Usare il controllo degli accessi in base al ruolo del piano di controllo con Azure Cosmos DB per NoSQL

Articolo
10/02/2024

SI APPLICA A: NoSQL

Diagramma della posizione corrente ('Controllo degli accessi in base al ruolo') nella sequenza della guida alla distribuzione.

Questo articolo illustra i passaggi per concedere a un'identità l'accesso per gestire un account Azure Cosmos DB per NoSQL e le relative risorse.

Importante

I passaggi descritti in questo articolo riguardano solo l'accesso al piano di controllo per eseguire operazioni sull'account stesso di qualsiasi risorsa nella gerarchia dell'account. Per informazioni su come gestire gli elementi ed eseguire query per il piano dati, vedere Concedere l'accesso in base al ruolo del piano dati.

Prerequisiti

Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
Un account Azure Cosmos DB esistente.
Una o più identità esistenti in Microsoft Entra ID.

Usare l'ambiente Bash in Azure Cloud Shell. Per altre informazioni, vedere Avvio rapido su Bash in Azure Cloud Shell.
Se si preferisce eseguire i comandi di riferimento dell'interfaccia della riga di comando in locale, installare l'interfaccia della riga di comando di Azure. Per l'esecuzione in Windows o macOS, è consigliabile eseguire l'interfaccia della riga di comando di Azure in un contenitore Docker. Per altre informazioni, vedere Come eseguire l'interfaccia della riga di comando di Azure in un contenitore Docker.
- Se si usa un'installazione locale, accedere all'interfaccia della riga di comando di Azure con il comando az login. Per completare il processo di autenticazione, seguire la procedura visualizzata nel terminale. Per altre opzioni di accesso, vedere Accedere tramite l'interfaccia della riga di comando di Azure.
- Quando richiesto, al primo utilizzo installare l'estensione dell'interfaccia della riga di comando di Azure. Per altre informazioni sulle estensioni, vedere Usare le estensioni con l'interfaccia della riga di comando di Azure.
- Eseguire az version per trovare la versione e le librerie dipendenti installate. Per eseguire l'aggiornamento alla versione più recente, eseguire az upgrade.

Se si sceglie di usare Azure PowerShell in locale:
- Installare la versione più recente del modulo Az di PowerShell.
- Connettersi all'account Azure con il cmdlet Connect-AzAccount.
Se si sceglie di usare Azure Cloud Shell:
- Vedere Panoramica di Azure Cloud Shell per altre informazioni.

Preparare la definizione del ruolo

Prima di tutto, è necessario preparare una definizione di ruolo con un elenco di actions per concedere l'accesso per gestire le risorse dell'account in Azure Cosmos DB.

Definizione predefinita
Definizione personalizzata

Elencare tutte le definizioni di ruolo associate all'account Azure Cosmos DB usando az role definition list. Esaminare l'output e individuare la definizione del ruolo denominata Collaboratore dati predefinito di Cosmos DB. L'output contiene l'identificatore univoco della definizione del ruolo nella id proprietà . Registrare questo valore perché è necessario usare nel passaggio di assegnazione più avanti in questa guida.

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",
  }
]

Nota

Per questo esempio, il valore id sarebbe /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/providers/Microsoft.Authorization/roleDefinitions/230815da-be43-4aae-9cb4-875f7bd000aa. In questo esempio vengono usati dati fittizi e l'identificatore è diverso da questo esempio. Tuttavia, l'identificatore (230815da-be43-4aae-9cb4-875f7bd000aa) è globalmente univoco in tutte le definizioni di ruolo in Azure.

Accedere al portale di Azure (https://portal.azure.com).
Immettere Gruppo di risorse nella barra di ricerca globale.
In Servizi selezionare Gruppi di risorse.
Nel riquadro Gruppi di risorse selezionare il gruppo di risorse esistente.

Nota

Questo screenshot di esempio include il msdocs-identity-example gruppo di risorse. Il nome effettivo del gruppo di risorse può essere diverso.
Nel riquadro del gruppo di risorse selezionare Controllo di accesso (IAM) nel menu del servizio.
Nel riquadro Controllo di accesso (IAM) selezionare Ruoli.
Nella sezione Ruoli usare la frase di ricerca Cosmos DB e individuare la definizione del ruolo Operatore Cosmos DB. Selezionare quindi l'opzione Visualizza associata a tale definizione.
Nella finestra di dialogo definizione del ruolo Operatore Cosmos DB osservare le azioni assegnate come parte di questa definizione di ruolo.
Chiudere la finestra di dialogo definizione del ruolo Operatore Cosmos DB.

Usare Get-AzRoleDefinition per elencare tutte le definizioni di ruolo associate all'account Azure Cosmos DB. Esaminare l'output e individuare la definizione del ruolo denominata Collaboratore dati predefinito di Cosmos DB. L'output contiene l'identificatore univoco della definizione del ruolo nella Id proprietà . Registrare questo valore perché è necessario usare nel passaggio di assegnazione più avanti in questa guida.

$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 : {/}

Nota

Per questo esempio, il valore Id sarebbe 230815da-be43-4aae-9cb4-875f7bd000aa. L'identificatore è globalmente univoco in tutte le definizioni di ruolo in Azure.

Usare az group show per ottenere i metadati per il gruppo di risorse corrente.
```
az group show \
    --name "<name-of-existing-resource-group>"
```
Osservare l'output del comando precedente. Registrare il valore della id proprietà per questo gruppo di risorse perché è necessario usare nel passaggio successivo.
```
{
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example",
  "location": "westus",
  "name": "msdocs-identity-example",
  "type": "Microsoft.Resources/resourceGroups"
}
```
Nota

Per questo esempio, il valore id sarebbe /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example. In questo esempio vengono usati dati fittizi e l'identificatore è diverso da questo esempio. Questo è un esempio troncato dell'output.
Creare un nuovo file JSON denominato role-definition.json. Nel file creare questa definizione di risorsa specificando i valori elencati qui. Per l'elenco AssignableScopes , aggiungere la id proprietà del gruppo di risorse registrato nel passaggio precedente.
```
{
  "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"
  ]
}
```
Nota

In questo esempio viene usato il /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example valore registrato nel passaggio precedente. L'identificatore effettivo della risorsa può essere diverso.
Creare una nuova definizione di ruolo usando az role definition create. Usare il file role-definition.json come input per l'argomento --role-definition .
```
az role definition create \
    --role-definition role-definition.json
```
Esaminare l'output del comando di creazione della definizione. L'output contiene l'identificatore univoco della definizione del ruolo nella id proprietà . Registrare questo valore perché è necessario usare nel passaggio di assegnazione più avanti in questa guida.
```
{
  "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"
}
```
Nota

Per questo esempio, il valore id sarebbe /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleDefinitions/ffffffff-eeee-dddd-cccc-bbbbbbbbbbb0. In questo esempio vengono usati dati fittizi e l'identificatore è diverso da questo esempio. Si tratta di un subset del tipico codice JSON restituito dalla distribuzione per maggiore chiarezza.

Creare un nuovo file Bicep per definire la definizione del ruolo. Assegnare al file il nome control-plane-role-definition.bicep. Aggiungere questi actions elementi alla definizione:

	Descrizione
*`Microsoft.DocumentDb/`**	Abilita tutte le azioni possibili.

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

Distribuire il modello Bicep usando az deployment group create. Specificare il nome del modello Bicep e del gruppo di risorse di Azure.

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

Esaminare l'output della distribuzione. L'output contiene l'identificatore univoco della definizione del ruolo nella properties.outputs.definitionId.value proprietà . Registrare questo valore perché è necessario usare nel passaggio di assegnazione più avanti in questa guida.
```
{
  "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"
      }
    }
  }
}
```
Nota

Per questo esempio, il valore id sarebbe /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleDefinitions/ffffffff-eeee-dddd-cccc-bbbbbbbbbbb0. In questo esempio vengono usati dati fittizi e l'identificatore è diverso da questo esempio. Si tratta di un subset del tipico codice JSON restituito dalla distribuzione per maggiore chiarezza.

Nel riquadro Controllo di accesso (IAM) selezionare Aggiungi e quindi Aggiungi ruolo personalizzato.

Nel riquadro Informazioni di base configurare le opzioni seguenti e quindi selezionare Avanti:

	Valore
Nome del ruolo personalizzato	`Azure Cosmos DB Control Plane Owner`
Descrizione	`Can perform all control plane actions for an Azure Cosmos DB account.`
Autorizzazioni di base	Iniziare da zero

Screenshot del riquadro

Nel riquadro Autorizzazioni selezionare Aggiungi autorizzazioni. DocumentDB Cercare quindi nella finestra di dialogo delle autorizzazioni. Infine, selezionare l'opzione Microsoft.DocumentDB .
Nella finestra di dialogo autorizzazioni selezionare tutte le azioni per Microsoft.DocumentDB. Selezionare quindi Aggiungi per tornare al riquadro *Autorizzazioni .
Nel riquadro Autorizzazioni osservare l'elenco delle autorizzazioni. Quindi selezionare Rivedi e crea.
Nel riquadro Rivedi e crea esaminare le opzioni specificate per la nuova definizione del ruolo. Infine, selezionare Crea.
Attendere che il portale finisca di creare la definizione del ruolo.

Usare Get-AzResourceGroup per ottenere i metadati per il gruppo di risorse corrente.

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

Osservare l'output del comando precedente. Registrare il valore della ResourceId proprietà per questo gruppo di risorse perché è necessario usare nel passaggio successivo.
```
ResourceGroupName : msdocs-identity-example
Location          : westus
ProvisioningState : Succeeded
ResourceId        : /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example
```
Nota

Per questo esempio, il valore ResourceId sarebbe /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example. In questo esempio vengono usati dati fittizi e l'identificatore è diverso da questo esempio. Questo è un esempio troncato dell'output tipico.
Prima di tutto, importare il Az.Resources modulo. Creare quindi un nuovo Microsoft.Azure.Commands.Resources.Models.Authorization.PSRoleDefinition oggetto. Nell'oggetto creare questa definizione di risorsa specificando i valori elencati qui. Per l'elenco AssignableScopes , aggiungere la ResourceId proprietà del gruppo di risorse registrato nel passaggio precedente. Usare infine l'oggetto definizione del ruolo come input per il -Role parametro di 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
```
Nota

In questo esempio viene usato il /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example valore registrato nel passaggio precedente. L'identificatore effettivo della risorsa può essere diverso.
Esaminare l'output del comando di creazione della definizione. L'output contiene l'identificatore univoco della definizione del ruolo nella Name proprietà . Registrare questo valore perché è necessario usare nel passaggio di assegnazione più avanti in questa guida.
```
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}
```
Nota

Per questo esempio, il valore Name sarebbe Azure Cosmos DB Control Plane Owner. Si tratta di un subset dell'output tipico della distribuzione per maggiore chiarezza.

Assegnare un ruolo all'identità

Assegnare ora il ruolo appena definito a un'identità in modo che le applicazioni possano accedere alle risorse in Azure Cosmos DB.

Importante

Questa attività di assegnazione richiede di avere già l'identificatore univoco di qualsiasi identità che si vuole concedere autorizzazioni di controllo degli accessi in base al ruolo.

Usare az group show per ottenere di nuovo i metadati per il gruppo di risorse corrente.
```
az group show \
    --name "<name-of-existing-resource-group>"
```
Osservare l'output del comando precedente. Registrare il valore della id proprietà per questo gruppo di risorse perché è necessario usare nel passaggio successivo.
```
{
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example",
  "location": "westus",
  "name": "msdocs-identity-example",
  "type": "Microsoft.Resources/resourceGroups"
}
```
Nota

Per questo esempio, il valore id sarebbe /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example. In questo esempio vengono usati dati fittizi e l'identificatore è diverso da questo esempio. Questo è un esempio troncato dell'output.
Assegnare il nuovo ruolo usando az role assignment create. Usare l'identificatore del gruppo di risorse per l'argomento --scope , l'identificatore del ruolo per l'argomento -role e l'identificatore univoco per l'identità dell'argomento --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"
```
Nota

In questo comando di esempio l'oggetto scope è stato impostato sull'esempio /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example fittizio dell'esempio del passaggio precedente. L'identificatore del gruppo di risorse sarà diverso da questo esempio. È role stato impostato anche sull'oggetto fittizio /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleDefinitions/ffffffff-eeee-dddd-cccc-bbbbbbbbbbb0. Anche in questo caso, l'identificatore del ruolo sarà distinto.

Osservare l'output dal comando . L'output include un identificatore univoco per l'assegnazione nella id proprietà .

{
  "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"
}

Nota

In questo esempio la id proprietà è /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleAssignments/ffffffff-eeee-dddd-cccc-bbbbbbbbbbb0 un altro esempio fittizio.

Ripetere questi passaggi per concedere l'accesso all'account da qualsiasi altra identità che si vuole usare.

Suggerimento

È possibile ripetere questi passaggi per tutte le identità desiderate. In genere, questi passaggi vengono almeno ripetuti per consentire agli sviluppatori di accedere a un account usando la propria identità umana e consentire alle applicazioni di accedere usando un'identità gestita.

Creare un nuovo file Bicep per definire l'assegnazione di ruolo. Assegnare al file il nome 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
  }
}

Creare un nuovo file di parametri Bicep denominato control-plane-role-assignment.bicepparam In questo file di parametri; assegnare gli identificatori di definizione del roleDefinitionId ruolo registrati in precedenza al parametro e l'identificatore univoco per l'identità al identityId parametro .
```
using './control-plane-role-assignment.bicep'

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

Distribuire questo modello Bicep usando 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

Ripetere questi passaggi per concedere l'accesso all'account da qualsiasi altra identità che si vuole usare.

Suggerimento

È possibile ripetere questi passaggi per tutte le identità desiderate. In genere, questi passaggi vengono almeno ripetuti per consentire agli sviluppatori di accedere a un account usando la propria identità umana e consentire alle applicazioni di accedere usando un'identità gestita.

Nel riquadro Controllo di accesso (IAM) selezionare Aggiungi e quindi Aggiungi assegnazione di ruolo.
Nel riquadro Ruolo cercare Azure Cosmos DB e quindi selezionare il ruolo Proprietario piano di controllo di Azure Cosmos DB creato in precedenza in questa guida. Quindi seleziona Avanti.

Suggerimento

Facoltativamente, è possibile filtrare l'elenco dei ruoli in modo da includere solo ruoli personalizzati.
Nel riquadro Membri selezionare l'opzione Seleziona membri. Nella finestra di dialogo membri selezionare l'identità che si vuole concedere a questo livello di accesso per l'account Azure Cosmos DB e quindi usare l'opzione Seleziona per confermare la scelta.

Nota

Questo screenshot illustra un utente di esempio denominato "Kai Carter" con un'entità di sicurezza di kai@adventure-works.com.
Tornare al riquadro Membri , esaminare il membro selezionato[s] e quindi selezionare Rivedi e assegna.
Nel riquadro Rivedi e assegna esaminare le opzioni specificate per la nuova assegnazione di ruolo. Selezionare infine Rivedi e assegna.
Attendere che il portale finisca di creare l'assegnazione di ruolo.

Assegnare il nuovo ruolo usando New-AzRoleAssignment. Usare il nome del ruolo per il RoleDefinitionName parametro e l'identificatore univoco dell'identità per il ObjectId parametro .

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

Osservare l'output dal comando . L'output include un identificatore univoco per l'assegnazione nella RoleAssignmentId proprietà .

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

Nota

In questo esempio la RoleAssignmentId proprietà è /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleAssignments/ffffffff-eeee-dddd-cccc-bbbbbbbbbbb0 un altro esempio fittizio. Si tratta di un subset dell'output tipico della distribuzione per maggiore chiarezza.

Ripetere questi passaggi per concedere l'accesso all'account da qualsiasi altra identità che si vuole usare.

Suggerimento

È possibile ripetere questi passaggi per tutte le identità desiderate. In genere, questi passaggi vengono almeno ripetuti per consentire agli sviluppatori di accedere a un account usando la propria identità umana e consentire alle applicazioni di accedere usando un'identità gestita.

Convalidare l'accesso del piano di controllo nel codice

Verificare infine di aver concesso correttamente l'accesso usando il codice dell'applicazione e Azure Management SDK nel linguaggio di programmazione preferito.

using Azure.Identity;
using Azure.ResourceManager;

DefaultAzureCredential credential = new();

ArmClient client = new(credential);

Importante

Questo esempio di codice usa le Azure.ResourceManager.CosmosDB librerie e Azure.Identity di 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);

Importante

Questo esempio di codice usa le @azure/arm-cosmosdb librerie e @azure/identity di 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);

Importante

Questo esempio di codice usa le @azure/arm-cosmosdb librerie e @azure/identity di 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)

Importante

Questo esempio di codice usa le azure-mgmt-cosmosdb librerie e azure-identity da 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)
}

Importante

Questo esempio di codice usa le azure/azure-sdk-for-go/sdk/resourcemanager/cosmos/armcosmos librerie e azure/azure-sdk-for-go/sdk/azidentity di 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);
    }
}

Importante

Questo esempio di codice usa le com.azure.resourcemanager/azure-resourcemanager-cosmos librerie e com.azure/azure-identity di Maven.

Passaggio successivo

Concedere all'identità l'accesso in base al ruolo del piano dati

Condividi tramite

Usare il controllo degli accessi in base al ruolo del piano di controllo con Azure Cosmos DB per NoSQL

Prerequisiti

Preparare la definizione del ruolo

Assegnare un ruolo all'identità

Convalidare l'accesso del piano di controllo nel codice

Passaggio successivo

Commenti e suggerimenti

Risorse aggiuntive