Microsoft Information Protection SDK - Concetti relativi al motore dell'API ProtezioneMicrosoft Information Protection SDK - Protection API engine concepts

Implementazione: Aggiungere un motore di protezioneImplementation: Add a Protection Engine

Nell'API Protezione, la classe mip::ProtectionProfile è la classe radice per tutte le operazioni dell'SDK.In the File API, the mip::ProtectionProfile class is the root class for all SDK operations. Avendo già creato il profilo, è ora possibile aggiungere un motore al profilo.Having already created the profile, we can now add an engine to the profile.

L'esempio seguente illustra l'uso di un solo motore per un unico utente autenticato.The example below demonstrates using a single engine for a single authenticated user.

Implementazione: Creare le impostazioni del motore di protezioneImplementation: Create Protection Engine Settings

Analogamente a un profilo, anche per il motore è necessario un oggetto impostazioni, mip::ProtectionEngine::Settings.Similar to a profile, the engine also requires a settings object, 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.This object stores the unique engine identifier, customizable client data that can be used for debugging or telemetry, and, optionally, the locale.

Viene qui creato un oggetto ProtectionEngine::Settings chiamato engineSettings.Here we create a ProtectionEngine::Settings object called engineSettings.

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

Nota

Se si utilizza questo metodo per creare l'oggetto impostazioni di protezione, è inoltre necessario impostare manualmente CloudEndpointBaseUrl su https://api.aadrm.com o TP l'URL del cluster del servizio Active Directory Rights Management.If using this method to create the protection settings object, you must also manually set the CloudEndpointBaseUrl to https://api.aadrm.com or tp the Active Directory Rights Management Service cluster URL.

Come procedura consigliata, il primo parametro, id, deve essere tale da consentire di collegare il motore con facilità all'utente associato oppure a un oggetto mip::Identity.As a best practice, the first parameter, id, should be something that allows the engine to be easily connected to the associated user, or a mip::Identity object. Per inizializzare le impostazioni con mip::Identity:To initialize the settings with mip::Identity:

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

Implementazione: Aggiungere il motore di protezioneImplementation: Add the Protection Engine

Per aggiungere il motore, si tornerà al modello promise/future usato per caricare il profilo.To add the engine, we'll go back to the future/promise pattern used to load the profile. Invece di creare la promessa per mip::ProtectionProfile, si userà mip::ProtectionEngine.Instead of creating the promise for mip::ProtectionProfile, we'll use 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 è l'aggiunta di un motore per l'utente autenticato al profilo.The end result of the code above is that we've successfully added an engine for the authenticated user to the profile.

Implementazione: Elencare i modelliImplementation: List Templates

Tramite il motore aggiunto è ora possibile elencare tutti i modelli di riservatezza disponibili per l'utente autenticato chiamando engine->GetTemplatesAsync().Using the added engine, it's now possible to list all of the sensitivity templates available to the authenticated user by calling engine->GetTemplatesAsync().

GetTemplatesAsync() recupererà l'elenco degli identificatori dei modelli.GetTemplatesAsync() will fetch the list of templates identifiers. Il risultato viene archiviato in un vettore di std::shared_ptr<std::string>.The result is stored in a vector of std::shared_ptr<std::string>.

Implementazione: ListSensitivityTemplates()Implementation: 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 dei modelliImplementation: Print the Template Ids

//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 è stato eseguito correttamente il pull dei criteri dal servizio e si è riusciti a ottenere i modelli.Printing the names is an easy way to show that we successfully pulled policy from the service and were able to get the templates. Per applicare il modello, è necessario l'identificatore del modello.To apply the template, the template identifier is required.

Il mapping dei modelli alle etichette può essere eseguito solo tramite l'API Criteri, esaminando il risultato di ComputeActions().Mapping templates to labels can only be done via Policy API by examining the result of ComputeActions().

Passaggi successiviNext Steps

Ora che il profilo è caricato, il motore è stato aggiunto e sono disponibili modelli, è possibile aggiungere un gestore per iniziare a leggere, scrivere o rimuovere i modelli dai file.Now that the profile is loaded, the engine added, and we have templates, we can add a handler to begin to read, write, or remove templates from files. Vedere i concetti relativi al gestore della protezione.See Protection handler concepts.