Configurer des connexions sans mot de passe entre plusieurs applications et services Azure

Les applications nécessitent souvent des connexions sécurisées entre plusieurs services Azure simultanément. Par exemple, une instance Azure App Service d’entreprise peut se connecter à plusieurs comptes de stockage différents, une instance de base de données Azure SQL, un Service Bus, etc.

Les identités managées sont l’option d’authentification recommandée pour les connexions sécurisées sans mot de passe entre les ressources Azure. Les développeurs n’ont pas à suivre et gérer manuellement de nombreux secrets différents pour les identités managées, car la plupart de ces tâches sont gérées en interne par Azure. Ce didacticiel explique comment gérer les connexions entre plusieurs services à l’aide d’identités managées et de la bibliothèque cliente Azure Identity.

Comparer les types d’identités managées

Azure fournit les types d’identités managées suivantes :

• Les identités managées affectées par le système sont directement liées à une seule ressource Azure. Lorsque vous activez une identité managée affectée par le système sur un service, Azure crée une identité liée et gère les tâches administratives pour cette identité en interne. Quand la ressource Azure est supprimée, l’identité l’est aussi.
• Les identités managées affectées par l’utilisateur sont des identités indépendantes créées par un administrateur et peuvent être associées à une ou plusieurs ressources Azure. Le cycle de vie de l’identité est indépendant de ces ressources.

Vous pouvez en savoir plus sur les meilleures pratiques et quand utiliser des identités managées affectées par le système et des identités managées affectées par l’utilisateur dans les recommandations de meilleures pratiques des identités managées.

Explorer DefaultAzureCredential

Les identités managées sont plus facilement implémentées dans votre code d’application via une classe appelée DefaultAzureCredential à partir de la bibliothèque de client Azure Identity. DefaultAzureCredential prend en charge plusieurs mécanismes d’authentification et détermine automatiquement celle qui doit être utilisée au moment de l’exécution. En savoir plus sur DefaultAzureCredential pour les écosystèmes suivants :

• .NET
• Java
• Node.JS
• Python

Connecter une application hébergée sur Azure à plusieurs services Azure

Imaginez que vous avez été chargé de connecter une application existante à plusieurs services et bases de données Azure à l’aide de connexions sans mot de passe. L’application est une API web ASP.NET Core hébergée sur Azure App Service, bien que les étapes ci-dessous s’appliquent également à d’autres environnements d’hébergement Azure, tels qu’Azure Spring Apps, Machines Virtuelles, Container Apps et AKS.

Ce didacticiel s’applique aux architectures suivantes, bien qu’il puisse être adapté à de nombreux autres scénarios ainsi qu’à des modifications de configuration minimales.

Les étapes suivantes montrent comment configurer une application pour utiliser une identité managée affectée par le système et votre compte de développement local pour se connecter à plusieurs services Azure.

Créer une identité managée affectée par le système

1. Dans le Portail Azure, accédez à l’application hébergée que vous souhaitez vous connecter à d’autres services.

2. Sur la page vue d’ensemble du service, sélectionnez Identité.

3. Basculez le paramètre d’Etat sur Activé pour activer une identité managée affectée par le système pour le service.

   

Attribuer des rôles à l’identité managée pour chaque service connecté

1. Accédez à la page vue d’ensemble du compte de stockage auquel vous souhaitez accorder l’accès à votre identité.

2. Sélectionnez Contrôle d’accès (IAM) à partir de la navigation du compte de stockage.

3. Choisissez + Ajouter, puis Ajouter une attribution de rôle.

   

4. Dans la zone de recherche de Rôle, recherchez le Contributeur de données Blob de stockage, qui accorde des autorisations pour effectuer des opérations de lecture et d’écriture sur les données d’objets blob. Vous pouvez attribuer le rôle approprié pour votre cas d’usage. Sélectionnez le contributeur de données blob de stockage dans la liste, puis choisissez Suivant.

5. Sur l’écran Ajouter une attribution de rôle, pour l’option Attribuer l’accès à l’option , sélectionnez Identité managée. Choisissez ensuite +Sélectionner des membres.

6. Dans le menu volant, recherchez l’identité managée que vous avez créée en entrant le nom de votre App Service. Sélectionnez l’identité affectée par le système, puis Sélectionner pour fermer le menu volant.

   

7. Sélectionnez Suivant plusieurs fois jusqu’à ce que vous puissiez sélectionner Vérifier + attribuer pour terminer l’attribution de rôle.

8. Répétez ce processus pour les autres services auxquels vous souhaitez vous connecter.

Considérations relatives au développement local

Vous pouvez également activer l’accès aux ressources Azure pour le développement local en affectant des rôles à un compte d’utilisateur de la même façon que vous avez attribué des rôles à votre identité managée.

1. Après avoir attribué le rôle Contributeur de données Blob de stockage à votre identité managée, sous Attribuer l’accès à, cette fois sélectionnez Utilisateur, groupe ou principal de service. Choisissez + Sélectionner des membres pour ouvrir à nouveau le menu volant.

2. Recherchez le compte user@domain ou le groupe de sécurité Microsoft Entra auquel vous souhaitez accorder l’accès par adresse e-mail ou par nom, puis sélectionnez-le. Il doit s’agir du même compte que celui que vous utilisez pour vous connecter à vos outils de développement local, tels que Visual Studio ou Azure CLI.

Remarque

Vous pouvez également attribuer ces rôles à un groupe de sécurité Microsoft Entra si vous travaillez sur une équipe avec plusieurs développeurs. Vous pouvez ensuite placer n’importe quel développeur dans ce groupe qui a besoin d’accéder au développement de l’application localement.

Implémenter le code de l’application

.NET

1. Dans votre projet, installez le package Azure.Identity. Cette bibliothèque fournit DefaultAzureCredential. Vous pouvez également ajouter toutes les autres bibliothèques Azure qui sont pertinentes pour votre application. Pour cet exemple, les packages Azure.Storage.Blobs et Azure.Messaging.ServiceBus sont ajoutés pour se connecter au stockage Blob et Service Bus, respectivement.

   dotnet add package Azure.Identity
   dotnet add package Azure.Messaging.ServiceBus
   dotnet add package Azure.Storage.Blobs
   

2. Instanciez les clients de service pour les services Azure auxquels votre application doit se connecter. L’exemple de code suivant interagit avec le Stockage Blob et Service Bus à l’aide des clients de service correspondants.

   using Azure.Identity;
   using Azure.Messaging.ServiceBus;
   using Azure.Storage.Blobs;
   
   // Create DefaultAzureCredential instance that uses system-assigned managed identity
   // in the underlying ManagedIdentityCredential.
   DefaultAzureCredential credential = new();
   
   BlobServiceClient blobServiceClient = new(
       new Uri("https://<your-storage-account>.blob.core.windows.net"),
       credential);
   
   ServiceBusClient serviceBusClient = new("<your-namespace>", credential);
   ServiceBusSender sender = serviceBusClient.CreateSender("producttracking");
   

Java

1. Dans votre projet, ajoutez la dépendance azure-identity à votre fichier pom.xml. Cette bibliothèque fournit DefaultAzureCredential. Vous pouvez également ajouter toutes les autres dépendances Azure qui sont pertinentes pour votre application. Pour cet exemple, les dépendances azure-storage-blob et azure-messaging-servicebus sont ajoutées pour interagir avec le Stockage Blob et Service Bus.

   <dependencyManagement>
     <dependencies>
       <dependency>
         <groupId>com.azure</groupId>
         <artifactId>azure-sdk-bom</artifactId>
         <version>1.2.5</version>
         <type>pom</type>
         <scope>import</scope>
       </dependency>
     </dependencies>
   </dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure</groupId>
       <artifactId>azure-identity</artifactId>
     </dependency>
     <dependency>
       <groupId>com.azure</groupId>
       <artifactId>azure-storage-blob</artifactId>
     </dependency>
     <dependency>
       <groupId>com.azure</groupId>
       <artifactId>azure-messaging-servicebus</artifactId>
     </dependency>
   </dependencies>
   

2. Instanciez les clients de service pour les services Azure auxquels votre application doit se connecter. L’exemple de code suivant interagit avec le Stockage Blob et Service Bus à l’aide des clients de service correspondants.

   class Demo {
       public static void main(String[] args) {
           // Create DefaultAzureCredential instance that uses system-assigned managed identity
           // in the underlying ManagedIdentityCredential.
           DefaultAzureCredential credential = new DefaultAzureCredentialBuilder()
               .build();
   
           BlobServiceClient blobServiceClient = new BlobServiceClientBuilder()
               .endpoint("https://<your-storage-account>.blob.core.windows.net")
               .credential(credential)
               .buildClient();
   
           ServiceBusClientBuilder clientBuilder = new ServiceBusClientBuilder()
               .credential(credential);
           ServiceBusSenderClient serviceBusSenderClient = clientBuilder.sender()
               .queueName("producttracking")
               .buildClient();
       }
   }
   

Spring

1. Dans votre projet, vous devez uniquement ajouter les dépendances de service que vous utilisez. Pour cet exemple, les dépendances spring-cloud-azure-starter-storage-blob et spring-cloud-azure-starter-servicebus sont ajoutées pour se connecter au Stockage Blob et à Service Bus.

   <dependencyManagement>
     <dependencies>
       <dependency>
         <groupId>com.azure.spring</groupId>
         <artifactId>spring-cloud-azure-dependencies</artifactId>
         <version>4.5.0</version>
         <type>pom</type>
         <scope>import</scope>
       </dependency>
     </dependencies>
   </dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-starter-storage-blob</artifactId>
     </dependency>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-starter-servicebus</artifactId>
     </dependency>
   </dependencies>
   

2. Instanciez les clients de service pour les services Azure auxquels votre application doit se connecter. Les exemples suivants se connectent au Stockage Blob et à Service Bus à l’aide des clients des services correspondants.

   spring:
     cloud:
       azure:
         servicebus:
           namespace: <service-bus-name>
           entity-name: <service-bus-entity-name>
           entity-type: <service-bus-entity-type>
         storage:
           blob:
             account-name: <storage-account-name>
   

   @Service
   public class ExampleService {
       @Autowired
       private BlobServiceClient blobServiceClient;
   
       @Autowired
       private ServiceBusSenderClient serviceBusSenderClient;
   }
   

Node.JS

1. Dans votre projet, installez le package @azure/identity. Cette bibliothèque fournit DefaultAzureCredential. Pour cet exemple, les packages @azure/storage-blob et @azure/service-bus sont installés pour interagir avec le Stockage Blob et Service Bus.

   npm install --save @azure/identity @azure/storage-blob @azure/service-bus
   

2. Instanciez les clients de service pour les services Azure auxquels votre application doit se connecter. L’exemple de code suivant interagit avec le Stockage Blob et Service Bus à l’aide des clients de service correspondants.

   import { DefaultAzureCredential } from "@azure/identity";
   import { BlobServiceClient } from "@azure/storage-blob";
   import { ServiceBusClient } from "@azure/service-bus";
   
   // Azure resource names
   const storageAccount = process.env.AZURE_STORAGE_ACCOUNT_NAME;
   const serviceBusNamespace = process.env.AZURE_SERVICE_BUS_NAMESPACE;
   
   // Create DefaultAzureCredential instance that uses system-assigned managed identity
   // in the underlying ManagedIdentityCredential.
   const credential = new DefaultAzureCredential();
   
   // Create client for Blob Storage
   const blobServiceClient = new BlobServiceClient(
     `https://${storageAccount}.blob.core.windows.net`,
     credential
   );
   
   // Create client for Service Bus
   const serviceBusClient = new ServiceBusClient(
     `https://${serviceBusNamespace}.servicebus.windows.net`,
     credential
   );
   

Python

1. Dans votre projet, ajoutez une référence au package azure-identity. Cette bibliothèque fournit DefaultAzureCredential. Vous pouvez également ajouter toutes les autres bibliothèques Azure qui sont pertinentes pour votre application. Pour cet exemple, les packages azure-storage-blob et azure-service-bus sont ajoutés pour se connecter au stockage Blob et Service Bus, respectivement.

   pip install azure-identity azure-servicebus azure-storage-blob
   

2. Instanciez les clients de service pour les services Azure auxquels votre application doit se connecter. L’exemple de code suivant interagit avec le Stockage Blob et Service Bus à l’aide des clients de service correspondants.

   from azure.identity import DefaultAzureCredential
   from azure.servicebus import ServiceBusClient, ServiceBusMessage
   from azure.storage.blob import BlobServiceClient
   import os
   
   # Create DefaultAzureCredential instance that uses system-assigned managed identity
   # in the underlying ManagedIdentityCredential.
   credential = DefaultAzureCredential()
   
   blob_service_client = BlobServiceClient(
       account_url="https://<my-storage-account-name>.blob.core.windows.net/",
       credential=credential
   )
   
   fully_qualified_namespace = os.environ['SERVICEBUS_FULLY_QUALIFIED_NAMESPACE']
   queue_name = os.environ['SERVICE_BUS_QUEUE_NAME']
   
   with ServiceBusClient(fully_qualified_namespace, credential) as service_bus_client:
       with service_bus_client.get_queue_sender(queue_name) as sender:
           # Sending a single message
           single_message = ServiceBusMessage("Single message")
           sender.send_messages(single_message)
   

Lorsque ce code s’exécute localement, DefaultAzureCredential recherche sa chaîne d’informations d’identification pour obtenir les premières informations d’identification disponibles. Si la variable d’environnement Managed_Identity_Client_ID est nulle localement, les informations d’identification correspondant à un outil de développement installé localement sont utilisées. Par exemple, Azure CLI ou Visual Studio. Pour en savoir plus sur ce processus, consultez la section Explorer DefaultAzureCredential.

Lorsque l’application est déployée sur Azure, DefaultAzureCredential récupère automatiquement la variable Managed_Identity_Client_ID à partir de l’environnement App Service. Cette valeur devient disponible lorsqu’une identité managée est associée à votre application.

Ce processus global garantit que votre application peut s’exécuter en toute sécurité localement et dans Azure sans avoir besoin de modifications de code.

Connectez plusieurs applications à l’aide de plusieurs identités managées

Bien que les applications de l’exemple précédent partagent les mêmes exigences d’accès au service, les environnements réels sont souvent plus nuancés. Envisagez un scénario où plusieurs applications se connectent aux mêmes comptes de stockage, mais deux des applications accèdent également à différents services ou bases de données.

Pour configurer cette configuration dans votre code, assurez-vous que votre application inscrit des clients de services distincts pour se connecter à chaque compte de stockage ou base de données. Faites référence aux ID du client d’identité managée corrects pour chaque service lors de la configuration de DefaultAzureCredential. Les exemples de code suivants configurent ces connexions de service Azure :

• Deux connexions à des comptes de stockage distincts à l’aide d’une identité managée affectée par l’utilisateur partagé
• Connexion aux services Azure Cosmos DB et Azure SQL à l’aide d’une deuxième identité managée affectée par l’utilisateur. Cette identité managée est partagée lorsque le pilote client Azure SQL l’autorise. Pour plus d'informations, consultez les commentaires du code.

.NET

1. Dans votre projet, installez les packages nécessaires. La bibliothèque Azure Identity fournit DefaultAzureCredential.

   dotnet add package Azure.Identity
   dotnet add package Azure.Storage.Blobs
   dotnet add package Microsoft.Azure.Cosmos
   dotnet add package Microsoft.Data.SqlClient
   

2. Ajoutez ce qui suit à votre code :

   using Azure.Core;
   using Azure.Identity;
   using Azure.Storage.Blobs;
   using Microsoft.Azure.Cosmos;
   using Microsoft.Data.SqlClient;
   
   string clientIdStorage =
       Environment.GetEnvironmentVariable("Managed_Identity_Client_ID_Storage")!;
   
   // Create a DefaultAzureCredential instance that configures the underlying
   // ManagedIdentityCredential to use a user-assigned managed identity.
   DefaultAzureCredential credentialStorage = new(
       new DefaultAzureCredentialOptions
       {
           ManagedIdentityClientId = clientIdStorage,
       });
   
   // First Blob Storage client
   BlobServiceClient blobServiceClient1 = new(
       new Uri("https://<receipt-storage-account>.blob.core.windows.net"),
       credentialStorage);
   
   // Second Blob Storage client
   BlobServiceClient blobServiceClient2 = new(
       new Uri("https://<contract-storage-account>.blob.core.windows.net"),
       credentialStorage);
   
   string clientIdDatabases =
       Environment.GetEnvironmentVariable("Managed_Identity_Client_ID_Databases")!;
   
   // Create a DefaultAzureCredential instance that configures the underlying
   // ManagedIdentityCredential to use a user-assigned managed identity.
   DefaultAzureCredential credentialDatabases = new(
       new DefaultAzureCredentialOptions
       {
           ManagedIdentityClientId = clientIdDatabases,
       });
   
   // Create an Azure Cosmos DB client
   CosmosClient cosmosClient = new(
       Environment.GetEnvironmentVariable("COSMOS_ENDPOINT", EnvironmentVariableTarget.Process),
       credentialDatabases);
   
   // Open a connection to Azure SQL
   string connectionString =
       $"Server=<azure-sql-hostname>.database.windows.net;User Id={clientIdDatabases};Authentication=Active Directory Default;Database=<database-name>";
   
   using (SqlConnection connection = new(connectionString)
   {
       AccessTokenCallback = async (authParams, cancellationToken) =>
       {
           const string defaultScopeSuffix = "/.default";
           string scope = authParams.Resource.EndsWith(defaultScopeSuffix)
               ? authParams.Resource
               : $"{authParams.Resource}{defaultScopeSuffix}";
           AccessToken token = await credentialDatabases.GetTokenAsync(
               new TokenRequestContext([scope]),
               cancellationToken);
   
           return new SqlAuthenticationToken(token.Token, token.ExpiresOn);
       }
   })
   {
       connection.Open();
   }
   

Java

1. Ajoutez le code suivant à votre fichier pom.xml :

   <dependencyManagement>
     <dependencies>
       <dependency>
         <groupId>com.azure</groupId>
         <artifactId>azure-sdk-bom</artifactId>
         <version>1.2.5</version>
         <type>pom</type>
         <scope>import</scope>
       </dependency>
     </dependencies>
   </dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure</groupId>
       <artifactId>azure-identity</artifactId>
     </dependency>
     <dependency>
       <groupId>com.azure</groupId>
       <artifactId>azure-storage-blob</artifactId>
     </dependency>
     <dependency>
       <groupId>com.azure</groupId>
       <artifactId>azure-cosmos</artifactId>
     </dependency>
     <dependency>
       <groupId>com.microsoft.sqlserver</groupId>
       <artifactId>mssql-jdbc</artifactId>
       <version>11.2.1.jre17</version>
     </dependency>
   </dependencies>
   

2. Ajoutez ce qui suit à votre code :

   class Demo {
       public static void main(String[] args) {
           String clientIdStorage = System.getenv("Managed_Identity_Client_ID_Storage");
   
           // Create a DefaultAzureCredential instance that configures the underlying
           // ManagedIdentityCredential to use a user-assigned managed identity.
           DefaultAzureCredential credentialStorage = new DefaultAzureCredentialBuilder()
               .managedIdentityClientId(clientIdStorage)
               .build();
   
           // First Blob Storage client
           BlobServiceClient blobServiceClient1 = new BlobServiceClientBuilder()
               .endpoint("https://<receipt-storage-account>.blob.core.windows.net")
               .credential(credentialStorage)
               .buildClient();
   
           // Second Blob Storage client
           BlobServiceClient blobServiceClient2 = new BlobServiceClientBuilder()
               .endpoint("https://<contract-storage-account>.blob.core.windows.net")
               .credential(credentialStorage)
               .buildClient();
   
           String clientIdDatabases = System.getenv("Managed_Identity_Client_ID_Databases");
   
           // Create a DefaultAzureCredential instance that configures the underlying
           // ManagedIdentityCredential to use a user-assigned managed identity.
           DefaultAzureCredential credentialDatabases = new DefaultAzureCredentialBuilder()
               .managedIdentityClientId(clientIdDatabases)
               .build()
   
           // Create an Azure Cosmos DB client
           CosmosClient cosmosClient = new CosmosClientBuilder()
               .endpoint("https://<cosmos-db-account>.documents.azure.com:443/")
               .credential(credentialDatabases)
               .buildClient();
   
           // Open a connection to Azure SQL using a managed identity.
           // The DefaultAzureCredential instance stored in the credentialDatabases variable can't be 
           // used here, so sharing isn't possible between Cosmos DB and Azure SQL.
           String connectionUrl = "jdbc:sqlserver://<azure-sql-hostname>.database.windows.net:1433;"
               + "database=<database-name>;encrypt=true;trustServerCertificate=false;hostNameInCertificate=*.database"
               + ".windows.net;loginTimeout=30;Authentication=ActiveDirectoryMSI;";
           try {
               Connection connection = DriverManager.getConnection(connectionUrl);
               Statement statement = connection.createStatement();
           } catch (SQLException e) {
               e.printStackTrace();
           }
       }
   }
   

Spring

1. Ajoutez le code suivant à votre fichier pom.xml :

   <dependencyManagement>
     <dependencies>
       <dependency>
         <groupId>com.azure.spring</groupId>
         <artifactId>spring-cloud-azure-dependencies</artifactId>
         <version>4.5.0</version>
         <type>pom</type>
         <scope>import</scope>
       </dependency>
     </dependencies>
   </dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-starter-storage-blob</artifactId>
     </dependency>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-starter-cosmos</artifactId>
     </dependency>
     <dependency>
       <groupId>com.microsoft.sqlserver</groupId>
       <artifactId>mssql-jdbc</artifactId>
     </dependency>
     <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-jdbc</artifactId>
     </dependency>
   </dependencies>
   

2. Ajoutez le code suivant à votre fichier application.yml :

   spring:
     cloud:
       azure:
         cosmos:
           endpoint: https://<cosmos-db-account>.documents.azure.com:443/
           credential:
             client-id: <Managed_Identity_Client_ID_Databases>
             managed-identity-enabled: true
         storage:
           blob:
             endpoint: https://<contract-storage-account>.blob.core.windows.net
             credential:
               client-id: <Managed_Identity_Client_ID_Storage>
               managed-identity-enabled: true
     datasource:
       url: jdbc:sqlserver://<azure-sql-hostname>.database.windows.net:1433;database=<database-name>;encrypt=true;trustServerCertificate=false;hostNameInCertificate=*.database.windows.net;loginTimeout=30;Authentication=ActiveDirectoryMSI;
   

3. Ajoutez ce qui suit à votre code :

   Remarque

   Azure Spring Cloud ne prend pas en charge la configuration de plusieurs clients du même service, les exemples de code suivants créent plusieurs beans pour cette situation.

   @Configuration
   public class AzureStorageConfiguration {
       @Bean("secondBlobServiceClient")
       public BlobServiceClient secondBlobServiceClient(BlobServiceClientBuilder builder) {
           return builder.endpoint("https://<receipt-storage-account>.blob.core.windows.net")
               .buildClient();
       }
   
       @Bean("firstBlobServiceClient")
       public BlobServiceClient firstBlobServiceClient(BlobServiceClientBuilder builder) {
           return builder.buildClient();
       }
   }
   

   @Service
   public class ExampleService {
       @Autowired
       @Qualifier("firstBlobServiceClient")
       private BlobServiceClient blobServiceClient1;
   
       @Autowired
       @Qualifier("secondBlobServiceClient")
       private BlobServiceClient blobServiceClient2;
   
       @Autowired
       private CosmosClient cosmosClient;
   
       @Autowired
       private JdbcTemplate jdbcTemplate;
   }
   

Node.JS

1. Dans votre projet, installez les packages nécessaires. La bibliothèque Azure Identity fournit DefaultAzureCredential.

   npm install --save @azure/identity @azure/storage-blob @azure/cosmos tedious
   

2. Ajoutez ce qui suit à votre code :

   import { DefaultAzureCredential } from "@azure/identity";
   import { BlobServiceClient } from "@azure/storage-blob";
   import { CosmosClient } from "@azure/cosmos";
   import { Connection } from "tedious";
   
   // Create a DefaultAzureCredential instance that configures the underlying
   // ManagedIdentityCredential to use a user-assigned managed identity.
   const credentialStorage = new DefaultAzureCredential({
     managedIdentityClientId: process.env.MANAGED_IDENTITY_CLIENT_ID_STORAGE
   });
   
   // First Blob Storage client
   const blobServiceClient1 = new BlobServiceClient(
     `https://${process.env.AZURE_STORAGE_ACCOUNT_NAME_1}.blob.core.windows.net`,
     credentialStorage
   );
   
   // Second Blob Storage client
   const blobServiceClient2 = new BlobServiceClient(
     `https://${process.env.AZURE_STORAGE_ACCOUNT_NAME_2}.blob.core.windows.net`,
     credentialStorage
   );
   
   // Create a DefaultAzureCredential instance that configures the underlying
   // ManagedIdentityCredential to use a user-assigned managed identity.
   const credentialDatabases = new DefaultAzureCredential({
     managedIdentityClientId: process.env.MANAGED_IDENTITY_CLIENT_ID_DATABASES
   });
   
   // Create an Azure Cosmos DB client
   const cosmosClient = new CosmosClient({
     endpoint: process.env.COSMOS_ENDPOINT,
     credential: credentialDatabases
   });
   
   // Configure connection and connect to Azure SQL
   const config = {
     server: process.env.AZURE_SQL_SERVER,
     authentication: {
       type: 'azure-active-directory-access-token',
       options: {
         token: credentialDatabases.getToken("https://database.windows.net//.default").token
       }
     },
     options: {
       database: process.env.AZURE_SQL_DATABASE,
       encrypt: true
     }
   };
   
   const connection = new Connection(config);
   connection.connect();
   

Python

1. Dans votre projet, installez les packages nécessaires. La bibliothèque Azure Identity fournit DefaultAzureCredential.

   pip install azure-identity azure-storage-blob azure-cosmos pyodbc
   

2. Ajoutez ce qui suit à votre code :

   from azure.cosmos import CosmosClient
   from azure.identity import DefaultAzureCredential
   from azure.storage.blob import BlobServiceClient
   import os, pyodbc, struct
   
   # Create a DefaultAzureCredential instance that configures the underlying
   # ManagedIdentityCredential to use a user-assigned managed identity.
   credential_storage = DefaultAzureCredential(
       managed_identity_client_id=os.environ['Managed_Identity_Client_ID_Storage']
   )
   
   # First Blob Storage client
   blob_service_client_1 = BlobServiceClient(
       account_url="https://<receipt-storage-account>.blob.core.windows.net/",
       credential=credential_storage
   )
   
   # Second Blob Storage client
   blob_service_client_2 = BlobServiceClient(
       account_url="https://<contract-storage-account>.blob.core.windows.net/",
       credential=credential_storage
   )
   
   # Create a DefaultAzureCredential instance that configures the underlying
   # ManagedIdentityCredential to use a user-assigned managed identity.
   credential_databases = DefaultAzureCredential(
       managed_identity_client_id=os.environ['Managed_Identity_Client_ID_Databases']
   )
   
   # Create an Azure Cosmos DB client
   cosmos_client = CosmosClient(
       os.environ['COSMOS_ENDPOINT'],
       credential=credential_databases
   )
   
   # Connect to Azure SQL
   token_bytes = credential_databases.get_token("https://database.windows.net/.default").token.encode("UTF-16-LE")
   token_struct = struct.pack(f'<I{len(token_bytes)}s', len(token_bytes), token_bytes)
   SQL_COPT_SS_ACCESS_TOKEN = 1256  # This connection option is defined by microsoft in msodbcsql.h
   conn = pyodbc.connect(connection_string, attrs_before={SQL_COPT_SS_ACCESS_TOKEN: token_struct})
   

Vous pouvez également associer une identité managée affectée par l’utilisateur et une identité managée affectée par le système à une ressource simultanément. Cela peut être utile dans les scénarios où toutes les applications nécessitent l’accès aux mêmes services partagés, mais l’une des applications a également une dépendance spécifique sur un service supplémentaire. L’utilisation d’une identité managée affectée par le système garantit également que l’identité liée à cette application spécifique est supprimée lorsque l’application est supprimée, ce qui peut vous aider à nettoyer votre environnement.

Ces types de scénarios sont explorés plus en détail dans les recommandations de meilleures pratiques des identités managées.

Étapes suivantes

Dans ce didacticiel, vous avez appris à migrer une application vers des connexions sans mot de passe. Consultez les ressources suivantes pour explorer les concepts abordés dans cet article plus en détails :

• Autoriser l’accès aux objets blob à l’aide Microsoft Entra ID
• Pour plus d’informations sur .NET, consultez Démarrer avec .NET en 10 minutes.