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 clase mip::ProtectionProfile es la clase raíz para todas las operaciones del SDK. Después de haber creado el perfil, 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í creamos un objeto ProtectionEngine::Settings denominado engineSettings.

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

Nota:

Si usa este método para crear el objeto de configuración de protección, también debe establecer manualmente la identidad en ProtectionEngineSettings a través de setIdentity() o el entorno de nube de destino a través de setCloud().

Como procedimiento recomendado, el primer parámetro, id, debe ser un elemento que permita que el motor se conecte fácilmente al usuario asociado o a un objeto mip::Identity. 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 de manera explícita un engineId único a través de:

engineSettings.SetEngineId(engineId);

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

Implementación: agregar el 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 en el perfil.

Implementación: enumerar las plantillas

Con el motor agregado, ya podemos enumerar todas las plantillas de confidencialidad disponibles para el usuario autenticado mediante 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 hemos cargado el perfil y agregado el motor, y tenemos plantillas, podemos agregar un controlador para empezar a leer, escribir o quitar plantillas de archivos. Consulte Conceptos del controlador de protección.