Utiliser le contrôle d’accès en fonction du rôle du plan de contrôle avec Azure Cosmos DB for Table

Article
10/24/2024

S’APPLIQUE À : Table

Diagramme de l’emplacement actuel (« Contrôle d’accès en fonction du rôle ») dans la séquence du guide de déploiement.

Cet article décrit les étapes à suivre afin d’accorder à une identité l’accès pour gérer un compte Azure Cosmos DB for Table et ses ressources.

Important

Les étapes décrites dans cet article couvrent uniquement l’accès au plan de contrôle pour effectuer des opérations sur le compte même de toutes les ressources de la hiérarchie du compte. Pour apprendre à gérer des rôles, des définitions et des affectations pour le plan de contrôle, consultez accorder l’accès en fonction du rôle du plan de données.

Prérequis

Compte Azure avec un abonnement actif. Créez un compte gratuitement.
Compte Azure Cosmos DB existant.
Une ou plusieurs identités existantes dans Microsoft Entra ID.

Utilisez l’environnement Bash dans Azure Cloud Shell. Pour plus d’informations, consultez Démarrage rapide pour Bash dans Azure Cloud Shell.
Si vous préférez exécuter les commandes de référence de l’interface de ligne de commande localement, installez l’interface Azure CLI. Si vous exécutez sur Windows ou macOS, envisagez d’exécuter Azure CLI dans un conteneur Docker. Pour plus d’informations, consultez Guide pratique pour exécuter Azure CLI dans un conteneur Docker.
- Si vous utilisez une installation locale, connectez-vous à Azure CLI à l’aide de la commande az login. Pour finir le processus d’authentification, suivez les étapes affichées dans votre terminal. Pour connaître les autres options de connexion, consultez Se connecter avec Azure CLI.
- Lorsque vous y êtes invité, installez l’extension Azure CLI lors de la première utilisation. Pour plus d’informations sur les extensions, consultez Utiliser des extensions avec Azure CLI.
- Exécutez az version pour rechercher la version et les bibliothèques dépendantes installées. Pour effectuer une mise à niveau vers la dernière version, exécutez az upgrade.

Si vous choisissez d’utiliser Azure PowerShell localement :
- Installez la dernière version du module Az PowerShell.
- Connectez-vous à votre compte Azure à l’aide de la cmdlet Connect-AzAccount.
Si vous choisissez d’utiliser Azure Cloud Shell :
- Pour plus d’informations, consultez Vue d’ensemble d’Azure Cloud Shell.

Préparer la définition de rôle

Tout d’abord, vous devez préparer une définition de rôle avec une liste d’actions pour accorder l’accès pour gérer les ressources de compte dans Azure Cosmos DB.

Définition intégrée
Définition personnalisée

Répertoriez toutes les définitions de rôle associées à votre compte Azure Cosmos DB à l’aide de az role definition list. Passez en revue la sortie et recherchez la définition de rôle nommée Contributeur de données intégré Cosmos DB. La sortie contient l’identificateur unique de la définition de rôle dans la propriété id. Enregistrez cette valeur, car vous devrez l’utiliser dans l’étape d’affectation plus loin dans ce guide.

az role definition list \
    --name "Cosmos DB Operator"

[
  {
    "assignableScopes": [
      "/"
    ],
    "description": "Lets you manage Azure Cosmos DB accounts, but not access data in them. Prevents access to account keys and connection strings.",
    "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/providers/Microsoft.Authorization/roleDefinitions/230815da-be43-4aae-9cb4-875f7bd000aa",
    "name": "230815da-be43-4aae-9cb4-875f7bd000aa",
    "permissions": [
      {
        "actions": [
          "Microsoft.DocumentDb/databaseAccounts/*",
          "Microsoft.Insights/alertRules/*",
          "Microsoft.Authorization/*/read",
          "Microsoft.ResourceHealth/availabilityStatuses/read",
          "Microsoft.Resources/deployments/*",
          "Microsoft.Resources/subscriptions/resourceGroups/read",
          "Microsoft.Support/*",
          "Microsoft.Network/virtualNetworks/subnets/joinViaServiceEndpoint/action"
        ],
        "condition": null,
        "conditionVersion": null,
        "dataActions": [],
        "notActions": [
          "Microsoft.DocumentDB/databaseAccounts/dataTransferJobs/*",
          "Microsoft.DocumentDB/databaseAccounts/readonlyKeys/*",
          "Microsoft.DocumentDB/databaseAccounts/regenerateKey/*",
          "Microsoft.DocumentDB/databaseAccounts/listKeys/*",
          "Microsoft.DocumentDB/databaseAccounts/listConnectionStrings/*",
          "Microsoft.DocumentDB/databaseAccounts/sqlRoleDefinitions/write",
          "Microsoft.DocumentDB/databaseAccounts/sqlRoleDefinitions/delete",
          "Microsoft.DocumentDB/databaseAccounts/sqlRoleAssignments/write",
          "Microsoft.DocumentDB/databaseAccounts/sqlRoleAssignments/delete",
          "Microsoft.DocumentDB/databaseAccounts/mongodbRoleDefinitions/write",
          "Microsoft.DocumentDB/databaseAccounts/mongodbRoleDefinitions/delete",
          "Microsoft.DocumentDB/databaseAccounts/mongodbUserDefinitions/write",
          "Microsoft.DocumentDB/databaseAccounts/mongodbUserDefinitions/delete"
        ],
        "notDataActions": []
      }
    ],
    "roleName": "Cosmos DB Operator",
    "roleType": "BuiltInRole",
    "type": "Microsoft.Authorization/roleDefinitions",
  }
]

Remarque

Pour cet exemple, la valeur id serait /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/providers/Microsoft.Authorization/roleDefinitions/230815da-be43-4aae-9cb4-875f7bd000aa. Cet exemple utilise des données fictives et votre identificateur serait distinct de cet exemple. Toutefois, l’identificateur (230815da-be43-4aae-9cb4-875f7bd000aa) est globalement unique dans toutes les définitions de rôle dans Azure.

Connectez-vous au portail Azure (https://portal.azure.com).
Entrez groupe de ressources dans la barre de recherche globale.
Sous Services, sélectionnez Groupes de ressources.
Dans le volet Groupes de ressources, sélectionnez votre groupe de ressources existant.

Remarque

Cet exemple de capture d’écran inclut le groupe de ressources msdocs-identity-example. Le nom de votre groupe de ressources réel peut être différent.
Dans le volet du groupe de ressources, sélectionnez Contrôle d’accès (IAM) dans le menu de service.
Dans le volet Contrôle d’accès (IAM), sélectionnez Rôles.
Dans la section Rôles, utilisez l’expression de recherche Cosmos DB et recherchez la définition de rôle Opérateur Cosmos DB. Sélectionnez ensuite l’option Afficher associée à cette définition.
Dans la boîte de dialogue de définition de rôle Opérateur Cosmos DB, observez les actions affectées dans le cadre de cette définition de rôle.
Fermez la boîte de dialogue de définition de rôle Opérateur Cosmos DB.

Utilisez Get-AzRoleDefinition pour répertorier toutes les définitions de rôle associées à votre compte Azure Cosmos DB. Passez en revue la sortie et recherchez la définition de rôle nommée Contributeur de données intégré Cosmos DB. La sortie contient l’identificateur unique de la définition de rôle dans la propriété Id. Enregistrez cette valeur, car vous devrez l’utiliser dans l’étape d’affectation plus loin dans ce guide.

$parameters = @{
    Name = "Cosmos DB Operator"
}
Get-AzRoleDefinition @parameters

Name             : Cosmos DB Operator
Id               : 230815da-be43-4aae-9cb4-875f7bd000aa
IsCustom         : False
Description      : Lets you manage Azure Cosmos DB accounts, but not access data in them. Prevents access to account keys and connection strings.
Actions          : {Microsoft.DocumentDb/databaseAccounts/*, Microsoft.Insights/alertRules/*, Microsoft.Authorization/*/read, Microsoft.ResourceHealth/availabilityStatuses/read…}
NotActions       : {Microsoft.DocumentDB/databaseAccounts/dataTransferJobs/*, Microsoft.DocumentDB/databaseAccounts/readonlyKeys/*, Microsoft.DocumentDB/databaseAccounts/regenerateKey/*, Microsoft.DocumentDB/databaseAccounts/listKeys/*…}
DataActions      : {}
NotDataActions   : {}
AssignableScopes : {/}

Remarque

Pour cet exemple, la valeur Id serait 230815da-be43-4aae-9cb4-875f7bd000aa. L’identificateur est globalement unique dans toutes les définitions de rôle dans Azure.

Utilisez az group show pour obtenir les métadonnées de votre groupe de ressources actuel.
```
az group show \
    --name "<name-of-existing-resource-group>"
```
Observez la sortie de la commande précédente. Enregistrez la valeur de la propriété id pour ce groupe de ressources, car vous devrez l’utiliser à l’étape suivante.
```
{
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example",
  "location": "westus",
  "name": "msdocs-identity-example",
  "type": "Microsoft.Resources/resourceGroups"
}
```
Remarque

Pour cet exemple, la valeur id serait /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example. Cet exemple utilise des données fictives et votre identificateur serait distinct de cet exemple. Voici un exemple tronqué de la sortie.
Créez un fichier JSON nommé role-definition.json. Dans le fichier, créez cette définition de ressource en spécifiant les valeurs répertoriées ici. Pour la liste AssignableScopes, ajoutez la propriété id du groupe de ressources, enregistrée à l’étape précédente.
```
{
  "Name": "Azure Cosmos DB Control Plane Owner",
  "IsCustom": true,
  "Description": "Can perform all control plane actions for an Azure Cosmos DB account.",
  "Actions": [
    "Microsoft.DocumentDb/*"
  ],
  "AssignableScopes": [
    "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example"
  ]
}
```
Remarque

Cet exemple utilise la valeur /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example enregistrée à l’étape précédente. Votre identificateur de ressource réel peut être différent.
Créez une définition de rôle à l’aide de az role definition create. Utilisez le fichier role-definition.json comme entrée de l’argument --role-definition.
```
az role definition create \
    --role-definition role-definition.json
```
Passez en revue la sortie de la commande de création de définition. La sortie contient l’identificateur unique de la définition de rôle dans la propriété id. Enregistrez cette valeur, car vous devrez l’utiliser dans l’étape d’affectation plus loin dans ce guide.
```
{
  "assignableScopes": [
    "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example"
  ],
  "description": "Can perform all control plane actions for an Azure Cosmos DB account.",
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleDefinitions/ffffffff-eeee-dddd-cccc-bbbbbbbbbbb0",
  "name": "e4e4e4e4-ffff-aaaa-bbbb-c5c5c5c5c5c5",
  "permissions": [
    {
      "actions": [
        "Microsoft.DocumentDb/*"
      ]
    }
  ],
  "roleName": "Azure Cosmos DB Control Plane Owner",
  "roleType": "CustomRole"
}
```
Remarque

Pour cet exemple, la valeur id serait /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleDefinitions/ffffffff-eeee-dddd-cccc-bbbbbbbbbbb0. Cet exemple utilise des données fictives et votre identificateur serait distinct de cet exemple. Il s’agit d’un sous-ensemble de la sortie JSON classique du déploiement, pour plus de clarté.

Créez un fichier Bicep pour définir votre définition de rôle. Nommez le fichier control-plane-role-definition.bicep. Ajoutez ces actions à la définition :

	Description
*`Microsoft.DocumentDb/`**	Active toutes les actions possibles.

metadata description = 'Create RBAC definition for control plane access to Azure Cosmos DB.'

@description('Name of the role definition.')
param roleDefinitionName string = 'Azure Cosmos DB Control Plane Owner'

@description('Description of the role definition.')
param roleDefinitionDescription string = 'Can perform all control plane actions for an Azure Cosmos DB account.'

resource definition 'Microsoft.Authorization/roleDefinitions@2022-04-01' = {
  name: guid(subscription().id, resourceGroup().id, roleDefinitionName)
  scope: resourceGroup()
  properties: {
    roleName: roleDefinitionName
    description: roleDefinitionDescription
    type: 'CustomRole'
    permissions: [
      {
        actions: [
          'Microsoft.DocumentDb/*'
        ]
      }
    ]
    assignableScopes: [
      resourceGroup().id
    ]
  }
}

output definitionId string = definition.id

Déployez le modèle Bicep à l’aide de az deployment group create. Spécifiez le nom du modèle Bicep et du groupe de ressources Azure.

az deployment group create \
    --resource-group "<name-of-existing-resource-group>" \
    --template-file control-plane-role-definition.bicep

Examinez la sortie du déploiement. La sortie contient l’identificateur unique de la définition de rôle dans la propriété properties.outputs.definitionId.value. Enregistrez cette valeur, car vous devrez l’utiliser dans l’étape d’affectation plus loin dans ce guide.
```
{
  "properties": {
    "outputs": {
      "definitionId": {
        "type": "String",
        "value": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleDefinitions/ffffffff-eeee-dddd-cccc-bbbbbbbbbbb0"
      }
    }
  }
}
```
Remarque

Pour cet exemple, la valeur id serait /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleDefinitions/ffffffff-eeee-dddd-cccc-bbbbbbbbbbb0. Cet exemple utilise des données fictives et votre identificateur serait distinct de cet exemple. Il s’agit d’un sous-ensemble de la sortie JSON classique du déploiement, pour plus de clarté.

Dans le volet Contrôle d’accès (IAM), sélectionnez Ajouter, puis Ajouter un rôle personnalisé.

Dans le volet Informations de base, configurez les options suivantes, puis sélectionnez Suivant :

	Valeur
Nom de rôle personnalisé	`Azure Cosmos DB Control Plane Owner`
Description	`Can perform all control plane actions for an Azure Cosmos DB account.`
Autorisations de base	Commencer à partir de zéro

Capture d’écran du volet « Informations de base » pour l’ajout d’un rôle personnalisé.

Dans le volet Autorisations, sélectionnez Ajouter des autorisations. Ensuite, recherchez DocumentDB dans la boîte de dialogue d’autorisations. Enfin, sélectionnez l’option Microsoft.DocumentDB.
Dans la boîte de dialogue d’autorisations, sélectionnez toutes les actions pour Microsoft.DocumentDB. Ensuite, sélectionnez Ajouter pour revenir au volet *Autorisations.
De retour dans le volet Autorisations, observez la liste des autorisations. Sélectionnez ensuite Vérifier + créer.
Dans le volet Vérifier + créer, passez en revue les options spécifiées pour la nouvelle définition de rôle. Pour finir, sélectionnez Créer.
Attendez que le portail termine la création de la définition de rôle.

Utilisez Get-AzResourceGroup pour obtenir les métadonnées de votre groupe de ressources actuel.

$parameters = @{
    Name = "<name-of-existing-resource-group>"
}
Get-AzResourceGroup @parameters

Observez la sortie de la commande précédente. Enregistrez la valeur de la propriété ResourceId pour ce groupe de ressources, car vous devrez l’utiliser à l’étape suivante.
```
ResourceGroupName : msdocs-identity-example
Location          : westus
ProvisioningState : Succeeded
ResourceId        : /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example
```
Remarque

Pour cet exemple, la valeur ResourceId serait /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example. Cet exemple utilise des données fictives et votre identificateur serait distinct de cet exemple. Il s’agit d’un exemple tronqué de la sortie classique.
Commencez par importer le module Az.Resources. Créez ensuite un objet Microsoft.Azure.Commands.Resources.Models.Authorization.PSRoleDefinition. Dans l’objet, créez cette définition de ressource en spécifiant les valeurs répertoriées ici. Pour la liste AssignableScopes, ajoutez la propriété ResourceId du groupe de ressources, enregistrée à l’étape précédente. Enfin, utilisez l’objet de définition de rôle comme entrée pour le paramètre -Role de New-AzRoleDefinition.
```
Import-Module Az.Resources

$parameters = @{
    TypeName = "Microsoft.Azure.Commands.Resources.Models.Authorization.PSRoleDefinition"
    Property = @{
        Name = "Azure Cosmos DB Control Plane Owner"
        Description = "Can perform all control plane actions for an Azure Cosmos DB account."
        IsCustom = $true
        Actions = @(
            "Microsoft.DocumentDb/*"
        )
        AssignableScopes = @(
            "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example"
        )
    }
}
$role = New-Object @parameters

New-AzRoleDefinition -Role $role
```
Remarque

Cet exemple utilise la valeur /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example enregistrée à l’étape précédente. Votre identificateur de ressource réel peut être différent.
Passez en revue la sortie de la commande de création de définition. La sortie contient l’identificateur unique de la définition de rôle dans la propriété Name. Enregistrez cette valeur, car vous devrez l’utiliser dans l’étape d’affectation plus loin dans ce guide.
```
Name             : Azure Cosmos DB Control Plane Owner
Id               : e4e4e4e4-ffff-aaaa-bbbb-c5c5c5c5c5c5
IsCustom         : True
Description      : Can perform all control plane actions for an Azure Cosmos DB account.
Actions          : {Microsoft.DocumentDb/*}
AssignableScopes : {/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example}
```
Remarque

Pour cet exemple, la valeur Name serait Azure Cosmos DB Control Plane Owner. Il s’agit d’un sous-ensemble de la sortie classique du déploiement, pour plus de clarté.

Attribuer un rôle à l’identité

À présent, affectez le rôle nouvellement défini à une identité afin que vos applications puissent accéder aux ressources dans Azure Cosmos DB.

Important

Cette tâche d’attribution nécessite que vous disposiez déjà de l’identificateur unique de l’identité à laquelle vous souhaitez accorder des autorisations de contrôle d’accès en fonction du rôle.

Utilisez az group show pour obtenir à nouveau les métadonnées de votre groupe de ressources actuel.
```
az group show \
    --name "<name-of-existing-resource-group>"
```
Observez la sortie de la commande précédente. Enregistrez la valeur de la propriété id pour ce groupe de ressources, car vous devrez l’utiliser à l’étape suivante.
```
{
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example",
  "location": "westus",
  "name": "msdocs-identity-example",
  "type": "Microsoft.Resources/resourceGroups"
}
```
Remarque

Pour cet exemple, la valeur id serait /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example. Cet exemple utilise des données fictives et votre identificateur serait distinct de cet exemple. Voici un exemple tronqué de la sortie.
Attribuez le nouveau rôle à l’aide de az role assignment create. Utilisez l’identificateur de votre groupe de ressources pour l’argument --scope, l’identificateur du rôle pour l’argument -role et l’identificateur unique de votre identité à l’argument --assignee.
```
az role assignment create \
    --assignee "<your-principal-identifier>" \
    --role "subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleDefinitions/ffffffff-eeee-dddd-cccc-bbbbbbbbbbb0" \
    --scope "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example"
```
Remarque

Dans cet exemple de commande, le paramètre scope a été défini sur l’exemple fictif /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example de l’exemple de l’étape précédente. L’identificateur de votre groupe de ressources serait distinct de cet exemple. Le paramètre role a également été défini sur la valeur fictive /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleDefinitions/ffffffff-eeee-dddd-cccc-bbbbbbbbbbb0. Là encore, votre identificateur de rôle serait distinct.

Observez la sortie de la commande . La sortie inclut un identificateur unique pour l’affectation dans la propriété id.

{
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleAssignments/ffffffff-eeee-dddd-cccc-bbbbbbbbbbb0",
  "name": "ffffffff-5555-6666-7777-aaaaaaaaaaaa",
  "principalId": "aaaaaaaa-bbbb-cccc-1111-222222222222",
  "resourceGroup": "msdocs-identity-example",
  "roleDefinitionId": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleDefinitions/ffffffff-eeee-dddd-cccc-bbbbbbbbbbb0",
  "scope": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example",
  "type": "Microsoft.Authorization/roleAssignments"
}

Remarque

Dans cet exemple, la propriété id est /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleAssignments/ffffffff-eeee-dddd-cccc-bbbbbbbbbbb0, un autre exemple fictif.

Répétez ces étapes pour accorder l’accès au compte à partir d’autres identités que vous souhaitez utiliser.

Conseil

Vous pouvez répéter ces étapes pour autant d’identités que vous le souhaitez. En règle générale, ces étapes sont au moins répétées pour permettre aux développeurs d’accéder à un compte à l’aide de leur identité humaine et pour accorder aux applications l’accès à l’aide d’une identité managée.

Créez un fichier Bicep pour définir votre attribution de rôle. Nommez le fichier control-plane-role-assignment.bicep.

metadata description = 'Assign RBAC role for control plane access to Azure Cosmos DB.'

@description('Id of the role definition to assign to the targeted principal in the context of the account.')
param roleDefinitionId string

@description('Id of the identity/principal to assign this role in the context of the account.')
param identityId string

resource assignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(subscription().id, resourceGroup().id, roleDefinitionId, identityId)
  scope: resourceGroup()
  properties: {
    roleDefinitionId: roleDefinitionId
    principalId: identityId
  }
}

Créez un fichier de paramètres Bicep nommé control-plane-role-assignment.bicepparam. Dans ce fichier de paramètres, affectez les identificateurs de définition de rôle précédemment enregistrés au paramètre roleDefinitionId et l’identificateur unique de votre identité au paramètre identityId.
```
using './control-plane-role-assignment.bicep'

param roleDefinitionId = '<id-of-new-role-definition>'
param identityId = '<id-of-existing-identity>'
```

Déployez ce modèle Bicep à l’aide de az deployment group create.

az deployment group create \
    --resource-group "<name-of-existing-resource-group>" \
    --parameters control-plane-role-assignment.bicepparam \
    --template-file control-plane-role-assignment.bicep

Répétez ces étapes pour accorder l’accès au compte à partir d’autres identités que vous souhaitez utiliser.

Conseil

Vous pouvez répéter ces étapes pour autant d’identités que vous le souhaitez. En règle générale, ces étapes sont au moins répétées pour permettre aux développeurs d’accéder à un compte à l’aide de leur identité humaine et pour accorder aux applications l’accès à l’aide d’une identité managée.

Dans le volet Contrôle d’accès (IAM), sélectionnez Ajouter, puis Ajouter une attribution de rôle.
Dans le volet Rôle, recherchez Azure Cosmos DB et sélectionnez le rôle Propriétaire du plan de contrôle Azure Cosmos DB créé précédemment dans ce guide. Sélectionnez ensuite Suivant.

Conseil

Vous pouvez éventuellement filtrer la liste des rôles pour inclure uniquement les rôles personnalisés.
Dans le volet Membres, sélectionnez l’option Sélectionner des membres. Dans la boîte de dialogue des membres, sélectionnez l’identité à laquelle vous souhaitez accorder ce niveau d’accès pour votre compte Azure Cosmos DB, puis utilisez l’option Sélectionner pour confirmer votre choix.

Remarque

Cette capture d’écran illustre un exemple d’utilisateur nommé « Kai Carter » avec un principal de kai@adventure-works.com.
De retour dans le volet Membres, passez en revue le ou les membres sélectionnés, puis sélectionnez Vérifier + affecter.
Dans le volet Vérifier + affecter, passez en revue les options spécifiées pour la nouvelle attribution de rôle. Enfin, sélectionnez Vérifier + créer.
Attendez que le portail termine la création de l’attribution de rôle.

Attribuez le nouveau rôle à l’aide de New-AzRoleAssignment. Utilisez le nom du rôle pour le paramètre RoleDefinitionName et l’identificateur unique de votre identité au paramètre ObjectId.

$parameters = @{
    ResourceGroupName = "<name-of-existing-resource-group>"
    ObjectId = "<your-principal-identifier>"
    RoleDefinitionName = "Azure Cosmos DB Control Plane Owner"
}
New-AzRoleAssignment @parameters

Observez la sortie de la commande . La sortie inclut un identificateur unique pour l’affectation dans la propriété RoleAssignmentId.

RoleAssignmentName : ffffffff-5555-6666-7777-aaaaaaaaaaaa
RoleAssignmentId   : /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleAssignments/ffffffff-eeee-dddd-cccc-bbbbbbbbbbb0
Scope              : /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example
DisplayName        : Kai Carter
SignInName         : <kai@adventure-works.com>
RoleDefinitionName : Azure Cosmos DB Control Plane Owner
RoleDefinitionId   : e4e4e4e4-ffff-aaaa-bbbb-c5c5c5c5c5c5

Remarque

Dans cet exemple, la propriété RoleAssignmentId est /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleAssignments/ffffffff-eeee-dddd-cccc-bbbbbbbbbbb0, un autre exemple fictif. Il s’agit d’un sous-ensemble de la sortie classique du déploiement, pour plus de clarté.

Répétez ces étapes pour accorder l’accès au compte à partir d’autres identités que vous souhaitez utiliser.

Conseil

Vous pouvez répéter ces étapes pour autant d’identités que vous le souhaitez. En règle générale, ces étapes sont au moins répétées pour permettre aux développeurs d’accéder à un compte à l’aide de leur identité humaine et pour accorder aux applications l’accès à l’aide d’une identité managée.

Valider l’accès au plan de contrôle dans le code

Enfin, vérifiez que vous avez correctement accordé l’accès à l’aide du code d’application et du SDK Gestion Azure dans votre langage de programmation préféré.

using Azure.Identity;
using Azure.ResourceManager;

DefaultAzureCredential credential = new();

ArmClient client = new(credential);

Important

Cet exemple de code utilise les bibliothèques Azure.ResourceManager.CosmosDB et Azure.Identity de NuGet.

const { CosmosDBManagementClient } = require('@azure/arm-cosmosdb');
const { DefaultAzureCredential } = require('@azure/identity');

const subscriptionId = "<subscription-id>";

const credential = new DefaultAzureCredential();

const client = new CosmosDBManagementClient(credential, subscriptionId);

Important

Cet exemple de code utilise les bibliothèques @azure/arm-cosmosdb et @azure/identity de npm.

import { CosmosDBManagementClient } from '@azure/arm-cosmosdb';
import { TokenCredential, DefaultAzureCredential } from '@azure/identity';

let subscriptionId: string = "<subscription-id>";

let credential: TokenCredential = new DefaultAzureCredential();

const client: CosmosDBManagementClient = new CosmosDBManagementClient(credential, subscriptionId);

Important

Cet exemple de code utilise les bibliothèques @azure/arm-cosmosdb et @azure/identity de npm.

from azure.mgmt.cosmosdb import CosmosDBManagementClient
from azure.identity import DefaultAzureCredential

subscription_id = "<subscription-id>"

credential = DefaultAzureCredential()

client = CosmosDBManagementClient(credential=credential, subscription=subscription_id)

Important

Cet exemple de code utilise les bibliothèques azure-mgmt-cosmosdb et azure-identity de PyPI.

package main

import (
    "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
    "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/cosmos/armcosmos"
)

const subscriptionId = "<subscription-id>"

func main() {
    credential, _ := azidentity.NewDefaultAzureCredential(nil)
    
    client, _ := armcosmos.NewDatabaseClient(subscriptionId, credential, nil)
}

Important

Cet exemple de code utilise les bibliothèques azure/azure-sdk-for-go/sdk/resourcemanager/cosmos/armcosmos et azure/azure-sdk-for-go/sdk/azidentity de Go.

package com.example;

import com.azure.core.management.profile.AzureProfile;
import com.azure.core.management.AzureEnvironment;
import com.azure.identity.DefaultAzureCredential;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.resourcemanager.cosmos.CosmosManager;

public class CosmosDB {
    public static void main(String[] args) {
        AzureProfile profile = new AzureProfile(AzureEnvironment.AZURE);
        DefaultAzureCredential credential = new DefaultAzureCredentialBuilder()
          .build();

        CosmosManager manager = CosmosManager.authenticate(credential, profile);
    }
}

Important

Cet exemple de code utilise les bibliothèques com.azure.resourcemanager/azure-resourcemanager-cosmos et com.azure/azure-identity de Maven.

Étape suivante

Accorder à votre identité un accès en fonction du rôle du plan de données

Partager via

Utiliser le contrôle d’accès en fonction du rôle du plan de contrôle avec Azure Cosmos DB for Table

Prérequis

Préparer la définition de rôle

Attribuer un rôle à l’identité

Valider l’accès au plan de contrôle dans le code

Étape suivante

Commentaires

Ressources supplémentaires