Connettersi ad Azure Cosmos DB per NoSQL usando il controllo degli accessi in base al ruolo e l'ID Microsoft Entra

2025-09-11
Si applica a: ✅ NoSQL

Il controllo degli accessi in base al ruolo fa riferimento a un metodo per gestire l'accesso alle risorse in Azure. Questo metodo si basa su identità specifiche assegnate ai ruoli che gestiscono il livello di accesso a una o più risorse. Il controllo degli accessi in base al ruolo offre un sistema flessibile di gestione degli accessi con granularità fine che garantisce che le identità abbiano solo il livello di accesso con privilegi minimi necessari per svolgere le proprie attività.

Per altre informazioni, vedere Controllo degli accessi in base al ruolo.

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.

È possibile utilizzare l'ambiente Bash in Azure Cloud Shell. Per altre informazioni, vedere Introduzione ad Azure Cloud Shell.
Se preferisci eseguire localmente i comandi di riferimento della CLI, installa l'Azure CLI. 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 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 la procedura visualizzata 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.

Disabilitare l'autenticazione basata su chiave

La disabilitazione dell'autorizzazione basata su chiave impedisce l'uso dell'account senza il metodo di autenticazione microsoft Entra ID più sicuro. Questa procedura è un passaggio che deve essere eseguito sui nuovi account nei carichi di lavoro sicuri. In alternativa, eseguire questa procedura sugli account esistenti di cui viene eseguita la migrazione a un modello di carico di lavoro sicuro.

Prima di tutto, disabilitare l'autenticazione basata su chiave per l'account esistente, così che le applicazioni siano obbligate a usare l'autenticazione con ID Microsoft Entra. Usare az resource update per modificare properties.disableLocalAuth l'account esistente.

az resource update \
    --resource-group "<name-of-existing-resource-group>" \
    --name "<name-of-existing-account>" \
    --resource-type "Microsoft.DocumentDB/databaseAccounts" \
    --set properties.disableLocalAuth=true

Per prima cosa, crea un nuovo account con l'autenticazione basata su chiave disabilitata, in modo che le applicazioni siano obbligate a utilizzare l'autenticazione Microsoft Entra.

Creare un nuovo file Bicep per distribuire il nuovo account con l'autenticazione basata su chiave disabilitata. Assegnare al file il nome deploy-new-account.bicep.

metadata description = 'Deploys a new Azure Cosmos DB account with key-based auth disabled.'

@description('Name of the Azure Cosmos DB account.')
param name string = 'csms-${uniqueString(resourceGroup().id)}'

@description('Primary ___location for the Azure Cosmos DB account.')
param ___location string = resourceGroup().___location

resource account 'Microsoft.DocumentDB/databaseAccounts@2024-05-15' = {
  name: name
  ___location: ___location
  kind: 'GlobalDocumentDB'
  properties: {
    databaseAccountOfferType: 'Standard'
    locations: [
      {
        locationName: ___location
      }
    ]
    disableLocalAuth: true
  }
}

Usare az deployment group create per distribuire il file Bicep con il nuovo account.

az deployment group create \
    --resource-group "<name-of-existing-resource-group>" \
    --template-file deploy-new-account.bicep

Prima di tutto, disabilitare l'autenticazione basata su chiave per l'account esistente in modo che le applicazioni siano obbligate a usare l'autenticazione di Microsoft Entra. Usare Get-AzResource e Set-AzResource per leggere e aggiornare rispettivamente l'account esistente.

$parameters = @{
    ResourceGroupName = "<name-of-existing-resource-group>"
    ResourceName = "<name-of-existing-account>"
    ResourceType = "Microsoft.DocumentDB/databaseAccounts"
}
$resource = Get-AzResource @parameters

$resource.Properties.DisableLocalAuth = $true

$resource | Set-AzResource -Force

Usare questi passaggi per creare un nuovo account Azure Cosmos DB per NoSQL con autenticazione basata su chiave disabilitata in modo che le applicazioni siano obbligate a usare solo l'autenticazione Microsoft Entra.

Quando si configura un nuovo account Azure Cosmos DB per NoSQL, passare alla sezione Sicurezza del processo di creazione dell'account.
Quindi, seleziona Disabilita per l'opzione Autenticazione basata su chiave.

Importante

Per modificare un account Azure Cosmos DB è necessario un ruolo di Azure con almeno l'autorizzazione Microsoft.DocumentDb/databaseAccounts/*/write . Per altre informazioni, vedere Autorizzazioni per Azure Cosmos DB.

Verificare che l'autenticazione basata su chiave sia disabilitata

Per verificare che l'accesso basato su chiave sia disabilitato, provare a usare Azure SDK per connettersi ad Azure Cosmos DB per NoSQL usando una credenziale della password del proprietario della risorsa (ROPC). Questo tentativo dovrebbe non riuscire. Se necessario, qui sono disponibili esempi di codice per i linguaggi di programmazione comuni.

using Microsoft.Azure.Cosmos;

string connectionString = "AccountEndpoint=<nosql-endpoint>;AccountKey=<key>;";

CosmosClient client = new(connectionString);

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

const connectionString = 'AccountEndpoint=<nosql-endpoint>;AccountKey=<key>;';

const client = new CosmosClient(connectionString);

import { CosmosClient } from '@azure/cosmos'

let connectionString: string = 'AccountEndpoint=<nosql-endpoint>;AccountKey=<key>;';

const client: CosmosClient = new CosmosClient(connectionString);

from azure.cosmos import CosmosClient

connection_string = "AccountEndpoint=<nosql-endpoint>;AccountKey=<key>;"

client = CosmosClient(connection_string)

package main

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

const connectionString = "AccountEndpoint=<nosql-endpoint>;AccountKey=<key>;"

func main() {
    client, _ := azcosmos.NewClientFromConnectionString(connectionString, nil)
}

import com.azure.cosmos.CosmosClient;
import com.azure.cosmos.CosmosClientBuilder;

public class NoSQL{
    public static void main(String[] args){
        CosmosClient client = new CosmosClientBuilder()
            .endpoint("<nosql-endpoint>")
            .key("<key>")
            .buildClient();
    }
}

use azure_data_cosmos::CosmosClient;

fn main() {
    let client = CosmosClient::new_with_access_key(
        "<account-endpoint>",
        "<account-key>",
        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();
}

Concedere l'accesso in base al ruolo del piano di controllo

L'accesso al piano di controllo si riferisce alla possibilità di gestire le risorse per un servizio di Azure senza gestire i dati. Ad esempio, l'accesso al piano di controllo di Azure Cosmos DB può includere la possibilità di:

Leggere tutti i metadati di account e risorse
Leggere e rigenerare le chiavi dell'account e le stringhe di connessione
Eseguire backup e ripristino dell'account
Avviare e tenere traccia dei processi di trasferimento dei dati
Gestire database e contenitori
Modificare le proprietà dell'account

Importante

In Azure Cosmos DB è necessario l'accesso al piano di controllo per gestire le definizioni e le assegnazioni di controllo degli accessi basati sui ruoli del piano dati nativo. Poiché il meccanismo di controllo degli accessi in base al ruolo del piano dati di Azure Cosmos DB è nativo, è necessario disporre dell'accesso del piano di controllo per creare definizioni e assegnazioni e archiviarli come risorse all'interno di un account Azure Cosmos DB.

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. In questa guida si prepara un ruolo predefinito e personalizzato. Assegnare quindi il ruolo appena definito a un'identità in modo che le applicazioni possano accedere alle risorse in Azure Cosmos DB.

Elencare tutte le definizioni di ruolo associate all'account Azure Cosmos DB usando az role definition list.
```
az role definition list \
    --name "Cosmos DB Operator"
```

Esaminare l'output e individuare la definizione del ruolo denominata Operatore 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.

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

Annotazioni

In questo esempio il id valore sarà /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.

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"
}
```
Annotazioni

In questo esempio il id valore sarà /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example. In questo esempio vengono usati dati fittizi e l'identificatore è diverso da questo esempio. Questa stringa è 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"
  ]
}
```
Annotazioni

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 potrebbe 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/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1",
  "name": "e4e4e4e4-ffff-aaaa-bbbb-c5c5c5c5c5c5",
  "permissions": [
    {
      "actions": [
        "Microsoft.DocumentDb/*"
      ]
    }
  ],
  "roleName": "Azure Cosmos DB Control Plane Owner",
  "roleType": "CustomRole"
}
```
Annotazioni

In questo esempio il id valore sarà /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleDefinitions/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1. In questo esempio vengono usati dati fittizi e l'identificatore è diverso da questo esempio. Questo esempio è un subset del tipico codice JSON restituito dalla distribuzione per maggiore chiarezza.
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"
}
```
Annotazioni

In questo esempio il id valore sarà /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example. In questo esempio vengono usati dati fittizi e l'identificatore è diverso da questo esempio. Questa stringa è un esempio troncato dell'output.
Assegnare il nuovo ruolo usando az role assignment create. Usa l'identificatore del gruppo di risorse per l'argomento --scope, l'identificatore del ruolo per l'argomento -role e l'identificatore univoco per la tua identità per l'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/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1" \
    --scope "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example"
```
Annotazioni

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 su /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleDefinitions/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1, che è fittizio. Anche in questo caso, l'identificatore del ruolo sarà distinto.

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

{
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleAssignments/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1",
  "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/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1",
  "scope": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example",
  "type": "Microsoft.Authorization/roleAssignments"
}

Annotazioni

In questo esempio la id proprietà è /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleAssignments/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1, che è 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 ai dati usando un'identità gestita.

Elencare tutte le definizioni di ruolo associate all'account Azure Cosmos DB usando az role definition list.
```
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",
  }
]

Annotazioni

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:

	Description
*`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/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1"
      }
    }
  }
}
```
Annotazioni

In questo esempio il id valore sarà /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleDefinitions/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1. In questo esempio vengono usati dati fittizi e l'identificatore è diverso da questo esempio. Questo esempio è un subset del tipico codice JSON restituito dalla distribuzione per maggiore chiarezza.

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 ruolo registrati in precedenza al parametro roleDefinitionId e l'identificatore univoco della propria identità al parametro identityId.
```
using './control-plane-role-assignment.bicep'

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

Implementare 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 ai dati usando un'identità gestita.

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.

Screenshot di un gruppo di risorse esistente nell'elenco dei gruppi di risorse per la sottoscrizione.

Annotazioni

Questo screenshot di esempio include il msdocs-identity-example gruppo di risorse. Il nome effettivo del gruppo di risorse potrebbe 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.

Screenshot di un elenco di definizioni di ruolo nell'attuale ambito assegnabile, filtrato per includere solo le definizioni con "Cosmos DB" nel titolo.
Nella finestra di dialogo della definizione del ruolo Operatore Cosmos DB, si possono osservare le azioni assegnate come parte del ruolo.
Chiudere la finestra di dialogo definizione del ruolo Operatore Cosmos DB .
Nel riquadro Controllo di accesso (IAM) selezionare Aggiungi. Selezionare quindi Aggiungi ruolo personalizzato.

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

	Value
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. Quindi, cerca DocumentDB 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. Selezionare quindi Rivedi + 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.
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 del 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.

Annotazioni

Questo screenshot mostra un utente di esempio denominato "Kai Carter" con un'entità di sicurezza 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. Infine, selezionare Rivedi e assegna.
Attendere che il portale finisca di creare l'assegnazione di ruolo.

Usare Get-AzRoleDefinition per elencare tutte le definizioni di ruolo associate all'account Azure Cosmos DB.
```
$parameters = @{
    Name = "Cosmos DB Operator"
}
Get-AzRoleDefinition @parameters
```

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.

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

Annotazioni

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

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/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1/resourcegroups/msdocs-identity-example
```
Annotazioni

In questo esempio il ResourceId valore sarà /subscriptions/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1/resourcegroups/msdocs-identity-example. In questo esempio vengono usati dati fittizi e l'identificatore è diverso da questo esempio. Questa stringa è 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. Infine, utilizzare l'oggetto definizione ruolo come input del parametro -Role 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
```
Annotazioni

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 potrebbe 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}
```
Annotazioni

In questo esempio il Name valore sarà Azure Cosmos DB Control Plane Owner. Questo esempio è un subset dell'output tipico della distribuzione per maggiore chiarezza.

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

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

RoleAssignmentName : ffffffff-5555-6666-7777-aaaaaaaaaaaa
RoleAssignmentId   : /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleAssignments/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1
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

Annotazioni

In questo esempio la RoleAssignmentId proprietà è /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleAssignments/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1, che è un altro esempio fittizio. Questo esempio è 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 ai dati usando un'identità gestita.

Importante

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

Convalidare l'accesso in base al ruolo del piano di controllo nel codice

Verificare di aver concesso correttamente l'accesso usando il codice dell'applicazione e Azure Management SDK.

using Azure.Identity;
using Azure.ResourceManager;

DefaultAzureCredential credential = new();

ArmClient client = new(credential);

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

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

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

subscription_id = "<subscription-id>"

credential = DefaultAzureCredential()

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

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

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

Concedere l'accesso in base al ruolo del piano dati

L'accesso al piano dati si riferisce alla possibilità di leggere e scrivere dati all'interno di un servizio di Azure senza la possibilità di gestire le risorse nell'account. Ad esempio, l'accesso al piano dati di Azure Cosmos DB può includere la possibilità di:

Leggere alcuni metadati di account e risorse
Creare, leggere, aggiornare, applicare patch ed eliminare elementi
Eseguire query NoSQL
Leggere dal feed di modifiche di un contenitore
Eseguire procedure memorizzate (stored procedure)
Gestire i conflitti nel feed dei conflitti

Prima di tutto, devi preparare una definizione di ruolo con un elenco di dataActions per concedere l'accesso alla lettura, eseguire query e gestire i dati in Azure Cosmos DB per NoSQL. In questa guida si prepara un ruolo predefinito e personalizzato. Assegnare quindi il ruolo appena definito a un'identità in modo che le applicazioni possano accedere ai dati in Azure Cosmos DB per NoSQL.

Importante

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

Microsoft.DocumentDB/databaseAccounts/sqlRoleDefinitions/read

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

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

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.

Elencare 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 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.

[
  ...,
  {
    "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

In questo esempio il id valore sarà /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.

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:

	Description
`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

In questo esempio il id valore sarà /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.

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

Osservare 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

In questo esempio il id valore sarà /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. Usare gli identificatori di definizione del ruolo registrati in precedenza per l'argomento --role-definition-id e l'identificatore univoco della propria 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.
Suggerimento

Nell'implementazione nativa di Azure Cosmos DB del controllo degli accessi in base al ruolo, l'ambito fa riferimento alla granularità delle risorse all'interno di un account per cui si vuole applicare l'autorizzazione. Al livello più alto, è possibile definire l'ambito di un'assegnazione di controllo degli accessi in base al ruolo del piano dati all'intero account usando l'ambito più grande. Questo ambito include tutti i database e i contenitori all'interno dell'account:
```
/subscriptions/<subscription-id>/resourcegroups/<resource-group-name>/providers/Microsoft.DocumentDB/databaseAccounts/<account-name>/
```
In alternativa, è possibile definire l'ambito dell'assegnazione di ruolo del piano dati a un database specifico:
```
/subscriptions/<subscription-id>/resourcegroups/<resource-group-name>/providers/Microsoft.DocumentDB/databaseAccounts/<account-name>/dbs/<database-name>
```
Infine, è possibile definire l'ambito dell'assegnazione a un singolo contenitore, l'ambito più granulare:
```
/subscriptions/<subscription-id>/resourcegroups/<resource-group-name>/providers/Microsoft.DocumentDB/databaseAccounts/<account-name>/dbs/<database-name>/colls/<container-name>
```
In molti casi, è possibile usare l'ambito relativo anziché l'ambito completo. Ad esempio, è possibile usare questo ambito relativo per concedere autorizzazioni di controllo degli accessi in base al ruolo del piano dati per un database e un contenitore specifici da un comando dell'interfaccia della riga di comando di Azure:
```
/dbs/<database-name>/colls/<container-name>
```
È anche possibile concedere l'accesso universale a tutti i database e ai contenitori usando l'ambito relativo:
```
/
```
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 la tua 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>"
```

Elencare 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 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.

[
  ...,
  {
    "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

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

	Description
`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

Suggerimento

Nell'implementazione nativa di Azure Cosmos DB del controllo degli accessi in base al ruolo, l'ambito fa riferimento alla granularità delle risorse all'interno di un account per cui si vuole applicare l'autorizzazione. Al livello più alto, è possibile definire l'ambito di un'assegnazione di controllo degli accessi in base al ruolo del piano dati all'intero account usando l'ambito più grande. Questo ambito include tutti i database e i contenitori all'interno dell'account:

/subscriptions/<subscription-id>/resourcegroups/<resource-group-name>/providers/Microsoft.DocumentDB/databaseAccounts/<account-name>/

In alternativa, è possibile definire l'ambito dell'assegnazione di ruolo del piano dati a un database specifico:

/subscriptions/<subscription-id>/resourcegroups/<resource-group-name>/providers/Microsoft.DocumentDB/databaseAccounts/<account-name>/dbs/<database-name>

Infine, è possibile definire l'ambito dell'assegnazione a un singolo contenitore, l'ambito più granulare:

/subscriptions/<subscription-id>/resourcegroups/<resource-group-name>/providers/Microsoft.DocumentDB/databaseAccounts/<account-name>/dbs/<database-name>/colls/<container-name>

In molti casi, è possibile usare l'ambito relativo anziché l'ambito completo. Ad esempio, è possibile usare questo ambito relativo per concedere autorizzazioni di controllo degli accessi in base al ruolo del piano dati per un database e un contenitore specifici da un comando dell'interfaccia della riga di comando di Azure:

/dbs/<database-name>/colls/<container-name>

È anche possibile concedere l'accesso universale a tutti i database e ai contenitori usando l'ambito relativo:

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

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

Distribuire 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 un nuovo file Bicep per definire l'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 usa deployer().objectId quindi per ottenere l'identità dell'entità che ha distribuito il modello. Per altre informazioni, vedere deployer.

Distribuire 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-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

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

In questo esempio il Id valore sarà /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.

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

	Description
`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

Suggerimento

/subscriptions/<subscription-id>/resourcegroups/<resource-group-name>/providers/Microsoft.DocumentDB/databaseAccounts/<account-name>/

In alternativa, è possibile definire l'ambito dell'assegnazione di ruolo del piano dati a un database specifico:

/subscriptions/<subscription-id>/resourcegroups/<resource-group-name>/providers/Microsoft.DocumentDB/databaseAccounts/<account-name>/dbs/<database-name>

Infine, è possibile definire l'ambito dell'assegnazione a un singolo contenitore, l'ambito più granulare:

/subscriptions/<subscription-id>/resourcegroups/<resource-group-name>/providers/Microsoft.DocumentDB/databaseAccounts/<account-name>/dbs/<database-name>/colls/<container-name>

/dbs/<database-name>/colls/<container-name>

È anche possibile concedere l'accesso universale a tutti i database e ai contenitori usando l'ambito relativo:

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

In questo esempio il Id valore sarà /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.

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

Osservare 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

In questo esempio il Id valore sarà /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 della tua identità per il parametro PrincipalId. Infine, utilizzare 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. Esaminare l'output per verificare che la tua assegnazione di ruolo sia stata creata.
```
$parameters = @{
    ResourceGroupName = "<name-of-existing-resource-group>"
    AccountName = "<name-of-existing-nosql-account>"
}
Get-AzCosmosDBSqlRoleAssignment @parameters
```

Avvertimento

La gestione del controllo degli accessi in base al ruolo del piano dati non è supportata nel portale di Azure.

Verificare l'accesso basato su ruoli del piano dati nel codice

Verificare di aver concesso correttamente l'accesso usando il codice dell'applicazione e Azure SDK.

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>"));

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>();

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>();

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>",
)

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

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

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

Commenti e suggerimenti

Questa pagina è stata utile?

Condividi tramite

Connettersi ad Azure Cosmos DB per NoSQL usando il controllo degli accessi in base al ruolo e l'ID Microsoft Entra

Prerequisiti

Disabilitare l'autenticazione basata su chiave

Verificare che l'autenticazione basata su chiave sia disabilitata

Concedere l'accesso in base al ruolo del piano di controllo

Convalidare l'accesso in base al ruolo del piano di controllo nel codice

Concedere l'accesso in base al ruolo del piano dati

Verificare l'accesso basato su ruoli del piano dati nel codice

Contenuti correlati

Commenti e suggerimenti

Risorse aggiuntive