Autenticación de aplicaciones de C++ hospedadas Azure para Azure recursos mediante una identidad administrada asignada por el usuario

El enfoque recomendado para autenticar una aplicación hospedada Azure en otros recursos de Azure consiste en usar una identidad administrada. Este enfoque es compatible con la mayoría de los servicios Azure, incluidas las aplicaciones hospedadas en Azure App Service, Azure Container Apps y Azure Virtual Machines. Obtenga más información sobre las distintas técnicas y enfoques de autenticación en la página de información general de autenticación . En las secciones siguientes, aprenderá lo siguiente:

• Conceptos esenciales de identidad administrada
• Creación de una identidad administrada asignada por el usuario para la aplicación
• Asignación de roles a la identidad administrada asignada por el usuario
• Cómo autenticar utilizando la identidad administrada asignada al usuario desde el código de tu aplicación

Conceptos esenciales de identidad administrada

Una identidad administrada permite a la aplicación conectarse de forma segura a otros recursos de Azure sin el uso de claves secretas u otros secretos de aplicación. Internamente, Azure realiza un seguimiento de la identidad y a qué recursos puede conectarse. Azure usa esta información para obtener automáticamente tokens de Microsoft Entra para la aplicación para permitir que se conecte a otros recursos de Azure.

Hay dos tipos de identidades administradas que se deben tener en cuenta al configurar la aplicación hospedada:

• Las identidades administradas asignadas por el sistema están habilitadas directamente en un recurso Azure y están vinculadas a su ciclo de vida. Cuando se elimina el recurso, Azure elimina la identidad automáticamente. Las identidades asignadas por el sistema proporcionan un enfoque minimalista para usar identidades administradas.
• Identidades administradas asignadas por el usuario se crean como recursos de Azure independientes y ofrecen mayor flexibilidad y capacidades. Son ideales para soluciones que implican varios recursos de Azure que necesitan compartir la misma identidad y permisos. Por ejemplo, si varias máquinas virtuales necesitan acceder al mismo conjunto de recursos de Azure, una identidad administrada asignada por el usuario proporciona reutilizabilidad y administración optimizada.

En las secciones siguientes se describen los pasos para habilitar y usar una identidad administrada asignada por el usuario para una aplicación hospedada Azure. Si necesita usar una identidad administrada asignada por el sistema, visite el artículo identidades administradas asignadas por el sistema para obtener más información.

Creación de una identidad administrada asignada por el usuario

Las identidades administradas asignadas por el usuario se crean como recursos independientes en la suscripción de Azure mediante el portal de Azure o el Azure CLI. Los comandos de Azure CLI se pueden ejecutar en el Azure Cloud Shell o en una estación de trabajo con el Azure CLI instalado.

az identity create \
    --resource-group <resource-group-name> \
    --name <identity-name> \
    --query 'clientId' \
    --output json

az identity show \
    --resource-group <your-resource-group> \
    --name <your-managed-identity-name> \
    --output json

Asigna la identidad administrada a tu aplicación

Una identidad administrada asignada por el usuario se puede asociar a uno o varios recursos Azure. Todos los recursos que usan esa identidad obtienen los permisos aplicados a través de los roles de la identidad.

Asignación de roles a la identidad administrada

A continuación, determine qué roles necesita la aplicación y asígnelos a la identidad administrada. Puede asignar roles a una identidad administrada en los ámbitos siguientes:

• Recurso: los roles asignados solo se aplican a ese recurso específico.
• grupo de recursos: los roles asignados se aplican a todos los recursos contenidos en el grupo de recursos.
• Suscripción: Los roles asignados se aplican a todos los recursos contenidos en la suscripción.

En el ejemplo siguiente se muestra cómo asignar roles en el ámbito del grupo de recursos, ya que muchas aplicaciones administran todos sus recursos relacionados Azure mediante un único grupo de recursos.

Autenticación a los servicios de Azure desde tu aplicación

La biblioteca Azure Identity proporciona varias credenciales, implementaciones de TokenCredential adaptadas para admitir diferentes escenarios y flujos de autenticación de Microsoft Entra. Dado que la identidad administrada no está disponible cuando se ejecuta localmente, los pasos siguientes muestran qué credencial usar en qué escenario:

• Entorno de desarrollo local: durante el desarrollo local solamente, use una clase denominada DefaultAzureCredential para una cadena de credenciales preconfigurada y con opiniones. DefaultAzureCredential detecta las credenciales de usuario de las herramientas o ide locales, como el Azure CLI o el Visual Studio. También proporciona flexibilidad y comodidad para reintentos, tiempos de espera para respuestas y compatibilidad con varias opciones de autenticación. Visite el artículo Autenticarse en los servicios de Azure durante el desarrollo local para más información.
• Aplicaciones hospedadas en Azure: Cuando la aplicación se ejecuta en Azure, use ManagedIdentityCredential para detectar de forma segura la identidad administrada configurada para la aplicación. Especificar este tipo exacto de credencial impide que otras credenciales disponibles se recojan inesperadamente.

Implementación del código

1. Agregue el paquete azure-identity-cpp a la aplicación mediante vcpkg.

   En un terminal de su elección, vaya al directorio del proyecto de aplicación y ejecute el siguiente comando:

   vcpkg add port azure-identity-cpp
   

2. Agregue lo siguiente en el archivo CMake:

   find_package(azure-identity-cpp CONFIG REQUIRED)
   target_link_libraries(<your project name> PRIVATE Azure::azure-identity)
   

3. Se accede a los servicios de Azure mediante clientes especializados de las distintas bibliotecas de clientes del SDK de Azure. Para cualquier código de C++ que cree una instancia de un cliente de Azure SDK en su aplicación, necesita:

   1. Incluya el azure/identity.hpp encabezado .
   2. Cree una instancia de DefaultAzureCredential.
   3. Pase la instancia de DefaultAzureCredential al constructor de cliente de Azure SDK.
   4. Establezca la variable de entorno AZURE_CLIENT_ID en el ID de cliente de la identidad administrada asignada por el usuario.
   5. Establezca la variable de AZURE_TOKEN_CREDENTIALS entorno en ManagedIdentityCredential para asegurarse de que DefaultAzureCredential usa la credencial de identidad administrada. Esta práctica hace que la autenticación sea más predecible y fácil de depurar cuando se implementa en Azure. Para obtener más información, consulte Uso de una credencial específica.

   En el siguiente segmento de código se muestra un ejemplo de estos pasos con un cliente de blobs de Azure Storage.

   #include <azure/identity.hpp>
   #include <azure/storage/blobs.hpp>
   #include <iostream>
   #include <memory>
   #include <cstdlib>
   
   int main() {
       try {
           // Set the AZURE_CLIENT_ID environment variable to your user-assigned managed identity client ID
           // This can be done in your deployment environment or in code (shown below for demonstration)
           // std::putenv("AZURE_CLIENT_ID=your-user-assigned-identity-client-id");
   
           // Create a credential - DefaultAzureCredential will use the AZURE_CLIENT_ID environment variable
           // Create a credential - DefaultAzureCredential will use the AZURE_CLIENT_ID and AZURE_TOKEN_CREDENTIALS environment variables
           auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>(true);
   
           // Create a client for the specified storage account
           std::string accountUrl = "https://<replace_with_your_storage_account_name>.blob.core.windows.net/";
           Azure::Storage::Blobs::BlobServiceClient blobServiceClient(accountUrl, credential);
   
           // Get a reference to a container
           std::string containerName = "sample-container";
           auto containerClient = blobServiceClient.GetBlobContainerClient(containerName);
   
           // Get a reference to a blob
           std::string blobName = "sample-blob";
           auto blobClient = containerClient.GetBlobClient(blobName);
   
           // TODO: perform some action with the blob client
           // auto downloadResult = blobClient.DownloadTo("path/to/local/file");
   
           std::cout << "Successfully authenticated using user-assigned managed identity." << std::endl;
   
       } catch (const std::exception& ex) {
           std::cout << "Exception: " << ex.what() << std::endl;
           return 1;
       }
   
       return 0;
   }
   

Como se describe en el artículo Azure SDK para la información general sobre la autenticación de C++, DefaultAzureCredential admite varios métodos de autenticación y determina el método de autenticación que se usa en tiempo de ejecución. La ventaja de este enfoque es que la aplicación puede usar diferentes métodos de autenticación en distintos entornos sin implementar código específico del entorno. Cuando el código anterior se ejecuta en la estación de trabajo durante el desarrollo local, DefaultAzureCredential usa un principal de servicio de aplicación, según lo determinado por la configuración del entorno o las credenciales de herramientas de desarrollo para autenticarse con otros recursos de Azure. Por lo tanto, se puede usar el mismo código para autenticar la aplicación en Azure recursos durante el desarrollo local y cuando se implementa en Azure.

Una alternativa a DefaultAzureCredential es usar ManagedIdentityCredential. Los pasos para usar ManagedIdentityCredential son los mismos que para usar el DefaultAzureCredential tipo .

En el siguiente segmento de código se muestra un ejemplo de estos pasos con un cliente de blobs de Azure Storage.

#include <azure/identity.hpp>
#include <azure/storage/blobs.hpp>
#include <iostream>
#include <memory>

int main() {
    try {
        // Create a user-assigned managed identity credential with the client ID
        Azure::Identity::ManagedIdentityCredentialOptions options;
        options.ClientId = "abcd1234-..."; // Replace with your user-assigned managed identity client ID
        auto credential = std::make_shared<Azure::Identity::ManagedIdentityCredential>(options);
        
        // Create a client for the specified storage account
        std::string accountUrl = "https://<replace_with_your_storage_account_name>.blob.core.windows.net/";
        Azure::Storage::Blobs::BlobServiceClient blobServiceClient(accountUrl, credential);
        
        // Get a reference to a container
        std::string containerName = "sample-container";
        auto containerClient = blobServiceClient.GetBlobContainerClient(containerName);
        
        // Get a reference to a blob
        std::string blobName = "sample-blob";
        auto blobClient = containerClient.GetBlobClient(blobName);
        
        // TODO: perform some action with the blob client
        // auto downloadResult = blobClient.DownloadTo("path/to/local/file");
        
        std::cout << "Successfully authenticated using user-assigned managed identity." << std::endl;
        
    } catch (const std::exception& ex) {
        std::cout << "Exception: " << ex.what() << std::endl;
        return 1;
    }
    
    return 0;
}