Microsoft Information Protection SDK - Concepts du moteur du SDK de protection

Implémentation : Ajouter un moteur de protection

Dans le Kit de développement logiciel (SDK) File, la mip::ProtectionProfile classe est la classe racine pour toutes les opérations du Kit de développement logiciel (SDK). Après avoir déjà créé le profil, nous pouvons maintenant ajouter un moteur au profil.

L’exemple ci-dessous illustre l’utilisation d’un seul moteur pour un utilisateur authentifié unique.

Implémentation : Créer des paramètres du moteur de protection

Comme pour un profil, le moteur nécessite également un objet de paramètres. mip::ProtectionEngine::Settings Cet objet stocke l’identificateur de moteur unique, les données client personnalisables qui peuvent être utilisées pour le débogage ou la télémétrie, et éventuellement les paramètres régionaux.

Ici, nous créons un ProtectionEngine::Settings objet appelé engineSettings.

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

Note

Si vous utilisez cette méthode pour créer l’objet de paramètres de protection, vous devez également définir manuellement l’identité sur ProtectionEngineSettings setIdentity() via ou l’environnement cloud cible via setCloud().

Comme meilleure pratique, le premier paramètre, ID, doit être un élément qui permet au moteur d’être facilement connecté à l’utilisateur associé ou à un mip::Identity objet. Pour initialiser les paramètres avec mip::Identity:

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

Lors de la création de engineSettings de cette manière, il est important de définir explicitement un engineId unique via :

engineSettings.SetEngineId(engineId);

L’utilisation du nom d’utilisateur ou de l’e-mail permet de s’assurer que le même moteur est chargé chaque fois que l’utilisateur utilise le service ou l’application.

Implémentation : Ajouter le moteur de protection

Pour ajouter le moteur, nous reviendrons au modèle Future/Promise utilisé pour charger le profil. Au lieu de créer la promesse pour mip::ProtectionProfile, nous allons utiliser 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();

Le résultat final du code ci-dessus est que nous avons ajouté un moteur pour l’utilisateur authentifié au profil.

Implémentation : Modèles de liste

À l’aide du moteur ajouté, il est désormais possible de répertorier tous les modèles de confidentialité disponibles pour l’utilisateur authentifié en appelant engine->GetTemplatesAsync().

GetTemplatesAsync() récupère la liste des identificateurs de modèles. Le résultat est stocké dans un vecteur de std::shared_ptr<std::string>.

Implémentation : 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();

Implémentation : Imprimer les ID de modèle

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

L’impression des noms est un moyen simple de montrer que nous avons extrait correctement la stratégie du service et que nous avons pu obtenir les modèles. Pour appliquer le modèle, l’identificateur du modèle est requis.

L’association de modèles à des étiquettes ne peut être effectuée qu’à l’aide du SDK de stratégie, en examinant le résultat de ComputeActions().

Prochaines étapes

Maintenant que le profil est chargé, que le moteur a été ajouté et que nous disposons de modèles, nous pouvons ajouter un gestionnaire pour commencer à lire, écrire ou supprimer des modèles dans des fichiers. Consultez les concepts du gestionnaire de protection.