SDK de Microsoft Information Protection: conceptos del motor del SDK de protección

Implementación: Agregar un motor de protección

En el SDK de archivos, la mip::ProtectionProfile clase es la clase raíz para todas las operaciones del SDK. Después de haber creado el perfil, ahora podemos agregar un motor al perfil.

En el ejemplo siguiente se muestra el uso de un solo motor para un único usuario autenticado.

Implementación: crear una configuración del motor de protección

De forma similar a un perfil, el motor también requiere un objeto de configuración, mip::ProtectionEngine::Settings. Este objeto almacena el identificador único del motor, los datos de cliente personalizables que se pueden usar para la depuración o telemetría, y, opcionalmente, la configuración regional.

Aquí se crea un ProtectionEngine::Settings objeto denominado engineSettings.

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

Como procedimiento recomendado, el primer parámetro, id, debe ser algo que permita que el motor se conecte fácilmente al usuario asociado o a un mip::Identity objeto. Para inicializar la configuración con mip::Identity:

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

Al crear engineSettings de esta manera, es importante establecer explícitamente un engineId único a través de:

engineSettings.SetEngineId(engineId);

El uso del nombre de usuario o el correo electrónico ayuda a asegurarse de que el mismo motor se carga cada vez que el usuario usa el servicio o la aplicación.

Implementación: Adición del motor de protección

Para agregar el motor, volveremos al patrón futuro/promesa usado para cargar el perfil. En lugar de crear la promesa para mip::ProtectionProfile, usaremos 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();

El resultado final del código anterior es que hemos agregado correctamente un motor para el usuario autenticado al perfil.

Implementación: Listar plantillas

Con el motor agregado, ahora es posible enumerar todas las plantillas de sensibilidad disponibles para el usuario autenticado haciendo una llamada a engine->GetTemplatesAsync().

GetTemplatesAsync() capturará la lista de identificadores de plantillas. El resultado se almacena en un vector de std::shared_ptr<std::string>.

Implementación: 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();

Implementación: imprimir los identificadores de plantillas

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

La impresión de los nombres es una manera fácil de mostrar que hemos extraído correctamente la directiva del servicio y hemos podido obtener las plantillas. Para aplicar la plantilla, se requiere el identificador de plantilla.

La asignación de plantillas a etiquetas solo se puede realizar mediante el SDK de directivas a través de un examen del resultado de ComputeActions().

Pasos siguientes

Ahora que se carga el perfil, el motor agregado y tenemos plantillas, podemos agregar un controlador para empezar a leer, escribir o quitar plantillas de archivos. Consulte Conceptos del controlador de protección.