Inicio rápido: Inicialización de aplicaciones cliente: SDK de directivas (C++)

En esta guía rápida se muestra cómo implementar el patrón de inicialización de cliente utilizado por el SDK de directivas del MIP C++ en tiempo de ejecución.

Nota:

Los pasos descritos en este inicio rápido son necesarios para cualquier aplicación cliente que use el SDK de directivas de MIP. Este inicio rápido debe completarse después de establecer y configurar el SDK de MIP.

Prerrequisitos

Si aún no lo ha hecho, asegúrese de:

Creación de una solución y un proyecto de Visual Studio

  1. Abra Visual Studio 2022 o posterior, seleccione el menú Archivo , Nuevo, Proyecto.

    • Seleccione Aplicación de consola en Plantillas de C++.
    • Proporcione un nombre y una ubicación para el proyecto.

  2. Agregue el paquete NuGet para el SDK de directivas de MIP al proyecto:

    • En el Explorador de soluciones, haga clic con el botón derecho en el nodo del proyecto y seleccione Administrar paquetes NuGet....
    • Seleccione Examinar y escriba "Microsoft.InformationProtection" en el cuadro de búsqueda.
    • Seleccione el paquete Microsoft.InformationProtection.Policy y haga clic en Instalar.

Implementa una clase de observador

Cree una implementación básica para una clase de observador de perfil de directiva extendiendo la clase del mip::PolicyProfile::Observer SDK.

  1. Agregue una nueva clase al proyecto denominado profile_observer.

  2. Reemplace el contenido de profile_observer.h:

    #include <memory>
#include "mip/upe/policy_profile.h"

class PolicyProfileObserver final : public mip::PolicyProfile::Observer {
public:
     PolicyProfileObserver() { }
     void OnLoadSuccess(const std::shared_ptr<mip::PolicyProfile>& profile, const std::shared_ptr<void>& context) override;
     void OnLoadFailure(const std::exception_ptr& error, const std::shared_ptr<void>& context) override;
     void OnAddEngineSuccess(const std::shared_ptr<mip::PolicyEngine>& engine, const std::shared_ptr<void>& context) override;
     void OnAddEngineFailure(const std::exception_ptr& error, const std::shared_ptr<void>& context) override;
};

  3. Reemplace el contenido de profile_observer.cpp:

    #include "profile_observer.h"
#include <future>

using std::promise;
using std::shared_ptr;
using std::exception_ptr;

void PolicyProfileObserver::OnLoadSuccess(const shared_ptr<mip::PolicyProfile>& profile, const shared_ptr<void>& context) {
     auto loadPromise = static_cast<promise<shared_ptr<mip::PolicyProfile>>*>(context.get());
     loadPromise->set_value(profile);
}

void PolicyProfileObserver::OnLoadFailure(const exception_ptr& error, const shared_ptr<void>& context) {
     auto loadPromise = static_cast<promise<shared_ptr<mip::PolicyProfile>>*>(context.get());
     loadPromise->set_exception(error);
}

void PolicyProfileObserver::OnAddEngineSuccess(const shared_ptr<mip::PolicyEngine>& engine, const shared_ptr<void>& context) {
     auto addEnginePromise = static_cast<promise<shared_ptr<mip::PolicyEngine>>*>(context.get());
     addEnginePromise->set_value(engine);
}

void PolicyProfileObserver::OnAddEngineFailure(const exception_ptr& error, const shared_ptr<void>& context) {
     auto addEnginePromise = static_cast<promise<shared_ptr<mip::PolicyEngine>>*>(context.get());
     addEnginePromise->set_exception(error);
}

Implementación de un delegado de autenticación y una función principal

  1. Agregue una nueva clase al proyecto denominado auth_delegate. Consulte Conceptos de autenticación para obtener más información sobre cómo implementar la mip::AuthDelegate interfaz.

  2. Actualice main() para crear MipContext, para cargar un PolicyProfile y agregue un PolicyEngine:

    #include "mip/mip_context.h"
#include "mip/upe/policy_profile.h"
#include "auth_delegate.h"
#include "profile_observer.h"

#include <iostream>
#include <future>

using std::cout;
using std::endl;
using std::make_shared;
using std::shared_ptr;

int main()
{
    // Construct/initialize objects required by the application's profile object
    auto mipConfiguration = make_shared<mip::MipConfiguration>(
        "your_app_id",                          // Application ID from Microsoft Entra app registration
        "MIP SDK Policy Quickstart",            // Friendly name
        "1.0",                                  // Version
        true                                    // GUID for each machine
    );

    auto mipContext = mip::MipContext::Create(mipConfiguration);

    auto profileObserver = make_shared<PolicyProfileObserver>();

    auto authDelegateImpl = make_shared<sample::auth::AuthDelegateImpl>("your_app_id");

    mip::PolicyProfile::Settings profileSettings(mipContext,
        mip::CacheStorageType::OnDiskEncrypted,
        authDelegateImpl
    );

    // Load Policy Profile
    auto profilePromise = make_shared<std::promise<shared_ptr<mip::PolicyProfile>>>();
    auto profileFuture = profilePromise->get_future();
    mip::PolicyProfile::LoadAsync(profileSettings, profileObserver, profilePromise);
    auto profile = profileFuture.get();

    // Add a Policy Engine
    mip::PolicyEngine::Settings engineSettings(
        mip::Identity("user@contoso.com"),
        authDelegateImpl,
        "",
        "en-US",
        false
    );

    auto enginePromise = make_shared<std::promise<shared_ptr<mip::PolicyEngine>>>();
    auto engineFuture = enginePromise->get_future();
    profile->AddEngineAsync(engineSettings, profileObserver, enginePromise);
    auto engine = engineFuture.get();

    // Application using Policy engine is ready. 
    // Engine can be used to list labels, compute actions, etc.

    cout << "Policy engine loaded successfully." << endl;

    return 0;
}

  3. Compilar y probar. La aplicación debe inicializarse correctamente y conectarse al servicio Policy.

Pasos siguientes

  • Last updated on