Comment utiliser des identités managées pour se connecter à Azure Cosmos DB à partir d’une machine virtuelle Azure

Dans cet article, nous allons configurer une machine virtuelle afin d’utiliser des identités managées pour se connecter à Azure Cosmos DB. Azure Cosmos DB est une base de données NoSQL complètement managée pour développer des applications modernes. Les identités managées pour les ressources Azure permettent à vos applications de s’authentifier lorsqu’elles accèdent à des services qui prennent en charge l’authentification Microsoft Entra à l’aide d’une identité managée par Azure.

Prérequis

• Connaissance de base des identités managées. Si vous souhaitez en savoir plus sur les identités managées pour les ressources Azure avant de continuer, consultez la vue d’ensemble des identités managées.
• Vous devez disposer d’un compte Azure avec un abonnement actif. Créez un compte gratuitement.
• Vous aurez peut-être besoin de PowerShell ou de l’interface CLI.
• Visual Studio Community Edition ou un autre environnement de développement de votre choix.

Créer un groupe de ressources

Créez un groupe de ressources appelé mi-test. Nous utilisons ce groupe de ressources pour toutes les ressources dans ce tutoriel.

• Créer un groupe de ressources avec le portail Azure
• Créer un groupe de ressources avec l’interface CLI
• Créer un groupe de ressources avec PowerShell

Créer une machine virtuelle Azure avec une identité managée

Pour ce tutoriel, vous avez besoin d’une machine virtuelle Azure. Créez une machine virtuelle avec une identité managée affectée par le système activée et appelez-la mi-vm-01. Vous pouvez aussi créer une identité managée affectée par l’utilisateur appelée mi-ua-01 dans le groupe de ressources que nous avons créé plus tôt (mi-test). Si vous utilisez une identité managée affectée par l’utilisateur, vous pouvez l’affecter à une machine virtuelle lors de la création.

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

Pour créer une machine virtuelle Azure avec l’identité managée affectée par le système sur une machine virtuelle, votre compte a besoin de l’affectation de rôle Contributeur de machine virtuelle. Aucune autre attribution de rôle Microsoft Entra n’est requise.

New-AzVm `
    -ResourceGroupName "My VM" `
    -Name "My resource group" `
    -Location "East US" `
    -VirtualNetworkName "myVnet" `
    -SubnetName "mySubnet" `
    -SecurityGroupName "myNetworkSecurityGroup" `
    -SystemAssignedIdentity
    -OpenPorts 80,3389

az vm create --resource-group myResourceGroup --name myVM --image win2016datacenter --generate-ssh-keys --assign-identity --admin-username azureuser --admin-password myPassword12

"identity": {
    "type": "SystemAssigned"
},

 "resources": [
     {
         //other resource provider properties...
         "apiVersion": "2018-06-01",
         "type": "Microsoft.Compute/virtualMachines",
         "name": "[variables('myVM')]",
         "location": "[myResourceGroup().location]",
         "identity": {
             "type": "SystemAssigned",
             }                        
     }
 ]

Créer une machine virtuelle avec une identité managée affectée par l’utilisateur

Les étapes ci-dessous vous montrent comment créer une machine virtuelle avec une identité managée affectée par l’utilisateur configurée.

New-AzVm `
    -ResourceGroupName "<Your resource group>" `
    -Name "<Your VM name>" `
    -Location "East US" `
    -VirtualNetworkName "<myVnet>" `
    -SubnetName "mySubnet" `
    -SecurityGroupName "myNetworkSecurityGroup" `
    -UserAssignedIdentity "/subscriptions/<Your subscription>/resourceGroups/<Your resource group>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/<Your user assigned managed identity>" `
    -OpenPorts 80,3389

New-AzVm `
    -Name "<Linux VM name>" `
    -image CentOS85Gen2
    -ResourceGroupName "<Your resource group>" `
    -Location "East US" `
    -VirtualNetworkName "myVnet" `
    -SubnetName "mySubnet" `
    -Linux `
    -SecurityGroupName "myNetworkSecurityGroup" `
    -UserAssignedIdentity "/subscriptions/<Your subscription>/resourceGroups/<Your resource group>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/<Your user assigned managed identity>" `
    -OpenPorts 22

az vm create --resource-group <MyResourceGroup> --name <myVM> --image <SKU Linux Image> --admin-username <USER NAME> --admin-password <PASSWORD> --assign-identity <USER ASSIGNED IDENTITY NAME>

    "variables": {
     "identityName": "my-user-assigned"    
        
    },

"resources": [
     {
         //other resource provider properties...
         "apiVersion": "2018-06-01",
         "type": "Microsoft.Compute/virtualMachines",
         "name": "[variables('vmName')]",
         "location": "[resourceGroup().location]",
         "identity": {
             "type": "userAssigned",
             "userAssignedIdentities": {
                "[resourceID('Microsoft.ManagedIdentity/userAssignedIdentities/',variables('<identityName>'))]": {}
             }
         }
     }
 ]

Créer un compte Azure Cosmos DB

Maintenant que nous avons une machine virtuelle avec une identité managée affectée par l’utilisateur ou une identité managée affectée par le système, il nous faut un compte Azure Cosmos DB pour lequel vous disposez de droits d’administration. Si, dans le cadre de ce tutoriel, vous devez créer un compte Azure Cosmos DB, le Guide de démarrage rapide d’Azure Cosmos DB présente en détail les étapes à suivre.

Accorder l'accès

À ce stade, nous devons avoir une machine virtuelle configurée avec une identité managée et un compte Azure Cosmos DB. Avant de continuer, nous devons accorder à l’identité managée deux ou trois rôles différents.

• Accordez d’abord l’accès au plan de gestion Azure Cosmos DB en utilisant le contrôle RBAC Azure. L’identité managée doit avoir le rôle Contributeur de comptes DocumentDB attribué pour créer des bases de données et des conteneurs.

• Vous devez également accorder un rôle de contributeur à l’identité managée en utilisant le contrôle RBAC Azure Cosmos DB. Vous pouvez voir les étapes spécifiques ci-dessous.

$resourceGroupName = "<myResourceGroup>"
$accountName = "<myCosmosAccount>" 
$contributorRoleDefinitionId = "00000000-0000-0000-0000-000000000002" # This is the ID of the Cosmos DB Built-in Data contributor role definition
$principalId = "1111111-1111-11111-1111-11111111" # This is the object ID of the managed identity.
New-AzCosmosDBSqlRoleAssignment -AccountName $accountName `
    -ResourceGroupName $resourceGroupName `
    -RoleDefinitionId $contributorRoleDefinitionId `
    -Scope "/" `
    -PrincipalId $principalId

resourceGroupName='<myResourceGroup>'
accountName='<myCosmosAccount>'
readOnlyRoleDefinitionId = '00000000-0000-0000-0000-000000000002' # This is the ID of the Cosmos DB Built-in Data contributor role definition
principalId = "1111111-1111-11111-1111-11111111" # This is the object ID of the managed identity.
az cosmosdb sql role assignment create --account-name $accountName --resource-group $resourceGroupName --scope "/" --principal-id $principalId --role-definition-id $readOnlyRoleDefinitionId

{
  "id": "/subscriptions/mySubscriptionId/resourceGroups/myResourceGroupName/providers/Microsoft.DocumentDB/databaseAccounts/myAccountName/sqlRoleAssignments/00000000-0000-0000-0000-000000000002",
  "name": "myRoleAssignmentId",
  "type": "Microsoft.DocumentDB/databaseAccounts/sqlRoleAssignments",
  "properties": {
    "roleDefinitionId": "/subscriptions/mySubscriptionId/resourceGroups/myResourceGroupName/providers/Microsoft.DocumentDB/databaseAccounts/myAccountName/sqlRoleDefinitions/00000000-0000-0000-0000-000000000002",
    "scope": "/subscriptions/mySubscriptionId/resourceGroups/myResourceGroupName/providers/Microsoft.DocumentDB/databaseAccounts/myAccountName/dbs/purchases/colls/redmond-purchases",
    "principalId": "myPrincipalId"
  }
}

Accéder aux données

Pour obtenir l’accès à Azure Cosmos DB avec des identités managées, la bibliothèque Azure.identity doit être utilisée afin d’activer l’authentification dans votre application. Vous pouvez appeler ManagedIdentityCredential directement ou utiliser DefaultAzureCredential.

La classe ManagedIdentityCredential tente une authentification à l’aide d’une identité managée affectée à l’environnement de déploiement. La classe DefaultAzureCredential passe par différentes options d’authentification dans l’ordre. La deuxième option d’authentification que tente DefaultAzureCredential est les identités managées.

Dans l’exemple ci-dessous, vous allez créer une base de données, un conteneur et un élément dans le conteneur, puis lire l’élément qui vient d’être créé avec l’identité managée affectée par le système de la machine virtuelle. Si vous souhaitez utiliser une identité managée affectée par l’utilisateur, vous devez en spécifier une en indiquant l’ID client de l’identité managée.

string userAssignedClientId = "<your managed identity client Id>";
var tokenCredential = new DefaultAzureCredential(new DefaultAzureCredentialOptions { ManagedIdentityClientId = userAssignedClientId });

Pour utiliser l’exemple ci-dessous, vous devez disposer des packages NuGet suivants :

• Azure.Identity
• Microsoft.Azure.Cosmos
• Microsoft.Azure.Management.CosmosDB

En plus des packages NuGet ci-dessus, vous devez également activer Inclure la préversion, puis ajouter Azure.ResourceManager.CosmosDB.

using Azure.Identity;
using Azure.ResourceManager.CosmosDB;
using Azure.ResourceManager.CosmosDB.Models;
using Microsoft.Azure.Cosmos;
using System;
using System.Threading.Tasks;

namespace MITest
{
    class Program
    {
        static async Task Main(string[] args)
        {
            // Replace the placeholders with your own values
            var subscriptionId = "Your subscription ID";
            var resourceGroupName = "You resource group";
            var accountName = "Cosmos DB Account name";
            var databaseName = "mi-test";
            var containerName = "container01";

            // Authenticate to Azure using Managed Identity (system-assigned or user-assigned)
            var tokenCredential = new DefaultAzureCredential();

            // Create the Cosmos DB management client using the subscription ID and token credential
            var managementClient = new CosmosDBManagementClient(tokenCredential)
            {
                SubscriptionId = subscriptionId
            };

            // Create the Cosmos DB data client using the account URL and token credential
            var dataClient = new CosmosClient($"https://{accountName}.documents.azure.com:443/", tokenCredential);

            // Create a new database using the management client
            var createDatabaseOperation = await managementClient.SqlResources.StartCreateUpdateSqlDatabaseAsync(
                resourceGroupName,
                accountName,
                databaseName,
                new SqlDatabaseCreateUpdateParameters(new SqlDatabaseResource(databaseName), new CreateUpdateOptions()));
            await createDatabaseOperation.WaitForCompletionAsync();

            // Create a new container using the management client
            var createContainerOperation = await managementClient.SqlResources.StartCreateUpdateSqlContainerAsync(
                resourceGroupName,
                accountName,
                databaseName,
                containerName,
                new SqlContainerCreateUpdateParameters(new SqlContainerResource(containerName), new CreateUpdateOptions()));
            await createContainerOperation.WaitForCompletionAsync();

            // Create a new item in the container using the data client
            var partitionKey = "pkey";
            var id = Guid.NewGuid().ToString();
            await dataClient.GetContainer(databaseName, containerName)
                .CreateItemAsync(new { id = id, _partitionKey = partitionKey }, new PartitionKey(partitionKey));

            // Read back the item from the container using the data client
            var pointReadResult = await dataClient.GetContainer(databaseName, containerName)
                .ReadItemAsync<dynamic>(id, new PartitionKey(partitionKey));

            // Run a query to get all items from the container using the data client
            await dataClient.GetContainer(databaseName, containerName)
                .GetItemQueryIterator<dynamic>("SELECT * FROM c")
                .ReadNextAsync();
        }
    }
}

Exemples par langage qui utilisent ManagedIdentityCredential :

.NET

Initialisez votre client Azure Cosmos DB :

CosmosClient client = new CosmosClient("<account-endpoint>", new ManagedIdentityCredential());

Puis, lisez et écrivez des données.

Java

Initialisez votre client Azure Cosmos DB :

CosmosAsyncClient Client = new CosmosClientBuilder().endpoint("<account-endpoint>") .credential(new ManagedIdentityCredential()) .build();

Puis, lisez et écrivez les données comme décrit dans ces exemples.

JavaScript

Initialisez votre client Azure Cosmos DB :

const client = new CosmosClient({ "<account-endpoint>", aadCredentials: new ManagedIdentityCredential() });

Puis, lisez et écrivez les données comme décrit dans ces exemples.

Étapes de nettoyage

Remove-AzResource `
  -ResourceGroupName ExampleResourceGroup `
  -ResourceName ExampleVM `
  -ResourceType Microsoft.Compute/virtualMachines

az resource delete \
  --resource-group ExampleResourceGroup \
  --name ExampleVM \
  --resource-type "Microsoft.Compute/virtualMachines"

Étapes suivantes

En savoir plus sur les identités managées pour les ressources Azure :

• Que sont les identités managées pour les ressources Azure ?
• Modèles Microsoft Azure Resource Manager

En savoir plus sur Azure Cosmos DB :

• Modèle de ressource Azure Cosmos DB
• Tutoriel : Créer une application console .NET pour gérer des données dans un compte Azure Cosmos DB for NoSQL