Mulai cepat: Inisialisasi aplikasi klien - Policy SDK (C++)

Panduan cepat ini menunjukkan kepada Anda cara menerapkan pola inisialisasi klien yang digunakan oleh Policy SDK dalam MIP C++ SDK pada waktu proses.

Prasyarat

Jika Anda belum melakukannya, pastikan untuk:

• Selesaikan langkah-langkah dalam penyiapan dan konfigurasi SDK Microsoft Information Protection (MIP).
• Secara opsional:
  • Tinjau Profil dan objek mesin.
  • Tinjau konsep Autentikasi.
  • Tinjau konsep Observer.

Membuat solusi dan proyek Visual Studio

1. Buka Visual Studio 2022 atau yang lebih baru, pilih menu File , Baru, Proyek.

   • Pilih Aplikasi Konsol di bawah templat C++.
   • Berikan Nama dan Lokasi untuk proyek.

2. Tambahkan paket NuGet untuk SDK Kebijakan MIP ke proyek Anda:

   • Di Penjelajah Solusi, klik kanan simpul proyek dan pilih Kelola paket NuGet....
   • Pilih Telusuri dan masukkan "Microsoft.InformationProtection" di kotak pencarian.
   • Pilih paket Microsoft.InformationProtection.Policy dan klik Instal.

Menerapkan kelas pengamat

Buat implementasi dasar untuk kelas pengamat profil Kebijakan dengan memperluas kelas SDK mip::PolicyProfile::Observer .

1. Tambahkan kelas baru ke proyek Anda bernama profile_observer.

2. Ganti isi dari 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. Ganti isi dari 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);
   }
   

Menerapkan delegasi autentikasi dan fungsi utama

1. Tambahkan kelas baru ke proyek Anda bernama auth_delegate. Lihat Konsep autentikasi untuk detail tentang mengimplementasikan mip::AuthDelegate antarmuka.

2. Perbarui main() untuk membuat MipContext, muat PolicyProfile, dan tambahkan 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. Bangun dan uji. Aplikasi harus berhasil menginisialisasi dan menyambungkan ke layanan Kebijakan.

Langkah berikutnya

• Mencantumkan label sensitivitas (Policy SDK - C++)
• Profil SDK kebijakan dan konsep mesin