Hızlı Başlangıç Kılavuzu: İstemci Uygulaması Başlatma - Politika SDK (C++)

Bu hızlı başlangıçta, çalışma zamanında MIP C++ Policy SDK tarafından kullanılan istemci başlatma örüntüsünün nasıl uygulandığı gösterilmektedir.

Uyarı

MIP İlkesi SDK'sını kullanan tüm istemci uygulamaları bu hızlı başlangıçtaki adımlara ihtiyaç duyar. Başlamadan önce MIP SDK'sı ayarlama ve yapılandırma işlemini tamamlayın.

Önkoşullar

Henüz yapmadıysanız şunları yaptığınızdan emin olun:

Visual Studio çözümü ve projesi oluşturma

  1. Visual Studio 2022 veya sonraki bir sürümünü açın, Dosya menüsünü ( Yeni, Proje) seçin.

    • C++ şablonları altında Konsol Uygulaması'nı seçin.
    • Proje için bir Ad ve Konum belirtin.

  2. MIP İlkesi SDK'sı için NuGet paketini projenize ekleyin:

    • Çözüm Gezgini'de proje düğümüne sağ tıklayın ve NuGet paketlerini yönet...'i seçin.
    • Gözat'ı seçin ve arama kutusuna "Microsoft.InformationProtection" yazın.
    • Microsoft.InformationProtection.Policy paketini seçin ve Yükle seçeneğini belirleyin.

Gözlemci sınıfı uygulama

SDK'nın mip::PolicyProfile::Observer sınıfını genişleterek İlke profili gözlemci sınıfı için temel bir uygulama oluşturun.

  1. Projenize adlı profile_observeryeni bir sınıf ekleyin.

  2. öğesinin içeriğini değiştirin: 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. öğesinin içeriğini değiştirin: 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);
}

Kimlik doğrulama temsilcisi ve ana işlevi uygulama

  1. Projenize adlı auth_delegateyeni bir sınıf ekleyin. Kimlik doğrulama kavramları hakkında ayrıntılı bilgi için Arabirimi uygulamasını inceleyin.

  2. main() güncelleştirin ve MipContext öğesini oluşturun, bir PolicyProfile yükleyin ve bir PolicyEngine ekleyin:

    #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
    mip::ApplicationInfo appInfo{
        "your_app_id",                          // Application ID from Microsoft Entra app registration
        "MIP SDK Policy Quickstart",            // Friendly name
        "1.0"                                   // Version
    };

    auto mipConfiguration = make_shared<mip::MipConfiguration>(
        appInfo,                                // ApplicationInfo object
        "mip_data",                             // Path to store settings and logs
        mip::LogLevel::Trace,                   // Log level
        false,                                  // isOfflineOnly
        mip::CacheStorageType::OnDiskEncrypted  // Cache storage type
    );

    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,
        profileObserver
    );

    // Load Policy Profile
    auto profilePromise = make_shared<std::promise<shared_ptr<mip::PolicyProfile>>>();
    auto profileFuture = profilePromise->get_future();
    mip::PolicyProfile::LoadAsync(profileSettings, 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, 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. Oluştur ve test et. Uygulamanın başarıyla başlatılması ve İlke hizmetine bağlanması gerekir.

Sonraki Adımlar

  • Last updated on