Microsoft Information Protection SDK - Concetti relativi al motore di Protection SDK

Articolo
01/30/2024

Implementazione: aggiungere un motore di protezione

In File SDK la mip::ProtectionProfile classe è la classe radice per tutte le operazioni SDK. Dopo aver già creato il profilo, è ora possibile aggiungere un motore al profilo.

L'esempio seguente illustra l'uso di un singolo motore per un singolo utente autenticato.

Implementazione: creare Impostazioni del motore di protezione

Analogamente a un profilo, il motore richiede anche un oggetto impostazioni, mip::ProtectionEngine::Settings. Questo oggetto archivia l'identificatore univoco del motore, i dati client personalizzabili che possono essere usati per il debug o la telemetria e, facoltativamente, le impostazioni locali.

Qui viene creato un ProtectionEngine::Settings oggetto denominato motore Impostazioni.

ProtectionEngine::Settings engineSettings("UniqueID", "");

Nota

Se si usa questo metodo per creare l'oggetto impostazioni di protezione, è anche necessario impostare manualmente l'identità in ProtectionEngine Impostazioni tramite setIdentity() o l'ambiente cloud di destinazione tramite setCloud().

Come procedura consigliata, il primo parametro, id, deve essere qualcosa che consente al motore di essere facilmente connesso all'utente associato o a un mip::Identity oggetto. Per inizializzare le impostazioni con mip::Identity:

ProtectionEngine::Settings engineSettings(mip::Identity("Bob@Contoso.com", "");

Quando si crea il motore Impostazioni in questo modo, è importante impostare in modo esplicito anche un engineId univoco tramite:

engineSettings.SetEngineId(engineId);

L'uso del nome utente o del messaggio di posta elettronica consente di assicurarsi che lo stesso motore venga caricato ogni volta che l'utente usa il servizio o l'applicazione.

Implementazione: aggiungere il motore di protezione

Per aggiungere il motore, si tornerà al modello futuro/promessa usato per caricare il profilo. Anziché creare la promessa per mip::ProtectionProfile, si userà mip::ProtectionEngine.


  //auto profile will be std::shared_ptr<mip::ProtectionProfile>
  auto profile = profileFuture.get();

  //Create the ProtectionEngine::Settings object
  ProtectionEngine::Settings engineSettings("UniqueID", "");

  //Create a promise for std::shared_ptr<mip::ProtectionEngine>
  auto enginePromise = std::make_shared<std::promise<std::shared_ptr<mip::ProtectionEngine>>>();

  //Instantiate the future from the promise
  auto engineFuture = enginePromise->get_future();

  //Add the engine using AddEngineAsync, passing in the engine settings and the promise
  profile->AddEngineAsync(engineSettings, enginePromise);

  //get the future value and store in std::shared_ptr<mip::ProtectionEngine>
  auto engine = engineFuture.get();

Il risultato finale del codice precedente è che è stato aggiunto un motore per l'utente autenticato al profilo.

Implementazione: Elencare i modelli

Usando il motore aggiunto, è ora possibile elencare tutti i modelli di riservatezza disponibili per l'utente autenticato chiamando engine->GetTemplatesAsync().

GetTemplatesAsync() recupererà l'elenco di identificatori di modelli. Il risultato viene archiviato in un vettore di std::shared_ptr<std::string>.

Implementazione: ListSensitivityTemplates()

auto loadPromise = std::make_shared<std::promise<shared_ptr<vector<string>>>>();
std::future<std::shared_ptr<std::vector<std::string>>> loadFuture = loadPromise->get_future();
mEngine->GetTemplatesAsync(engineObserver, loadPromise);
auto templates = loadFuture.get();

Implementazione: stampare gli ID modello

//Iterate through all template IDs in the vector
for (const auto& temp : *templates) {
  cout << "Template:" << "\n\tId: " << temp << endl;
}

La stampa dei nomi è un modo semplice per mostrare che i criteri sono stati estratti correttamente dal servizio e sono stati in grado di ottenere i modelli. Per applicare il modello, è necessario l'identificatore del modello.

Il mapping dei modelli alle etichette può essere eseguito solo tramite Policy SDK esaminando il risultato di ComputeActions().

Passaggi successivi

Ora che il profilo è stato caricato, il motore è stato aggiunto e sono disponibili modelli, è possibile aggiungere un gestore per iniziare a leggere, scrivere o rimuovere modelli dai file. Vedere Concetti relativi al gestore di protezione.

Condividi tramite