Configurare connessioni senza password tra più app e servizi di Azure

Le applicazioni richiedono spesso connessioni sicure tra più servizi di Azure contemporaneamente. Ad esempio, un'istanza del servizio app Azure aziendale potrebbe connettersi a diversi account di archiviazione, un'istanza del database SQL di Azure, un bus di servizio e altro ancora.

Le identità gestite sono l'opzione di autenticazione consigliata per connessioni sicure senza password tra le risorse di Azure. Gli sviluppatori non devono tenere traccia e gestire manualmente molti segreti diversi per le identità gestite, poiché la maggior parte di queste attività viene gestita internamente da Azure. Questa esercitazione illustra come gestire le connessioni tra più servizi usando identità gestite e la libreria client di Identità di Azure.

Confrontare i tipi di identità gestite

Azure offre i tipi di identità gestite seguenti:

• Le identità gestite assegnate dal sistema sono direttamente collegate a una singola risorsa di Azure. Quando si abilita un'identità gestita assegnata dal sistema in un servizio, Azure creerà un'identità collegata e gestirà le attività amministrative per tale identità internamente. Quando la risorsa di Azure viene eliminata, viene eliminata anche l'identità.
• Le identità gestite assegnate dall'utente sono identità indipendenti create da un amministratore e possono essere associate a una o più risorse di Azure. Il ciclo di vita dell'identità è indipendente da tali risorse.

Per altre informazioni sulle procedure consigliate e su quando usare le identità gestite assegnate dal sistema rispetto alle identità gestite assegnate dall'utente, vedere raccomandazioni sulle procedure consigliate per le identità gestite.

Esplorare DefaultAzureCredential

Le identità gestite vengono implementate più facilmente nel codice dell'applicazione tramite una classe chiamata DefaultAzureCredential dalla libreria client di Identità di Azure. DefaultAzureCredential supporta più meccanismi di autenticazione e determina automaticamente quali devono essere usati in fase di esecuzione. Altre informazioni sugli DefaultAzureCredential ecosistemi seguenti:

• .NET
• Java
• Node.js
• Python

Connettere un'app ospitata in Azure a più servizi di Azure

Si supponga di dover connettere un'app esistente a più servizi e database di Azure usando connessioni senza password. L'applicazione è un'API Web di ASP.NET Core ospitata nel servizio app Azure, anche se i passaggi seguenti si applicano anche ad altri ambienti di hosting di Azure, ad esempio App Spring di Azure, Macchine virtuali, App contenitore e servizio Azure Kubernetes.

Questa esercitazione si applica alle architetture seguenti, anche se può essere adattata a molti altri scenari e tramite modifiche minime alla configurazione.

La procedura seguente illustra come configurare un'app per l'uso di un'identità gestita assegnata dal sistema e dell'account di sviluppo locale per connettersi a più servizi di Azure.

Creare un'identità gestita assegnata dal sistema

1. Nella portale di Azure passare all'applicazione ospitata che si vuole connettere ad altri servizi.

2. Nella pagina di panoramica del servizio selezionare Identità.

3. Impostare Statosu Sì per abilitare un'identità gestita assegnata dal sistema per il servizio.

   

Assegnare ruoli all'identità gestita per ogni servizio connesso

1. Passare alla pagina di panoramica dell'account di archiviazione a cui si vuole concedere l'accesso all'identità.

2. Selezionare Controllo di accesso (IAM) nel riquadro di spostamento dell'account di archiviazione.

3. Scegliere + Aggiungi e quindi Aggiungi assegnazione di ruolo.

   

4. Nella casella di ricerca Ruolo cercare Collaboratore dati BLOB di archiviazione, che concede le autorizzazioni per eseguire operazioni di lettura e scrittura sui dati BLOB. È possibile assegnare qualsiasi ruolo appropriato per il caso d'uso. Selezionare Collaboratore dati BLOB di archiviazione nell'elenco e scegliere Avanti.

5. Nella schermata Aggiungi assegnazione di ruolo , per l’opzione Assegna accesso a, selezionare Identità gestita. Scegliere quindi +Seleziona membri.

6. Nel riquadro a comparsa cercare l'identità gestita creata immettendo il nome del servizio app. Selezionare l'identità assegnata dal sistema e quindi scegliere Seleziona per chiudere il menu a comparsa.

   

7. Selezionare Avanti un paio di volte fino a quando non è possibile selezionare Rivedi e assegna per completare l'assegnazione di ruolo.

8. Ripetere questo processo per gli altri servizi a cui ci si vuole connettere.

Considerazioni sullo sviluppo locale

È anche possibile abilitare l'accesso alle risorse di Azure per lo sviluppo locale assegnando ruoli a un account utente nello stesso modo in cui sono stati assegnati ruoli all'identità gestita.

1. Dopo aver assegnato il ruolo Collaboratore dati BLOB di archiviazione all'identità gestita, in Assegna accesso a questa volta selezionare Utente, gruppo o entità servizio. Scegliere + Seleziona membri per aprire di nuovo il menu a comparsa.

2. Cercare l'account user@domain o il gruppo di sicurezza Microsoft Entra a cui si vuole concedere l'accesso tramite indirizzo di posta elettronica o nome e quindi selezionarlo. Questo deve essere lo stesso account usato per accedere agli strumenti di sviluppo locali, ad esempio Visual Studio o l'interfaccia della riga di comando di Azure.

Nota

È anche possibile assegnare questi ruoli a un gruppo di sicurezza Di Microsoft Entra se si lavora a un team con più sviluppatori. È quindi possibile inserire qualsiasi sviluppatore all'interno di tale gruppo che deve accedere per sviluppare l'app in locale.

Implementare il codice dell'applicazione

.NET

1. Nel progetto installare il Azure.Identity pacchetto. Questa libreria fornisce DefaultAzureCredential. È anche possibile aggiungere qualsiasi altra libreria di Azure pertinente per l'app. Per questo esempio, i pacchetti e Azure.Messaging.ServiceBus vengono aggiunti rispettivamente per connettersi all'archiviazione Azure.Storage.Blobs BLOB e bus di servizio.

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

2. Creare un'istanza dei client del servizio per i servizi di Azure a cui l'app deve connettersi. L'esempio di codice seguente interagisce con l'archiviazione BLOB e bus di servizio usando i client del servizio corrispondenti.

   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. Nel progetto aggiungere la azure-identity dipendenza al file di pom.xml . Questa libreria fornisce DefaultAzureCredential. È anche possibile aggiungere altre dipendenze di Azure rilevanti per l'app. Per questo esempio, le dipendenze e azure-messaging-servicebus vengono aggiunte per interagire con l'archiviazione azure-storage-blob BLOB e bus di servizio.

   <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. Creare un'istanza dei client del servizio per i servizi di Azure a cui l'app deve connettersi. L'esempio di codice seguente interagisce con l'archiviazione BLOB e bus di servizio usando i client del servizio corrispondenti.

   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. Nel progetto è sufficiente aggiungere dipendenze del servizio usate. Per questo esempio, le dipendenze e spring-cloud-azure-starter-servicebus vengono aggiunte per connettersi all'archiviazione spring-cloud-azure-starter-storage-blob BLOB e bus di servizio.

   <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. Creare un'istanza dei client del servizio per i servizi di Azure a cui l'app deve connettersi. Gli esempi seguenti si connettono all'archiviazione BLOB e bus di servizio usando i client del servizio corrispondenti.

   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. Nel progetto installare il @azure/identity pacchetto. Questa libreria fornisce DefaultAzureCredential. Per questo esempio, i pacchetti e @azure/service-bus vengono installati per interagire con l'archiviazione @azure/storage-blob BLOB e bus di servizio.

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

2. Creare un'istanza dei client del servizio per i servizi di Azure a cui l'app deve connettersi. L'esempio di codice seguente interagisce con l'archiviazione BLOB e bus di servizio usando i client del servizio corrispondenti.

   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. Nel progetto aggiungere un riferimento al azure-identity pacchetto. Questa libreria fornisce DefaultAzureCredential. È anche possibile aggiungere qualsiasi altra libreria di Azure pertinente per l'app. Per questo esempio, i pacchetti e azure-service-bus vengono aggiunti rispettivamente per connettersi all'archiviazione azure-storage-blob BLOB e bus di servizio.

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

2. Creare un'istanza dei client del servizio per i servizi di Azure a cui l'app deve connettersi. L'esempio di codice seguente interagisce con l'archiviazione BLOB e bus di servizio usando i client del servizio corrispondenti.

   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)
   

Quando questo codice viene eseguito in locale, DefaultAzureCredential cerca le prime credenziali disponibili nella catena di credenziali. Se la Managed_Identity_Client_ID variabile di ambiente è Null in locale, viene usata una credenziale corrispondente a uno strumento di sviluppo installato localmente. Ad esempio, interfaccia della riga di comando di Azure o Visual Studio. Per altre informazioni su questo processo, vedere la sezione Esplorare DefaultAzureCredential.

Quando l'applicazione viene distribuita in Azure, DefaultAzureCredential recupera automaticamente la Managed_Identity_Client_ID variabile dall'ambiente servizio app. Tale valore diventa disponibile quando un'identità gestita è associata all'app.

Questo processo complessivo garantisce che l'app possa essere eseguita in modo sicuro in locale e in Azure senza la necessità di apportare modifiche al codice.

Connettere più app usando più identità gestite

Anche se le app nell'esempio precedente hanno condiviso gli stessi requisiti di accesso ai servizi, gli ambienti reali sono spesso più sfumati. Si consideri uno scenario in cui più app si connettono agli stessi account di archiviazione, ma due delle app accedono anche a servizi o database diversi.

Per configurare questa configurazione nel codice, assicurarsi che l'applicazione registri client di servizio separati per connettersi a ogni account di archiviazione o database. Fare riferimento agli ID client dell'identità gestita corretti per ogni servizio durante la configurazione di DefaultAzureCredential. Gli esempi di codice seguenti configurano queste connessioni al servizio di Azure:

• Due connessioni a account di archiviazione separati tramite un'identità gestita assegnata dall'utente condiviso
• Una connessione ad Azure Cosmos DB e ai servizi SQL di Azure usando una seconda identità gestita assegnata dall'utente. Questa identità gestita viene condivisa quando il driver client SQL di Azure lo consente. Per altre informazioni, vedere i commenti del codice.

.NET

1. Nel progetto installare i pacchetti necessari. La libreria di identità di Azure fornisce 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. Aggiungere quanto segue al codice:

   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. Aggiungere quanto segue al file 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. Aggiungere quanto segue al codice:

   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. Aggiungere quanto segue al file 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. Aggiungere quanto segue al file 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. Aggiungere quanto segue al codice:

   Nota

   Spring Cloud Azure non supporta la configurazione di più client dello stesso servizio. Gli esempi di codice seguenti creano più fagioli per questa situazione.

   @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. Nel progetto installare i pacchetti necessari. La libreria di identità di Azure fornisce DefaultAzureCredential.

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

2. Aggiungere quanto segue al codice:

   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. Nel progetto installare i pacchetti necessari. La libreria di identità di Azure fornisce DefaultAzureCredential.

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

2. Aggiungere quanto segue al codice:

   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})
   

È anche possibile associare contemporaneamente un'identità gestita assegnata dall'utente e un'identità gestita assegnata dal sistema a una risorsa. Ciò può essere utile negli scenari in cui tutte le app richiedono l'accesso agli stessi servizi condivisi, ma una delle app ha anche una dipendenza specifica da un servizio aggiuntivo. L'uso di un'identità gestita assegnata dal sistema garantisce anche che l'identità associata a tale app specifica venga eliminata quando l'app viene eliminata, che consente di mantenere pulito l'ambiente.

Questi tipi di scenari vengono esaminati in modo più approfondito nelle raccomandazioni sulle procedure consigliate sulle identità gestite.

Passaggi successivi

In questa esercitazione si è appreso come eseguire la migrazione di un'applicazione a connessioni senza password. Leggere le risorse seguenti per esplorare i concetti illustrati in questo articolo in modo più approfondito:

• Autorizzare l'accesso ai BLOB tramite Microsoft Entra ID
• Per altre informazioni su .NET, vedere Get started with .NET in 10 minutes (Introduzione a .NET in 10 minuti).