Připojení ke službě Azure Cosmos DB for NoSQL pomocí řízení přístupu na základě role a ID Microsoft Entra

Platí pro: ✅ NoSQL

Řízení přístupu na základě role odkazuje na metodu pro správu přístupu k prostředkům v Azure. Tato metoda je založená na přiřazených rolích konkrétních identit, které spravují, jakou úroveň přístupu mají k jednomu nebo více prostředkům. Řízení přístupu na základě role poskytuje flexibilní systém jemně odstupňované správy přístupu, který zajišťuje, že identity mají pouze nejnižší úroveň přístupu, kterou potřebují k provedení své úlohy.

Další informace najdete v tématu řízení přístupu na základě role.

Požadavky

Účet Azure s aktivním předplatným. Vytvořte si bezplatný účet.
Existující účet Azure Cosmos DB určený pro NoSQL.
Jedna nebo více existujících identit v Microsoft Entra ID.

Použijte prostředí Bash v Azure Cloud Shellu. Další informace najdete v tématu Začínáme s Azure Cloud Shellem.
Pokud chcete spouštět referenční příkazy CLI lokálně, nainstalujte Azure CLI. Pokud používáte Windows nebo macOS, zvažte spuštění Azure CLI v kontejneru Docker. Pro více informací, viz Jak spustit Azure CLI v Docker kontejneru.
- Pokud používáte místní instalaci, přihlaste se k Azure CLI pomocí příkazu az login. Chcete-li dokončit proces ověřování, postupujte podle kroků zobrazených ve vašem terminálu. Další možnosti přihlášení najdete v tématu Ověřování v Azure pomocí Azure CLI.
- Když budete vyzváni, nainstalujte rozšíření Azure CLI při prvním použití. Další informace o rozšířeních najdete v tématu Použití a správa rozšíření pomocí Azure CLI.
- Spusťte az version, abyste zjistili verzi a závislé knihovny, které jsou nainstalovány. Pokud chcete upgradovat na nejnovější verzi, spusťte az upgrade.

Pokud se rozhodnete používat Azure PowerShell lokálně:
- Nainstalujte nejnovější verzi modulu Az PowerShell.
- Připojte se ke svému účtu Azure pomocí rutiny Connect-AzAccount .
Pokud se rozhodnete použít Azure Cloud Shell:
- Další informace najdete v přehledu služby Azure Cloud Shell .

Zakázání ověřování na základě klíčů

Zakázání autorizace založené na klíčích zabrání použití vašeho účtu bez bezpečnější metody ověřování Microsoft Entra ID. Tento postup je krok, který by se měl provést u nových účtů v zabezpečených úlohách. Případně tento postup proveďte u stávajících účtů migrovaných do zabezpečeného vzoru úloh.

Nejprve zakažte ověřování založené na klíči na vašem stávajícím účtu, aby aplikace musely používat ověřování Microsoft Entra ID. Slouží az resource update k úpravě properties.disableLocalAuth existujícího účtu.

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

Nejprve vytvořte nový účet se zakázaným ověřováním založeným na klíčích, aby aplikace musely používat ověřování Microsoft Entra.

Vytvořte nový soubor Bicep pro nasazení nového účtu se zakázaným ověřováním založeným na klíči. Pojmenujte soubor 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
  }
}

Použijte az deployment group create k nasazení souboru Bicep s novým účtem.

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

Nejprve zakažte ověřování na základě klíčů u stávajícího účtu, aby aplikace musely používat ověřování Microsoft Entra. Použijte Get-AzResource pro čtení a Set-AzResource pro aktualizaci existujícího účtu.

$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

Pomocí těchto kroků vytvořte nový účet Azure Cosmos DB for NoSQL se zakázaným ověřováním na základě klíčů, aby aplikace musely používat pouze ověřování Microsoft Entra.

Při nastavování nového účtu Azure Cosmos DB for NoSQL přejděte do části Zabezpečení procesu vytváření účtu.
Potom vyberte Možnost Zakázat pro ověřování na základě klíče .

Důležité

Úprava účtu služby Azure Cosmos DB vyžaduje roli Azure s alespoň oprávněním Microsoft.DocumentDb/databaseAccounts/*/write . Další informace najdete v tématu oprávnění ke službě Azure Cosmos DB.

Ověřte, že je zakázané ověřování na základě klíčů.

Pokud chcete ověřit, že je přístup založený na klíči zakázaný, pokuste se pomocí sady Azure SDK připojit ke službě Azure Cosmos DB for NoSQL pomocí přihlašovacích údajů vlastníka prostředku (ROPC). Tento pokus by měl selhat. V případě potřeby jsou zde uvedeny ukázky kódu pro běžné programovací jazyky.

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

Udělení přístupu na základě role řídicí roviny

Přístup řídicí roviny odkazuje na možnost spravovat prostředky pro službu Azure bez správy dat. Přístup k řídící rovině Azure Cosmos DB může například zahrnovat schopnost:

Číst všechna metadata účtů a prostředků
Čtení a opětovné vygenerování klíčů účtu a připojovacích řetězců
Zálohování a obnovení účtu
Zahájit a sledovat přenosové úlohy dat
Správa databází a kontejnerů
Úprava vlastností účtu

Důležité

Ve službě Azure Cosmos DB potřebujete přístup k řídicí ploše pro správu definic řízení přístupu na základě rolí a přiřazení v nativní datové rovině. Vzhledem k tomu, že mechanismus řízení přístupu na základě role na základě roviny dat služby Azure Cosmos DB je nativní, potřebujete přístup k rovině řízení, abyste mohli vytvářet definice a přiřazení a ukládat je jako prostředky v rámci účtu služby Azure Cosmos DB.

Nejprve musíte připravit definici role se seznamem actions pro udělení přístupu ke správě prostředků účtu ve službě Azure Cosmos DB. V této příručce připravíte integrovanou a vlastní roli. Potom přiřaďte nově definovanou roli identitě, aby vaše aplikace mohly přistupovat k prostředkům ve službě Azure Cosmos DB.

Zobrazí seznam všech definic rolí přidružených k vašemu účtu služby Azure Cosmos DB pomocí az role definition list.
```
az role definition list \
    --name "Cosmos DB Operator"
```

Zkontrolujte výstup a vyhledejte definici role s názvem Operátor služby Cosmos DB. Výstup obsahuje jedinečný identifikátor definice role ve id vlastnosti. Tuto hodnotu si poznamenejte, protože je potřeba ji použít v kroku přiřazení dále v tomto průvodci.

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

Poznámka:

V tomto příkladu id by hodnota byla /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/providers/Microsoft.Authorization/roleDefinitions/230815da-be43-4aae-9cb4-875f7bd000aa. Tento příklad používá fiktivní data a váš identifikátor by se od tohoto příkladu odlišil. Identifikátor (230815da-be43-4aae-9cb4-875f7bd000aa) je však globálně jedinečný napříč všemi definicemi rolí v Azure.

Pomocí az group show získejte metadata pro aktuální skupinu prostředků.
```
az group show \
    --name "<name-of-existing-resource-group>"
```
Prohlédněte si výstup předchozího příkazu. Poznamenejte si hodnotu id vlastnosti pro tuto skupinu prostředků, protože je nutné ji použít v dalším kroku.
```
{
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example",
  "location": "westus",
  "name": "msdocs-identity-example",
  "type": "Microsoft.Resources/resourceGroups"
}
```
Poznámka:

V tomto příkladu id by hodnota byla /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example. Tento příklad používá fiktivní data a váš identifikátor by se od tohoto příkladu odlišil. Tento řetězec je zkrácený příklad výstupu.
Vytvořte nový soubor JSON s názvem role-definition.json. V souboru vytvořte tuto definici prostředku, která určuje hodnoty uvedené zde. V seznamu AssignableScopes přidejte vlastnost id skupiny prostředků zaznamenané v předchozím kroku.
```
{
  "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"
  ]
}
```
Poznámka:

V tomto příkladu se /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example používá hodnota zaznamenaná z předchozího kroku. Váš skutečný identifikátor prostředku se může lišit.
Vytvořte novou definici role pomocí az role definition create. Jako vstup pro argument použijte soubor role-definition.json.
```
az role definition create \
    --role-definition role-definition.json
```
Zkontrolujte výstup příkazu pro vytvoření definice. Výstup obsahuje jedinečný identifikátor definice role ve id vlastnosti. Tuto hodnotu si poznamenejte, protože je potřeba ji použít v kroku přiřazení dále v tomto průvodci.
```
{
  "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"
}
```
Poznámka:

V tomto příkladu id by hodnota byla /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleDefinitions/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1. Tento příklad používá fiktivní data a váš identifikátor by se od tohoto příkladu odlišil. Tento příklad je podmnožinou typického výstupu JSON z nasazení pro přehlednost.
Použijte az group show, abyste znovu získali metadata pro vaši aktuální skupinu prostředků.
```
az group show \
    --name "<name-of-existing-resource-group>"
```
Prohlédněte si výstup předchozího příkazu. Poznamenejte si hodnotu id vlastnosti pro tuto skupinu prostředků, protože je nutné ji použít v dalším kroku.
```
{
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example",
  "location": "westus",
  "name": "msdocs-identity-example",
  "type": "Microsoft.Resources/resourceGroups"
}
```
Poznámka:

V tomto příkladu id by hodnota byla /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example. Tento příklad používá fiktivní data a váš identifikátor by se od tohoto příkladu odlišil. Tento řetězec je zkrácený příklad výstupu.
Přiřaďte novou roli pomocí az role assignment create. Pro argument použijte identifikátor --scope vaší skupiny prostředků, identifikátor role pro -role argument a jedinečný identifikátor vaší identity pro --assignee argument.
```
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"
```
Poznámka:

V tomto ukázkovém příkazu scope byl nastaven na fiktivní příklad /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example z příkladu předchozího kroku. Identifikátor vaší skupiny prostředků by se od tohoto příkladu odlišil. role byla také nastavena na fiktivní /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleDefinitions/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1. Identifikátor vaší role by byl opět odlišný.

Podívejte se na výstup příkazu. Výstup obsahuje jedinečný identifikátor přiřazení ve vlastnosti 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"
}

Poznámka:

V tomto příkladu je vlastnost id, což je další fiktivní příklad.

Pokud chcete udělit přístup k účtu z jiných identit, které chcete použít, opakujte tyto kroky.

Návod

Tento postup můžete opakovat pro tolik identit, kolik chcete. Tyto kroky se obvykle opakují, aby vývojáři měli přístup k účtu pomocí své lidské identity a umožnili aplikacím přístup k datům pomocí spravované identity.

Zobrazí seznam všech definic rolí přidružených k vašemu účtu služby Azure Cosmos DB pomocí 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",
  }
]

Poznámka:

Vytvořte nový soubor Bicep, který definuje definici vaší role. Pojmenujte soubor control-plane-role-definition.bicep. Přidejte je actions do definice:

	Description
*`Microsoft.DocumentDb/`**	Povolí všechny možné akce.

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

Nasaďte šablonu Bicep pomocí az deployment group create. Zadejte název šablony Bicep a skupiny prostředků Azure.

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

Zkontrolujte výstup z nasazení. Výstup obsahuje jedinečný identifikátor definice role ve properties.outputs.definitionId.value vlastnosti. Tuto hodnotu si poznamenejte, protože je potřeba ji použít v kroku přiřazení dále v tomto průvodci.
```
{
  "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"
      }
    }
  }
}
```
Poznámka:

V tomto příkladu id by hodnota byla /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleDefinitions/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1. Tento příklad používá fiktivní data a váš identifikátor by se od tohoto příkladu odlišil. Tento příklad je podmnožinou typického výstupu JSON z nasazení pro přehlednost.

Vytvořte nový soubor Bicep k definování přiřazení role. Pojmenujte soubor 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
  }
}

Vytvořte nový soubor parametrů Bicep s názvem control-plane-role-assignment.bicepparam. V tomto souboru parametrů přidělte parametru roleDefinitionId dříve zaznamenané identifikátory definic rolí a parametru identityId jedinečný identifikátor vaší identity.
```
using './control-plane-role-assignment.bicep'

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

Nasaďte tuto šablonu Bicep pomocí 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

Pokud chcete udělit přístup k účtu z jiných identit, které chcete použít, opakujte tyto kroky.

Návod

Tento postup můžete opakovat pro tolik identit, kolik chcete. Tyto kroky se obvykle opakují, aby vývojáři měli přístup k účtu pomocí své lidské identity a umožnili aplikacím přístup k datům pomocí spravované identity.

Přihlaste se k webu Azure Portal (https://portal.azure.com).
Do globálního panelu hledání zadejte Resource group.
V rámci služeb vyberte skupiny prostředků.
V podokně Skupiny prostředků vyberte existující skupinu prostředků.

Poznámka:

Tento příklad snímku obrazovky zahrnuje skupinu prostředků msdocs-identity-example. Váš skutečný název skupiny prostředků se může lišit.
V panelu skupiny prostředků vyberte v nabídce řízení přístupu (IAM).
V podokně Řízení přístupu (IAM) vyberte Role.
V části Role použijte hledanou frázi Cosmos DB a vyhledejte definici role Operátor služby Cosmos DB . Pak vyberte možnost Zobrazit přidruženou k této definici.
V dialogovém okně Definice role operátora služby Cosmos DB sledujte akce přiřazené jako součást této definice role.
Zavřete dialogové okno definice role operátora služby Cosmos DB .
Zpět v podokně Řízení přístupu (IAM) vyberte Přidat. Pak vyberte Přidat vlastní roli.

V podokně Základy nakonfigurujte následující možnosti a pak vyberte Další:

	Hodnota
Název vlastní role	`Azure Cosmos DB Control Plane Owner`
Description	`Can perform all control plane actions for an Azure Cosmos DB account.`
Základní oprávnění	Začít od začátku

Snímek obrazovky s podoknem Základy pro přidání vlastní role

V podokně Oprávnění vyberte Přidat oprávnění. Potom vyhledejte DocumentDB v dialogovém okně oprávnění. Nakonec vyberte možnost Microsoft.DocumentDB .
V dialogovém okně oprávnění vyberte všechny akce pro Microsoft.DocumentDB. Potom vyberte Přidat a vraťte se do panelu Oprávnění.
Zpět v podokně Oprávnění sledujte seznam oprávnění. Pak vyberte Zkontrolovat a vytvořit.
V podokně Zkontrolovat a vytvořit zkontrolujte zadané možnosti pro novou definici role. Nakonec vyberte Vytvořit.
Počkejte, až portál dokončí vytvoření definice role.
V podokně Řízení přístupu (IAM) vyberte Přidat a potom přidat přiřazení role.
V podokně Role vyhledejte Azure Cosmos DB a pak vyberte roli Vlastník řídicí roviny služby Azure Cosmos DB , kterou jste vytvořili dříve v této příručce. Pak vyberte Další.

Návod

Volitelně můžete seznam rolí filtrovat tak, aby zahrnoval pouze vlastní role.
V podokně Členové vyberte možnost Vybrat členy . V dialogovém okně Členové vyberte identitu, kterou chcete udělit této úrovni přístupu k účtu služby Azure Cosmos DB, a pak pomocí možnosti Vybrat potvrďte svou volbu.

Poznámka:

Tento snímek obrazovky znázorňuje příklad uživatele jménem "Kai Carter" s hlavním identifikátorem kai@adventure-works.com.
Zpět v podokně Členové zkontrolujte vybrané členy a pak vyberte Zkontrolovat a přiřadit.
V podokně Zkontrolovat a přiřadit zkontrolujte zadané možnosti pro nové přiřazení role. Nakonec vyberte Zkontrolovat a přiřadit.
Počkejte, až portál dokončí vytvoření přiřazení role.

Slouží Get-AzRoleDefinition k výpisu všech definic rolí přidružených k vašemu účtu služby Azure Cosmos DB.
```
$parameters = @{
    Name = "Cosmos DB Operator"
}
Get-AzRoleDefinition @parameters
```

Zkontrolujte výstup a vyhledejte definici role s názvem Předdefinovaný přispěvatel dat Cosmos DB. Výstup obsahuje jedinečný identifikátor definice role ve Id vlastnosti. Tuto hodnotu si poznamenejte, protože je potřeba ji použít v kroku přiřazení dále v tomto průvodci.

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

Poznámka:

V tomto příkladu Id by hodnota byla 230815da-be43-4aae-9cb4-875f7bd000aa. Identifikátor je globálně jedinečný napříč všemi definicemi rolí v Azure.

Pomocí Get-AzResourceGroup získejte metadata pro aktuální skupinu prostředků.

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

Prohlédněte si výstup předchozího příkazu. Poznamenejte si hodnotu ResourceId vlastnosti pro tuto skupinu prostředků, protože je nutné ji použít v dalším kroku.
```
ResourceGroupName : msdocs-identity-example
Location          : westus
ProvisioningState : Succeeded
ResourceId        : /subscriptions/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1/resourcegroups/msdocs-identity-example
```
Poznámka:

V tomto příkladu ResourceId by hodnota byla /subscriptions/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1/resourcegroups/msdocs-identity-example. Tento příklad používá fiktivní data a váš identifikátor by se od tohoto příkladu odlišil. Tento řetězec je zkrácený příklad typického výstupu.
Nejprve importujte Az.Resources modul. Pak vytvořte nový Microsoft.Azure.Commands.Resources.Models.Authorization.PSRoleDefinition objekt. V objektu vytvořte tuto definici prostředku určující hodnoty uvedené zde. V seznamu AssignableScopes přidejte vlastnost ResourceId skupiny prostředků zaznamenané v předchozím kroku. Nakonec použijte objekt definice role jako vstup pro -Role parametr .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
```
Poznámka:

V tomto příkladu se /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example používá hodnota zaznamenaná z předchozího kroku. Váš skutečný identifikátor prostředku se může lišit.
Zkontrolujte výstup příkazu pro vytvoření definice. Výstup obsahuje jedinečný identifikátor definice role ve Name vlastnosti. Tuto hodnotu si poznamenejte, protože je potřeba ji použít v kroku přiřazení dále v tomto průvodci.
```
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}
```
Poznámka:

V tomto příkladu Name by hodnota byla Azure Cosmos DB Control Plane Owner. Tento příklad je podmnožinou typického výstupu nasazení pro lepší srozumitelnost.

Přiřaďte novou roli pomocí New-AzRoleAssignment. Použijte název role pro RoleDefinitionName parametr a jedinečný identifikátor vaší identity pro ObjectId parametr.

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

Podívejte se na výstup příkazu. Výstup obsahuje jedinečný identifikátor přiřazení ve vlastnosti 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

Poznámka:

V tomto příkladu je vlastnost RoleAssignmentId, což je další fiktivní příklad. Tento příklad je podmnožinou typického výstupu nasazení pro lepší srozumitelnost.

Pokud chcete udělit přístup k účtu z jiných identit, které chcete použít, opakujte tyto kroky.

Návod

Tento postup můžete opakovat pro tolik identit, kolik chcete. Tyto kroky se obvykle opakují, aby vývojáři měli přístup k účtu pomocí své lidské identity a umožnili aplikacím přístup k datům pomocí spravované identity.

Důležité

Přiřazení definice role vyžaduje, abyste už měli jedinečný identifikátor jakékoli identity, kterou chcete udělit oprávnění řízení přístupu na základě role.

Ověření přístupu na základě role v rámci řídicí roviny v kódu.

Ověřte, že jste správně udělili přístup pomocí kódu aplikace a sady 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);
    }
}

Udělení přístupu k datové vrstvě na základě rolí.

Přístup roviny dat odkazuje na schopnost číst a zapisovat data ve službě Azure bez možnosti spravovat prostředky v účtu. Přístup k rovině dat ve službě Azure Cosmos DB může například zahrnovat následující možnosti:

Čtení metadat některých účtů a prostředků
Vytváření, čtení, aktualizace, oprava a odstraňování položek
Spouštění dotazů NoSQL
Čtení z kanálu změn v kontejneru
Spouštění uložených procedur
Správa konfliktů v informačním kanálu konfliktů

Nejprve musíte připravit definici role se seznamem dataActions pro udělení přístupu ke čtení, dotazování a správě dat ve službě Azure Cosmos DB for NoSQL. V této příručce připravíte vlastní roli. Pak přiřaďte nově definovanou roli identitě, aby vaše aplikace mohly přistupovat k datům ve službě Azure Cosmos DB for NoSQL.

Důležité

Získání stávající definice role roviny dat vyžaduje tato oprávnění řídicí roviny:

Microsoft.DocumentDB/databaseAccounts/sqlRoleDefinitions/read

Vytvoření nové definice role roviny dat vyžaduje tato oprávnění řídicí roviny:

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

Vytvoření nového přiřazení role v rovině dat vyžaduje následující oprávnění řídicí roviny:

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

Výstraha

Nativní řízení přístupu na základě role ve službě Azure Cosmos DB for NoSQL nepodporuje notDataActions vlastnost. Všechny akce, které nejsou zadány jako povolené dataAction , jsou vyloučeny automaticky.

Zobrazí seznam všech definic rolí přidružených k vašemu účtu Azure Cosmos DB for NoSQL pomocí 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>"

Vytvořte nový soubor JSON s názvem role-definition.json, který se používá k vytvoření vlastní role. V tomto souboru vytvořte definici prostředku, která určuje akce dat uvedené tady:

	Description
`Microsoft.DocumentDB/databaseAccounts/readMetadata`	Může číst metadata na úrovni účtu.
*`Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/`**	Může provádět jakékoli operace s daty na úrovni kontejneru.
*`Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/`**	Může provádět jakoukoli operaci s položkami s kontejnery.

{
  "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/*"
      ]
    }
  ]
}

Dále použijte az cosmosdb sql role definition create k vytvoření definice role. Jako vstup argumentu použijte --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"

Zkontrolujte výstup z předchozího příkazu. Vyhledejte definici role, kterou jste právě vytvořili s názvem Azure Cosmos DB for NOSQL Data Plane Owner. Výstup obsahuje jedinečný identifikátor definice role ve id vlastnosti. Tuto hodnotu si poznamenejte, protože je nutné ji použít v kroku přiřazení dále v tomto průvodci jako --role-definition-id

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

Poznámka:

V tomto příkladu --role-definition-id by hodnota byla bbbbbbbb-1111-2222-3333-cccccccccccc. Tento příklad používá fiktivní data a váš identifikátor by se od tohoto příkladu odlišil.

Použijte získané id v předchozím kroku a určete --scope odebráním všeho za názvem účtu.

Poznámka:

V tomto příkladu --scope by hodnota byla /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql. Tento příklad používá fiktivní data a váš identifikátor by se od tohoto příkladu odlišil.
Přiřaďte novou roli pomocí az cosmosdb sql role assignment create.
Použijte dříve zaznamenané identifikátory definic rolí k argumentu --role-definition-id ,
jedinečný identifikátor vaší identity pro --principal-id argument
a nakonec použijte identifikátor vašeho účtu pro --scope argument.
```
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"
```
Návod

Pokud se pokoušíte udělit řízení přístupu na základě role pro datovou rovinu své vlastní identitě, můžete k získání identity použít tento příkaz:
```
az ad signed-in-user show
```
Další informace najdete v tématu az ad signed-in-user.
Návod

V nativní implementaci řízení přístupu na základě role ve službě Azure Cosmos DB se rozsah týká členitosti prostředků v rámci účtu, pro který chcete použít oprávnění. Na nejvyšší úrovni můžete vymezit rozsah řízení přístupu na úrovni datové roviny na základě role pro celý účet s využitím nejširšího oboru. Tento obor zahrnuje všechny databáze a kontejnery v rámci účtu:
```
/subscriptions/<subscription-id>/resourcegroups/<resource-group-name>/providers/Microsoft.DocumentDB/databaseAccounts/<account-name>/
```
Nebo můžete určit rozsah přiřazení role roviny dat ke konkrétní databázi:
```
/subscriptions/<subscription-id>/resourcegroups/<resource-group-name>/providers/Microsoft.DocumentDB/databaseAccounts/<account-name>/dbs/<database-name>
```
Nakonec můžete přiřazení vymezit na jeden kontejner, nejpodrobnější rozsah:
```
/subscriptions/<subscription-id>/resourcegroups/<resource-group-name>/providers/Microsoft.DocumentDB/databaseAccounts/<account-name>/dbs/<database-name>/colls/<container-name>
```
V mnoha případech můžete použít relativní obor místo plně kvalifikovaného oboru. Tento relativní obor můžete například použít k udělení oprávnění řízení přístupu na základě role pro rovinu dat konkrétní databázi a kontejner pomocí příkazu Azure CLI.
```
/dbs/<database-name>/colls/<container-name>
```
Pomocí relativního rozsahu můžete také poskytnout univerzální přístup ke všem databázím a kontejnerům.
```
/
```
Slouží az cosmosdb sql role assignment list k výpisu všech přiřazení rolí pro váš účet Azure Cosmos DB for NoSQL. Zkontrolujte výstup a ujistěte se, že vaše přiřazení role bylo vytvořeno.
```
az cosmosdb sql role assignment list \
    --resource-group "<name-of-existing-resource-group>" \
    --account-name "<name-of-existing-nosql-account>"
```

Zobrazí seznam všech definic rolí přidružených k vašemu účtu Azure Cosmos DB for NoSQL pomocí 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>"

Zkontrolujte výstup a vyhledejte definici role s názvem Předdefinovaný přispěvatel dat Cosmos DB. Výstup obsahuje jedinečný identifikátor definice role ve id vlastnosti. Tuto hodnotu si poznamenejte, protože je potřeba ji použít v kroku přiřazení dále v tomto průvodci.

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

Poznámka:

V tomto příkladu id by hodnota byla /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql/sqlRoleDefinitions/00000000-0000-0000-0000-000000000002. Tento příklad používá fiktivní data a váš identifikátor by se od tohoto příkladu odlišil.

Vytvořte nový soubor Bicep, který definuje definici vaší role. Pojmenujte soubor data-plane-role-definition.bicep. Přidejte je dataActions do definice:

	Description
`Microsoft.DocumentDB/databaseAccounts/readMetadata`	Může číst metadata na úrovni účtu.
*`Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/`**	Může provádět jakékoli operace s daty na úrovni kontejneru.
*`Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/`**	Může provádět jakoukoli operaci s položkami s kontejnery.

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

Návod

V nativní implementaci řízení přístupu na základě role ve službě Azure Cosmos DB se rozsah týká členitosti prostředků v rámci účtu, pro který chcete použít oprávnění. Na nejvyšší úrovni můžete vymezit rozsah řízení přístupu na úrovni datové roviny na základě role pro celý účet s využitím nejširšího oboru. Tento obor zahrnuje všechny databáze a kontejnery v rámci účtu:

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

Nebo můžete určit rozsah přiřazení role roviny dat ke konkrétní databázi:

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

Nakonec můžete přiřazení vymezit na jeden kontejner, nejpodrobnější rozsah:

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

V mnoha případech můžete použít relativní obor místo plně kvalifikovaného oboru. Tento relativní obor můžete například použít k udělení oprávnění řízení přístupu na základě role pro rovinu dat konkrétní databázi a kontejner pomocí příkazu Azure CLI.

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

Pomocí relativního rozsahu můžete také poskytnout univerzální přístup ke všem databázím a kontejnerům.

Vytvořte nový soubor parametrů Bicep s názvem data-plane-role-definition.bicepparam. V tomto souboru parametrů přiřaďte k parametru accountName název existujícího účtu Azure Cosmos DB for NoSQL.
```
using './data-plane-role-definition.bicep'

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

Nasaďte šablonu Bicep pomocí 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

Vytvořte nový soubor Bicep k definování přiřazení role. Pojmenujte soubor 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

Vytvořte nový soubor parametrů Bicep s názvem data-plane-role-assignment.bicepparam. V tomto souboru parametrů přiřaďte k parametru accountName název existujícího účtu Azure Cosmos DB for NoSQL, k parametru roleDefinitionId dříve zaznamenané identifikátory definic rolí a k parametru identityId jedinečný identifikátor vaší identity.
```
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>'
```
Návod

Pokud se pokoušíte udělit řízení přístupu založeného na rolích v rámci roviny dat vlastní identitě, můžete tento parametr identityId vynechat. Šablona Bicep pak použije deployer().objectId k získání identity hlavního objektu, který nasadil šablonu. Další informace najdete v tématu deployer.

Nasaďte šablonu Bicep pomocí 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

Pokud chcete udělit přístup k účtu z jiných identit, které chcete použít, opakujte tyto kroky.

Návod

Tento postup můžete opakovat pro tolik identit, kolik chcete. Tyto kroky se obvykle opakují, aby vývojáři měli přístup k účtu pomocí své lidské identity. Tento postup můžete také zopakovat, abyste aplikacím umožnili přístup k prostředkům pomocí spravované identity.

Slouží Get-AzCosmosDBSqlRoleDefinition k výpisu všech definic rolí přidružených k vašemu účtu Azure Cosmos DB for 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 :

Poznámka:

V tomto příkladu Id by hodnota byla /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql/sqlRoleDefinitions/00000000-0000-0000-0000-000000000002. Tento příklad používá fiktivní data a váš identifikátor by se od tohoto příkladu odlišil. Identifikátor (00000000-0000-0000-0000-000000000002) je však jedinečný napříč všemi definicemi rolí ve vašem účtu.

Vytvořte novou definici role pomocí New-AzCosmosDBSqlRoleDefinition. Pro parametr DataAction zadejte datové akce uvedené zde:

	Description
`Microsoft.DocumentDB/databaseAccounts/readMetadata`	Může číst metadata na úrovni účtu.
*`Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/`**	Může provádět jakékoli operace s daty na úrovni kontejneru.
*`Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/`**	Může provádět jakoukoli operaci s položkami s kontejnery.

$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

Návod

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

Nebo můžete určit rozsah přiřazení role roviny dat ke konkrétní databázi:

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

Nakonec můžete přiřazení vymezit na jeden kontejner, nejpodrobnější rozsah:

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

Pomocí relativního rozsahu můžete také poskytnout univerzální přístup ke všem databázím a kontejnerům.

Slouží Get-AzCosmosDBSqlRoleDefinition k výpisu všech definic rolí přidružených k vašemu účtu Azure Cosmos DB for NoSQL.

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

Zkontrolujte výstup z předchozího příkazu. Vyhledejte definici role, kterou jste právě vytvořili s názvem Azure Cosmos DB for NOSQL Data Plane Owner. Výstup obsahuje jedinečný identifikátor definice role ve Id vlastnosti. Tuto hodnotu si poznamenejte, protože je potřeba ji použít v kroku přiřazení dále v tomto průvodci.

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 :

Poznámka:

V tomto příkladu Id by hodnota byla /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql/sqlRoleDefinitions/bbbbbbbb-1111-2222-3333-cccccccccccc. Tento příklad používá fiktivní data a váš identifikátor by se od tohoto příkladu odlišil.

Slouží Get-AzCosmosDBAccount k získání metadat pro váš aktuální účet.

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

Prohlédněte si výstup předchozího příkazu. Poznamenejte si hodnotu Id vlastnosti pro tento účet, protože je nutné ji použít v dalším kroku.
```
Id
--    
/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql
```
Poznámka:

V tomto příkladu Id by hodnota byla /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql. Tento příklad používá fiktivní data a váš identifikátor by se od tohoto příkladu odlišil.

Slouží New-AzCosmosDBSqlRoleAssignment k přiřazení nové role. K parametru RoleDefinitionId použijte dříve zaznamenané identifikátory definic rolí a jedinečný identifikátor vaší identity pro PrincipalId parametr. Nakonec pro parametr použijte identifikátor Scope vašeho účtu.

$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

Návod

Pokud se pokoušíte udělit řízení přístupu na základě role pro datovou rovinu své vlastní identitě, můžete k získání identity použít tento příkaz:

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

Další informace najdete v tématu Get-AzADUser.

Vypíše všechna přiřazení rolí pro váš účet Azure Cosmos DB for NoSQL pomocí Get-AzCosmosDBSqlRoleAssignment. Zkontrolujte výstup a ujistěte se, že vaše přiřazení role bylo vytvořeno.
```
$parameters = @{
    ResourceGroupName = "<name-of-existing-resource-group>"
    AccountName = "<name-of-existing-nosql-account>"
}
Get-AzCosmosDBSqlRoleAssignment @parameters
```

Výstraha

Řízení přístupu na základě role v datové rovině není v Azure Portal podporováno.

Ověření přístupu na základě rolí v datové rovině v kódu

Ověřte, že jste správně udělili přístup pomocí kódu aplikace a sady 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();
}

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-09-11

Sdílet prostřednictvím

Připojení ke službě Azure Cosmos DB for NoSQL pomocí řízení přístupu na základě role a ID Microsoft Entra

Požadavky

Zakázání ověřování na základě klíčů

Ověřte, že je zakázané ověřování na základě klíčů.

Udělení přístupu na základě role řídicí roviny

Ověření přístupu na základě role v rámci řídicí roviny v kódu.

Udělení přístupu k datové vrstvě na základě rolí.

Ověření přístupu na základě rolí v datové rovině v kódu

Související obsah

Váš názor

Další materiály