Rychlý start: Inicializace klientské aplikace – Sada Policy SDK (C++)

V tomto rychlém průvodci se dozvíte, jak implementovat vzor inicializace klienta používaný MIP C++ SDK při běhu programu.

Předpoklady

Pokud jste to ještě neudělali, nezapomeňte:

• Dokončete kroky v nastavení a konfiguraci sady Microsoft Information Protection (MIP) SDK.
• Volitelně:
  • Zkontrolujte objekty profilu a modulu.
  • Projděte si koncepty ověřování.
  • Přečtěte si koncepty pozorovatele.

Vytvoření řešení a projektu sady Visual Studio

1. Otevřete Visual Studio 2022 nebo novější, vyberte nabídku Soubor , Nový, Projekt.

   • V šablonách jazyka C++ vyberte konzolovou aplikaci .
   • Zadejte název a umístění projektu.

2. Do projektu přidejte balíček NuGet pro sadu MIP Policy SDK:

   • V Průzkumníku řešení klikněte pravým tlačítkem na uzel projektu a vyberte Spravovat balíčky NuGet....
   • Vyberte Procházet a do vyhledávacího pole zadejte "Microsoft.InformationProtection".
   • Vyberte balíček Microsoft.InformationProtection.Policy a klikněte na Nainstalovat.

Implementovat třídu pozorovatele

Vytvořte základní implementaci třídy pozorovatele profilu zásad rozšířením třídy SDK mip::PolicyProfile::Observer.

1. Přidejte novou třídu do projektu s názvem profile_observer.

2. Nahraďte obsah 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. Nahraďte obsah 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);
   }
   

Implementujte delegáta autentizace a hlavní funkci

1. Přidejte novou třídu do projektu s názvem auth_delegate. Podrobnosti o implementaci rozhraní najdete v mip::AuthDelegate.

2. Aktualizujte main(), vytvořte MipContext, načtěte PolicyProfile a přidejte 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. Sestavte a otestujte. Aplikace by se měla úspěšně inicializovat a připojit se ke službě Policy.

Další kroky

• Seznam popisků citlivosti (Policy SDK – C++)
• Koncepty profilu a modulu sady Policy SDK