Kit de développement logiciel (SDK) Microsoft Information Protection - Concepts du moteur du kit de développement logiciel (SDK) Protection

Article
01/30/2024

Implémentation : Ajouter un moteur de protection

Dans le kit de développement logiciel (SDK) File, la classe mip::ProtectionProfile est la classe racine pour toutes les opérations du kit de développement logiciel (SDK). Ayant 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 les 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, la locale.

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

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

Remarque

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 via setIdentity() ou l’environnement cloud cible via setCloud().

En guise de meilleure pratique, le premier paramètre, id, doit être quelque chose qui permet au moteur d’être facilement connecté à l’utilisateur associé, ou à un objet mip::Identity. Pour initialiser les paramètres avec mip::Identity :

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

Lors de la création des engineSettings de cette façon, 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 allons revenir au modèle avenir/promesse 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 correctement 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érera 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 bien récupéré la stratégie depuis le service et que nous avons pu obtenir les modèles. Pour appliquer le modèle, l’identificateur du modèle est requis.

Le mappage de modèles aux étiquettes ne peut être effectué que via le kit de développement logiciel (SDK) Policy en examinant le résultat ComputeActions().

Étapes suivantes

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

Partager via