Démarrage rapide : Initialisation de l’application cliente - Kit de développement logiciel (SDK) de stratégie (C++)

Ce démarrage rapide vous montre comment implémenter le modèle d’initialisation du client utilisé par le SDK de stratégie C++ MIP au moment de l’exécution.

Note

Les étapes décrites dans ce guide de démarrage rapide sont requises pour toute application cliente qui utilise le SDK de stratégie MIP. Ce guide de démarrage rapide doit être terminé après la mise en place et la configuration du Kit de développement logiciel (SDK) MIP.

Prerequisites

Si ce n’est déjà fait, veillez à :

Créer une solution et un projet Visual Studio

  1. Ouvrez Visual Studio 2022 ou version ultérieure, sélectionnez le menu Fichier , Nouveau, Projet.

    • Sélectionnez Application console sous modèles C++.
    • Indiquez un nom et un emplacement pour le projet.

  2. Ajoutez le package NuGet pour le SDK de stratégie MIP à votre projet :

    • Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le nœud du projet, puis sélectionnez Gérer les packages NuGet....
    • Sélectionnez Parcourir et entrez « Microsoft.InformationProtection » dans la zone de recherche.
    • Sélectionnez le package Microsoft.InformationProtection.Policy , puis cliquez sur Installer.

Implémenter une classe d’observateur

Créez une implémentation de base pour une classe observateur de profil de stratégie en étendant la classe mip::PolicyProfile::Observer du kit de développement logiciel (SDK).

  1. Ajoutez une nouvelle classe à votre projet nommé profile_observer.

  2. Remplacez le contenu 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. Remplacez le contenu 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);
}

Implémenter un délégué d’authentification et une fonction principale

  1. Ajoutez une nouvelle classe à votre projet nommé auth_delegate. Pour plus d’informations sur l’implémentation de l’interface, consultez les concepts d’authentificationmip::AuthDelegate.

  2. Mettre à jour main() pour créer le MipContext, charger un PolicyProfile et ajouter 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. Compiler et tester. L’application doit initialiser correctement et se connecter au service de stratégie.

Étapes suivantes

  • Last updated on