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

Articolo
2025-04-23
Si applica a: ✅ NoSQL

SI APPLICA A: NoSQL

Questo articolo illustra la procedura per concedere a un'identità l'accesso per gestire i dati in un account Azure Cosmos DB per NoSQL.

Importante

I passaggi descritti in questo articolo riguardano solo l'accesso al piano dati per eseguire operazioni su singoli elementi ed eseguire query. Per informazioni su come gestire database e contenitori per il piano di controllo, vedere Concedere l'accesso in base al ruolo del piano di controllo.

Prerequisiti

Un account Azure con una sottoscrizione attiva. Creare un account gratuito.
Un account Azure Cosmos DB for NoSQL già presente.
Una o più identità esistenti in Microsoft Entra ID.

Utilizza l'ambiente Bash in Azure Cloud Shell. Per altre informazioni, vedere Introduzione ad Azure Cloud Shell.
Se preferisci eseguire localmente i comandi CLI di riferimento, installa l'Azure CLI. Se si esegue 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 usi un'installazione locale, accedi all'interfaccia della riga di comando di Azure usando il comando az login. Per completare il processo di autenticazione, seguire i passaggi visualizzati nel terminale. Per altre opzioni di accesso, vedere Eseguire l'autenticazione ad Azure con l'interfaccia della riga di comando di Azure.
- Quando ti viene richiesto, installa l'estensione Azure CLI al primo utilizzo. Per altre informazioni sulle estensioni, vedere Usare e gestire le estensioni con l'interfaccia della riga di comando di Azure.
- Esegui az version per trovare la versione e le librerie dipendenti installate. Per eseguire l'aggiornamento alla versione più recente, avviare az upgrade.

Se scegli di utilizzare Azure PowerShell localmente:
- Installare la versione più recente del modulo Az PowerShell.
- Connettersi all'account Azure con il cmdlet Connect-AzAccount.
Se si sceglie di usare Azure Cloud Shell:
- Vedi Panoramica di Azure Cloud Shell per ulteriori informazioni.

Preparare la definizione del ruolo

Prima di tutto, è necessario preparare una definizione di ruolo con un elenco di dataActions per concedere l'accesso alla lettura, interrogazione e gestione dei dati in Azure Cosmos DB per NoSQL.

Definizione predefinita
Definizione personalizzata

Importante

Per ottenere una definizione di ruolo del piano dati esistente sono necessarie queste autorizzazioni del piano di controllo:

Microsoft.DocumentDB/databaseAccounts/sqlRoleDefinitions/read

Per altre informazioni, vedere Concedere l'accesso in base al ruolo del piano di controllo.

Elencare tutte le definizioni di ruolo associate all'account Azure Cosmos DB per NoSQL usando az cosmosdb sql role definition list. Esaminare l'output e individuare la definizione del ruolo denominata Cosmos DB Built-in Data Contributor. 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 cosmosdb sql role definition list \
    --resource-group "<name-of-existing-resource-group>" \
    --account-name "<name-of-existing-nosql-account>"

[
  ...,
  {
    "assignableScopes": [
      "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql"
    ],
    "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql/sqlRoleDefinitions/00000000-0000-0000-0000-000000000002",
    "name": "00000000-0000-0000-0000-000000000002",
    "permissions": [
      {
        "dataActions": [
          "Microsoft.DocumentDB/databaseAccounts/readMetadata",
          "Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/*",
          "Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/*"
        ],
        "notDataActions": []
      }
    ],
    "resourceGroup": "msdocs-identity-example",
    "roleName": "Cosmos DB Built-in Data Contributor",
    "type": "Microsoft.DocumentDB/databaseAccounts/sqlRoleDefinitions",
    "typePropertiesType": "BuiltInRole"
  }
  ...
]

Annotazioni

Per questo esempio, il valore id sarebbe /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql/sqlRoleDefinitions/00000000-0000-0000-0000-000000000002. In questo esempio vengono usati dati fittizi e l'identificatore è diverso da questo esempio.

Usare Get-AzCosmosDBSqlRoleDefinition per elencare tutte le definizioni di ruolo associate all'account Azure Cosmos DB per NoSQL. Esaminare l'output e individuare la definizione del ruolo denominata Cosmos DB Built-in Data Contributor. 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 = @{
    ResourceGroupName = "<name-of-existing-resource-group>"
    AccountName = "<name-of-existing-nosql-account>"
}
Get-AzCosmosDBSqlRoleDefinition @parameters

Id                         : /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql/sqlRoleDefinitions/00000000-0000-0000-0000-000000000002
RoleName                   : Cosmos DB Built-in Data Contributor
Type                       : BuiltInRole
AssignableScopes           : {/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccountsmsdocs-identity-example-nosql}
Permissions.DataActions    : {Microsoft.DocumentDB/databaseAccounts/readMetadata, Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/*, Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/*}
Permissions.NotDataActions :

Annotazioni

Per questo esempio, il valore Id sarebbe /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql/sqlRoleDefinitions/00000000-0000-0000-0000-000000000002. In questo esempio vengono usati dati fittizi e l'identificatore è diverso da questo esempio. Tuttavia, l'identificatore (00000000-0000-0000-0000-000000000002) è univoco in tutte le definizioni di ruolo nell'account.

Importante

La creazione di una nuova definizione di ruolo del piano dati richiede queste autorizzazioni del piano di controllo:

Microsoft.DocumentDB/databaseAccounts/sqlRoleDefinitions/read
Microsoft.DocumentDB/databaseAccounts/sqlRoleDefinitions/write

Per altre informazioni, vedere Concedere l'accesso in base al ruolo del piano di controllo.

Avvertimento

Il controllo degli accessi in base al ruolo nativo di Azure Cosmos DB per NoSQL non supporta la notDataActions proprietà . Tutte le azioni non specificate come consentite dataAction vengono escluse automaticamente.

Creare un nuovo file JSON denominato role-definition.json. In questo file creare una definizione di risorsa specificando le azioni sui dati elencate di seguito:

	Descrizione
`Microsoft.DocumentDB/databaseAccounts/readMetadata`	Può leggere i metadati a livello di account
*`Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/`**	Può eseguire qualsiasi operazione sui dati a livello di contenitore
*`Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/`**	Può eseguire qualsiasi operazione sugli elementi con contenitori

{
  "RoleName": "Azure Cosmos DB for NoSQL Data Plane Owner",
  "Type": "CustomRole",
  "AssignableScopes": [
    "/"
  ],
  "Permissions": [
    {
      "DataActions": [
        "Microsoft.DocumentDB/databaseAccounts/readMetadata",
        "Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/*",
        "Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/*"
      ]
    }
  ]
}

Usare az cosmosdb sql role definition create quindi per creare la definizione del ruolo. Usare il role-definition.json come input per l'argomento --body .

az cosmosdb sql role definition create \
    --resource-group "<name-of-existing-resource-group>" \
    --account-name "<name-of-existing-nosql-account>" \
    --body "@role-definition.json"

Elencare ora tutte le definizioni di ruolo associate all'account Azure Cosmos DB per NoSQL usando az cosmosdb sql role definition list.

az cosmosdb sql role definition list \
    --resource-group "<name-of-existing-resource-group>" \
    --account-name "<name-of-existing-nosql-account>"

Esaminare l'output del comando precedente. Individuare la definizione del ruolo appena creata denominata Azure Cosmos DB per il proprietario del piano dati NOSQL. 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/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql"
  ],
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql/sqlRoleDefinitions/bbbbbbbb-1111-2222-3333-cccccccccccc",
  "name": "bbbbbbbb-1111-2222-3333-cccccccccccc",
  "permissions": [
    {
      "dataActions": [
        "Microsoft.DocumentDB/databaseAccounts/readMetadata",
        "Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/*",
        "Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/*"
      ],
      "notDataActions": []
    }
  ],
  "resourceGroup": "msdocs-identity-example",
  "roleName": "Azure Cosmos DB for NoSQL Data Plane Owner",
  "type": "Microsoft.DocumentDB/databaseAccounts/sqlRoleDefinitions",
  "typePropertiesType": "CustomRole"
}

Annotazioni

Per questo esempio, il valore id sarebbe /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql/sqlRoleDefinitions/bbbbbbbb-1111-2222-3333-cccccccccccc. In questo esempio vengono usati dati fittizi e l'identificatore è diverso da questo esempio.

Creare un nuovo file Bicep per definire la definizione del ruolo. Nomina il file data-plane-role-definition.bicep. Aggiungere questi dataActions elementi alla definizione:

	Descrizione
`Microsoft.DocumentDB/databaseAccounts/readMetadata`	Può leggere i metadati a livello di account
*`Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/`**	Può eseguire qualsiasi operazione sui dati a livello di contenitore
*`Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/`**	Può eseguire qualsiasi operazione sugli elementi con contenitori

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

@description('Name of the Azure Cosmos DB for NoSQL account.')
param accountName string

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

resource account 'Microsoft.DocumentDB/databaseAccounts@2024-05-15' existing = {
  name: accountName
}

resource definition 'Microsoft.DocumentDB/databaseAccounts/sqlRoleDefinitions@2024-05-15' = {
  name: guid(account.id, roleDefinitionName)
  parent: account
  properties: {
    roleName: roleDefinitionName
    type: 'CustomRole'
    assignableScopes: [
      account.id
    ]
    permissions: [
      {
        dataActions: [
          'Microsoft.DocumentDB/databaseAccounts/readMetadata'
          'Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/*'
          'Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/*'
        ]
      }
    ]
  }
}

output definitionId string = definition.id

Creare un nuovo file di parametri Bicep denominato data-plane-role-definition.bicepparam In questo file di parametri, assegna il nome dell'account esistente di Azure Cosmos DB per NoSQL al parametro accountName.
```
using './data-plane-role-definition.bicep'

param accountName = '<name-of-existing-nosql-account>'
```

Distribuisci il modello Bicep usando az deployment group create.

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

Creare una nuova definizione di ruolo usando New-AzCosmosDBSqlRoleDefinition. Per il DataAction parametro specificare le azioni di dati elencate di seguito:

	Descrizione
`Microsoft.DocumentDB/databaseAccounts/readMetadata`	Può leggere i metadati a livello di account
*`Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/`**	Può eseguire qualsiasi operazione sui dati a livello di contenitore
*`Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/`**	Può eseguire qualsiasi operazione sugli elementi con contenitori

$parameters = @{
    ResourceGroupName = "<name-of-existing-resource-group>"
    AccountName = "<name-of-existing-nosql-account>"
    RoleName = "Azure Cosmos DB for NoSQL Data Plane Owner"
    Type = "CustomRole"
    AssignableScope = @(
        "/"
    )
    DataAction = @(
        "Microsoft.DocumentDB/databaseAccounts/readMetadata",
        "Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/*",
        "Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/*"
    )
}
New-AzCosmosDBSqlRoleDefinition @parameters

Usare Get-AzCosmosDBSqlRoleDefinition per elencare tutte le definizioni di ruolo associate all'account Azure Cosmos DB per NoSQL.

$parameters = @{
    ResourceGroupName = "<name-of-existing-resource-group>"
    AccountName = "<name-of-existing-nosql-account>"
}
Get-AzCosmosDBSqlRoleDefinition @parameters

Esaminare l'output del comando precedente. Individuare la definizione del ruolo appena creata denominata Azure Cosmos DB per il proprietario del piano dati NOSQL. 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.

Id                         : /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql/sqlRoleDefinitions/bbbbbbbb-1111-2222-3333-cccccccccccc
RoleName                   : Azure Cosmos DB for NoSQL Data Plane Owner
Type                       : CustomRole
AssignableScopes           : {/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql}
Permissions.DataActions    : {Microsoft.DocumentDB/databaseAccounts/readMetadata, Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/*, Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/*}
Permissions.NotDataActions :

Annotazioni

Per questo esempio, il valore Id sarebbe /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql/sqlRoleDefinitions/bbbbbbbb-1111-2222-3333-cccccccccccc. In questo esempio vengono usati dati fittizi e l'identificatore è diverso da questo esempio.

Assegnare un ruolo all'identità

Assegnare ora il ruolo appena definito a un'identità in modo che le applicazioni possano accedere ai dati in Azure Cosmos DB per NoSQL.

Importante

La creazione di un'assegnazione di ruolo del piano dati richiede queste autorizzazioni del piano di controllo:

Microsoft.DocumentDB/databaseAccounts/sqlRoleDefinitions/read
Microsoft.DocumentDB/databaseAccounts/sqlRoleAssignments/read
Microsoft.DocumentDB/databaseAccounts/sqlRoleAssignments/write

Per altre informazioni, vedere Concedere l'accesso in base al ruolo del piano di controllo.

Usare az cosmosdb show per ottenere l'identificatore univoco per l'account corrente.

az cosmosdb show \
    --resource-group "<name-of-existing-resource-group>" \
    --name "<name-of-existing-nosql-account>" \
    --query "{id:id}"

Osservate l'output del comando precedente. Registrare il valore della id proprietà per questo account perché è necessario usare nel passaggio successivo.
```
{
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql"
}
```
Annotazioni

Per questo esempio, il valore id sarebbe /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql. In questo esempio vengono usati dati fittizi e l'identificatore è diverso da questo esempio.
Assegnare il nuovo ruolo usando az cosmosdb sql role assignment create. Usa gli identificatori di definizione del ruolo registrati in precedenza per l'argomento --role-definition-id e l'identificatore univoco della tua identità per l'argomento --principal-id. Infine, usare l'identificatore dell'account per l'argomento --scope.
```
az cosmosdb sql role assignment create \
    --resource-group "<name-of-existing-resource-group>" \
    --account-name "<name-of-existing-nosql-account>" \
    --role-definition-id "<id-of-new-role-definition>" \
    --principal-id "<id-of-existing-identity>" \
    --scope "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql"
```
Suggerimento

Se si tenta di concedere il controllo degli accessi in base al ruolo del piano dati alla propria identità, è possibile usare questo comando per ottenere l'identità:
```
az ad signed-in-user show
```
Per altre informazioni, vedere az ad signed-in-user.
Usare az cosmosdb sql role assignment list per elencare tutte le assegnazioni di ruolo per l'account Azure Cosmos DB per NoSQL. Esaminare l'output per verificare che l'assegnazione di ruolo sia stata creata.
```
az cosmosdb sql role assignment list \
    --resource-group "<name-of-existing-resource-group>" \
    --account-name "<name-of-existing-nosql-account>"
```

Creare un nuovo file Bicep per definire la tua assegnazione di ruolo. Assegnare al file il nome data-plane-role-assignment.bicep.

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

@description('Name of the Azure Cosmos DB for NoSQL account.')
param accountName string

@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 = deployer().objectId

resource account 'Microsoft.DocumentDB/databaseAccounts@2024-05-15' existing = {
  name: accountName
}

resource assignment 'Microsoft.DocumentDB/databaseAccounts/sqlRoleAssignments@2024-05-15' = {
  name: guid(roleDefinitionId, identityId, account.id)
  parent: account
  properties: {
    principalId: identityId
    roleDefinitionId: roleDefinitionId
    scope: account.id
  }
}

output assignmentId string = assignment.id

Creare un nuovo file di parametri Bicep denominato data-plane-role-assignment.bicepparam In questo file di parametri assegnare il nome dell'account Azure Cosmos DB per NoSQL esistente al accountName parametro , gli identificatori di definizione del ruolo registrati in precedenza al roleDefinitionId parametro e l'identificatore univoco per l'identità al identityId parametro .
```
using './data-plane-role-assignment.bicep'

param accountName = '<name-of-existing-nosql-account>'
param roleDefinitionId = '<id-of-new-role-definition>'
param identityId = '<id-of-existing-identity>'
```
Suggerimento

Se si sta tentando di concedere il controllo degli accessi in base al ruolo del piano dati alla propria identità, è possibile omettere il parametro identityId. Il modello Bicep userà quindi deployer().objectId per ottenere l'identità del principale che ha distribuito il modello. Per altre informazioni, vedere deployer.

Distribuisci il modello Bicep usando az deployment group create.

az deployment group create \
    --resource-group "<name-of-existing-resource-group>" \
    --parameters data-plane-role-assignment.bicepparam \
    --template-file data-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. È anche possibile ripetere questi passaggi per consentire alle applicazioni di accedere alle risorse usando un'identità gestita.

Usare Get-AzCosmosDBAccount per ottenere i metadati per l'account corrente.

$parameters = @{
    ResourceGroupName = "<name-of-existing-resource-group>"
    Name = "<name-of-existing-nosql-account>"
}    
Get-AzCosmosDBAccount @parameters | Select -Property Id

Osservate l'output del comando precedente. Registrare il valore della Id proprietà per questo account perché è necessario usare nel passaggio successivo.
```
Id
--    
/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql
```
Annotazioni

Per questo esempio, il valore Id sarebbe /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql. In questo esempio vengono usati dati fittizi e l'identificatore è diverso da questo esempio.

Usare New-AzCosmosDBSqlRoleAssignment per assegnare il nuovo ruolo. Usare gli identificatori di definizione del ruolo registrati in precedenza per il parametro RoleDefinitionId e l'identificatore univoco per l'identità al parametro PrincipalId. Infine, usate l'identificatore dell'account per il parametro Scope.

$parameters = @{
    ResourceGroupName = "<name-of-existing-resource-group>"
    AccountName = "<name-of-existing-nosql-account>"
    RoleDefinitionId = "<id-of-new-role-definition>"
    PrincipalId = "<id-of-existing-identity>"
    Scope = "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql"
}    
New-AzCosmosDBSqlRoleAssignment @parameters

Suggerimento

Se si tenta di concedere il controllo degli accessi in base al ruolo del piano dati alla propria identità, è possibile usare questo comando per ottenere l'identità:

Get-AzADUser -SignedIn | Format-List `
    -Property Id, DisplayName, Mail, UserPrincipalName

Per altre informazioni, vedere Get-AzADUser.

Elencare tutte le assegnazioni di ruolo per l'account Azure Cosmos DB per NoSQL usando Get-AzCosmosDBSqlRoleAssignment. Rivedi l'output per assicurarti che il tuo ruolo sia stato assegnato.
```
$parameters = @{
    ResourceGroupName = "<name-of-existing-resource-group>"
    AccountName = "<name-of-existing-nosql-account>"
}
Get-AzCosmosDBSqlRoleAssignment @parameters
```

Convalidare l'accesso al piano dati nel codice

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

using Azure.Core;
using Azure.Identity;
using Microsoft.Azure.Cosmos;

string endpoint = "<account-endpoint>";

TokenCredential credential = new DefaultAzureCredential();

CosmosClient client = new(endpoint, credential);

Container container = client.GetContainer("<database-name>", "<container-name>");

await container.ReadItemAsync<dynamic>("<item-id>", new PartitionKey("<partition-key>"));

Importante

Questo esempio di codice usa le Microsoft.Azure.Cosmos librerie e Azure.Identity di NuGet.

const { CosmosClient } = require('@azure/cosmos');
const { DefaultAzureCredential } = require('@azure/identity');

const endpoint = '<account-endpoint>';

const credential = new DefaultAzureCredential();

const client = new CosmosClient({ endpoint, aadCredentials:credential});

const container = client.database('<database-name>').container('<container-name>');

await container.item('<item-id>', '<partition-key>').read<String>();

Importante

Questo esempio di codice usa i @azure/cosmos pacchetti e @azure/identity di npm.

import { Container, CosmosClient, CosmosClientOptions } from '@azure/cosmos'
import { TokenCredential, DefaultAzureCredential } from '@azure/identity'

let endpoint: string = '<account-endpoint>';

let credential: TokenCredential = new DefaultAzureCredential();

let options: CosmosClientOptions = {
  endpoint: endpoint,
  aadCredentials: credential
};

const client: CosmosClient = new CosmosClient(options);

const container: Container = client.database('<database-name>').container('<container-name>');

await container.item('<item-id>', '<partition-key>').read<String>();

Importante

Questo esempio di codice usa i @azure/cosmos pacchetti e @azure/identity di npm.

from azure.cosmos import CosmosClient
from azure.identity import DefaultAzureCredential

endpoint = "<account-endpoint>"

credential = DefaultAzureCredential()

client = CosmosClient(endpoint, credential=credential)

container = client.get_database_client("<database-name>").get_container_client("<container-name>")

container.read_item(
    item="<item-id>",
    partition_key="<partition-key>",
)

Importante

Questo esempio di codice utilizza i pacchetti azure-cosmos e azure-identity da PyPI.

import (
    "context"
    
    "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
    "github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos"
)

const endpoint = "<account-endpoint>"

func main() {
    credential, _ := azidentity.NewDefaultAzureCredential(nil)
    client, _ := azcosmos.NewClient(endpoint, credential, nil)
    
    database, _ := client.NewDatabase("<database-name>")
    container, _ := database.NewContainer("<container-name>")
    
    _, err := container.ReadItem(context.TODO(), azcosmos.NewPartitionKeyString("<partition-key>"), "<item-id>", nil)
    if err != nil {
        panic(err)
    }
}

Importante

Questo esempio di codice usa i azure/azure-sdk-for-go/sdk/data/azcosmosazure/azure-sdk-for-go/azidentity pacchetti di Go.

import com.azure.cosmos.CosmosClient;
import com.azure.cosmos.CosmosClientBuilder;
import com.azure.cosmos.CosmosContainer;
import com.azure.cosmos.models.PartitionKey;
import com.azure.identity.DefaultAzureCredential;
import com.azure.identity.DefaultAzureCredentialBuilder;

public class NoSQL {
    public static void main(String[] args) {   
        DefaultAzureCredential credential = new DefaultAzureCredentialBuilder()
            .build();
            
        CosmosClient client = new CosmosClientBuilder()
            .endpoint("<account-endpoint>")
            .credential(credential)
            .buildClient();

        CosmosContainer container = client.getDatabase("<database-name>").getContainer("<container-name>");

        container.readItem("<item-id>", new PartitionKey("<partition-key>"), Object.class);
    }
}

Importante

Questo esempio di codice usa i com.azure/azure-cosmos pacchetti e com.azure/azure-identity di Maven.

use azure_data_cosmos::CosmosClient;
use azure_identity::DefaultAzureCredential;

fn main() {
    let credential = DefaultAzureCredential::new().unwrap();
    let client = CosmosClient::new("<account-endpoint>", credential, None).unwrap();

    let container = client.database_client("<database-name>").container_client("<container-name>");

    let response = container.read_item("<partition-key>", "<item-id>", None);
    tokio::runtime::Runtime::new().unwrap().block_on(response).unwrap();
}

Importante

Questo esempio di codice usa i pacchetti azure_data_cosmos e azure_identity di Cargo.

Condividi tramite

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

Prerequisiti

Preparare la definizione del ruolo

Assegnare un ruolo all'identità

Convalidare l'accesso al piano dati nel codice

Contenuti correlati

Commenti e suggerimenti

Risorse aggiuntive