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

Platí pro: ✅ Table

Ří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 služby Azure Cosmos DB for Table.
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ý, zkuste se pomocí sady Azure SDK připojit ke službě Azure Cosmos DB for Table 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 Azure.Data.Tables;
using Azure.Core;

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

TableServiceClient client = new(connectionString);

const { TableServiceClient } = require('@azure/data-tables');

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

const client = new TableServiceClient(connectionString);

import { TableServiceClient } from '@azure/data-tables';

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

const client: TableServiceClient = new TableServiceClient(connectionString);

from azure.data.tables import TableServiceClient

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

client = TableServiceClient(endpoint, connection_string)

package main

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

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

func main() {
  client, _ := aztables.NewServiceClientFromConnectionString(connectionString, nil)
}

import com.azure.data.tables.TableServiceClient;
import com.azure.data.tables.TableServiceClientBuilder;

public class Table{
    public static void main(String[] args){
        TableServiceClient tableServiceClient = new TableServiceClientBuilder()
            .connectionString("AccountEndpoint=<table-endpoint>;AccountKey=<key>;")
            .buildClient();
    }
}

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 pro 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í tabulkových dotazů
Č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 Table. V této příručce připravíte integrovanou a 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 Table.

Nejprve pomocí az cosmsodb show získejte identifikátor prostředku existujícího účtu služby Azure Cosmos DB pro tabulku a uložte ho do proměnné.

resourceId=$( \
    az cosmosdb show \
        --resource-group "<name-of-existing-resource-group>" \
        --name "<name-of-existing-table-account>" \
        --query "id" \
        --output tsv \
)

az rest \
    --method "GET" \
    --url $resourceId/tableRoleDefinitions?api-version=2023-04-15

Pak vypíšete seznam všech definic rolí přidružených k vašemu účtu tabulky Azure Cosmos DB pomocí az rest. Nakonec si prohlédněte výstup a vyhledejte definici role s názvem Vestavěný 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.

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

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-table/tableRoleDefinitions/00000000-0000-0000-0000-000000000002. Tento příklad používá fiktivní data a váš identifikátor by se od tohoto příkladu odlišil. Tento příklad výstupu je zkrácený.

Vytvořte nový soubor JSON s názvem role-definition.json. 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.

{
  "properties": {
    "roleName": "Azure Cosmos DB for Table Data Plane Owner",
    "type": "CustomRole",
    "assignableScopes": [
      "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/sidandrews-rbac/providers/Microsoft.DocumentDB/databaseAccounts/sidandrews-rbac-table/"
    ],
    "permissions": [
      {
        "dataActions": [
          "Microsoft.DocumentDB/databaseAccounts/readMetadata",
          "Microsoft.DocumentDB/databaseAccounts/tables/*",
          "Microsoft.DocumentDB/databaseAccounts/tables/containers/entities/*"
        ]
      }
    ]
  }
}

Teď vytvořte nebo aktualizujte definici role pomocí az cosmosdb show a az rest společně za účelem vydání požadavku HTTP PUT . V rámci tohoto požadavku zadejte jedinečný identifikátor GUID pro definici vaší role.
```
resourceId=$( \
    az cosmosdb show \
        --resource-group "<name-of-existing-resource-group>" \
        --name "<name-of-existing-table-account>" \
        --query "id" \
        --output tsv \
)

az rest \
    --method "PUT" \
    --url $resourceId/tableRoleDefinitions/d3d3d3d3-eeee-ffff-aaaa-b4b4b4b4b4b4?api-version=2023-04-15 \
    --body @role-definition.json
```
Poznámka:

V tomto příkladu byl zadaný jedinečný identifikátor GUID d3d3d3d3-eeee-ffff-aaaa-b4b4b4b4b4b4. Pro definici vlastní role můžete zadat libovolný jedinečný identifikátor GUID.
Výstup by nyní měl indikovat, že je požadavek zařazen do fronty. Teď počkejte, než se dokončí nasazení definice role ve frontě. Tento úkol může trvat několik minut.
```
{
  "status": "Enqueued"
}
```

Nakonec znovu zkontrolujte seznam definic rolí.az rest

resourceId=$( \
    az cosmosdb show \
        --resource-group "<name-of-existing-resource-group>" \
        --name "<name-of-existing-table-account>" \
        --query "id" \
        --output tsv \
)

az rest \
    --method "GET" \
    --url $resourceId/tableRoleDefinitions?api-version=2023-04-15

Slouží az cosmosdb show k získání jedinečného identifikátoru pro váš aktuální účet.

az cosmosdb show \
    --resource-group "<name-of-existing-resource-group>" \
    --name "<name-of-existing-resource-group>" \
    --query "{id: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-table"
}
```
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-table. Tento příklad používá fiktivní data a váš identifikátor by se od tohoto příkladu odlišil.
Vytvořte nový soubor JSON s názvem role-assignment.json. Do souboru JSON přidejte jedinečný identifikátor vaší identity a jedinečný identifikátor prostředku účtu.
```
{
  "properties": {
    "roleDefinitionId": "<account-resource-id>/tableRoleDefinitions/d3d3d3d3-eeee-ffff-aaaa-b4b4b4b4b4b4",
    "scope": "<account-resource-id>",
    "principalId": "<id-of-existing-identity>"
  }
}
```
Poznámka:

V tomto příkladu byl zadaný jedinečný identifikátor GUID d3d3d3d3-eeee-ffff-aaaa-b4b4b4b4b4b4. Jedinečný identifikátor GUID, který jste použili dříve pro vlastní definici role, můžete použít.
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 určit rozsah přiřazení řízení přístupu na bázi datové roviny k celému účtu pomocí nejširšího rozsahu. 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 k datové rovině ke konkrétní databázi a kontejneru pomocí příkazu Azure CLI.
```
/dbs/<database-name>/colls/<container-name>
```
Pomocí relativního oboru můžete také udělit univerzální přístup ke všem databázím a kontejnerům:
```
/
```
Teď vytvořte nebo aktualizujte přiřazení role pomocí az cosmosdb show a az rest společně za účelem vydání požadavku HTTP PUT . V rámci tohoto požadavku zadejte jedinečný identifikátor GUID pro přiřazení role.
```
resourceId=$( \
    az cosmosdb show \
        --resource-group "<name-of-existing-resource-group>" \
        --name "<name-of-existing-table-account>" \
        --query "id" \
        --output tsv \
)

az rest \
    --method "PUT" \
    --url $resourceId/tableRoleAssignments/e4e4e4e4-ffff-aaaa-bbbb-c5c5c5c5c5c5?api-version=2023-04-15 \
    --body @role-assignment.json
```
Poznámka:

V tomto příkladu byl zadaný jedinečný identifikátor GUID e4e4e4e4-ffff-aaaa-bbbb-c5c5c5c5c5c5. Můžete zadat libovolný jedinečný identifikátor GUID pro vlastní přiřazení role.

Nejprve pomocí az cosmsodb show získejte identifikátor prostředku existujícího účtu služby Azure Cosmos DB pro tabulku a uložte ho do proměnné.

resourceId=$( \
    az cosmosdb show \
        --resource-group "<name-of-existing-resource-group>" \
        --name "<name-of-existing-table-account>" \
        --query "id" \
        --output tsv \
)

az rest \
    --method "GET" \
    --url $resourceId/tableRoleDefinitions?api-version=2023-04-15

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

Poznámka:

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`
*`Microsoft.DocumentDB/databaseAccounts/tables/`**
*`Microsoft.DocumentDB/databaseAccounts/tables/containers/entities/`**

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

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

@description('Name of the role definition.')
param roleDefinitionName string = 'API for Table Data Plane Owner'

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

resource definition 'Microsoft.DocumentDB/databaseAccounts/tableRoleDefinitions@2023-04-15' = {
  name: guid('table-role-definition', account.id)
  parent: account
  properties: {
    roleName: roleDefinitionName
    type: 'CustomRole'
    assignableScopes: [
      account.id
    ]
    permissions: [
      {
        dataActions: [
          'Microsoft.DocumentDB/databaseAccounts/readMetadata'
          'Microsoft.DocumentDB/databaseAccounts/tables/*'
          'Microsoft.DocumentDB/databaseAccounts/tables/containers/entities/*'
        ]
      }
    ]
  }
}

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 určit rozsah přiřazení řízení přístupu na bázi datové roviny k celému účtu pomocí nejširšího rozsahu. 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 k datové rovině ke konkrétní databázi a kontejneru pomocí příkazu Azure CLI.

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

Pomocí relativního oboru můžete také udělit 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 parametru název existujícího účtu accountName služby Azure Cosmos DB for Table.
```
using './data-plane-role-definition.bicep'

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

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

az deployment group create \
    --resource-group "<name-of-existing-resource-group>" \
    --parameters data-plane-role-definition.bicepparam \
    --template-file data-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.DocumentDB/databaseAccounts/msdocs-identity-example-table-account/tableRoleDefinitions/dddddddd-9999-0000-1111-eeeeeeeeeeee"
      }
    }
  }
}
```
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-table-account/tableRoleDefinitions/dddddddd-9999-0000-1111-eeeeeeeeeeee. 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 další soubor Bicep pro přiřazení role k identitě. Pojmenujte tento soubor data-plane-role-assignment.bicep.

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

@description('Name of the Azure Cosmos DB for Table 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

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

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

output id 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 vašeho existujícího účtu Azure Cosmos DB for Table, k parametru roleDefinitionId přiřaďte dříve zaznamenané identifikátory definic rolí a k parametru identityId přiřaďte jedinečný identifikátor vaší identity.
```
using './data-plane-role-assignment.bicep'

param accountName = '<name-of-existing-table-account>'
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 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 a povolili aplikacím přístup k datům pomocí spravované identity.

Slouží Get-AzCosmosDBAccount k získání identifikátoru prostředku existujícího účtu služby Azure Cosmos DB for Table a jeho uložení do proměnné.

$parameters = @{
    ResourceGroupName = "<name-of-existing-resource-group>"
    Name = "<name-of-existing-table-account>"
}
$resourceId = (
    Get-AzCosmosDBAccount @parameters |
        Select-Object -Property Id -First 1
).Id

$parameters = @{
  Path = "$resourceId/tableRoleDefinitions?api-version=2023-04-15"
  Method = "GET"
}
Invoke-AzRestMethod @parameters

Pak použijte Invoke-AzRestMethod k výpisu všech definic rolí přidružených k vašemu účtu tabulky Azure Cosmos DB. 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.

StatusCode : 200
Content    : {
    "value": [
      ...,
      {
        "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-table/tableRoleDefinitions/00000000-0000-0000-0000-000000000002",
        "name": "00000000-0000-0000-0000-000000000002",
        "properties": {
          "assignableScopes": [
            "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-table"
          ],
          "permissions": [
            {
              "dataActions": [
                "Microsoft.DocumentDB/databaseAccounts/readMetadata",
                "Microsoft.DocumentDB/databaseAccounts/tables/*",
                "Microsoft.DocumentDB/databaseAccounts/tables/containers/entities/*"
              ],
              "notDataActions": []
            }
          ],
          "roleName": "Cosmos DB Built-in Data Contributor",
          "type": "BuiltInRole"
        },
        "type": "Microsoft.DocumentDB/databaseAccounts/tableRoleDefinitions"
      }
      ...
      ]
    },
    ...
  ]
}

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-table/tableRoleDefinitions/00000000-0000-0000-0000-000000000002. Tento příklad používá fiktivní data a váš identifikátor by se od tohoto příkladu odlišil. Tento příklad výstupu je zkrácený.

Vytvořte nebo aktualizujte definici role pomocí Get-AzCosmosDBAccount a Invoke-AzRestMethod společně za účelem vydání požadavku HTTP PUT . V rámci tohoto požadavku také zadejte jedinečný identifikátor GUID pro definici vaší role. Nakonec vytvořte část definice prostředku, která určuje akce dat 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>"
    Name = "<name-of-existing-table-account>"
}
$resourceId = (
    Get-AzCosmosDBAccount @parameters |
        Select-Object -Property Id -First 1
).Id

$payload = @{
  properties = @{
    roleName = "Azure Cosmos DB for Table Data Plane Owner"
    type = "CustomRole"
    assignableScopes = @(
      "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/sidandrews-rbac/providers/Microsoft.DocumentDB/databaseAccounts/sidandrews-rbac-table/"
    )
    permissions = @(
      @{
        dataActions = @(
          "Microsoft.DocumentDB/databaseAccounts/readMetadata",
          "Microsoft.DocumentDB/databaseAccounts/tables/*",
          "Microsoft.DocumentDB/databaseAccounts/tables/containers/entities/*"
        )
      }
    )
  }
}

$parameters = @{
  Path = "$resourceId/tableRoleDefinitions/d3d3d3d3-eeee-ffff-aaaa-b4b4b4b4b4b4?api-version=2023-04-15"
  Method = "PUT"
  Payload = $payload | ConvertTo-Json -Depth 4
}
Invoke-AzRestMethod @parameters

Poznámka:

V tomto příkladu byl zadaný jedinečný identifikátor GUID d3d3d3d3-eeee-ffff-aaaa-b4b4b4b4b4b4. Pro definici vlastní role můžete zadat libovolný jedinečný identifikátor GUID.

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 oboru můžete také udělit univerzální přístup ke všem databázím a kontejnerům:

Výstup by se měl vrátit se stavovým kódem 200. Teď počkejte, než se dokončí nasazení definice role ve frontě. Tento úkol může trvat několik minut.
```
StatusCode : 200
...
```

Nakonec znovu zkontrolujte seznam definic rolí.Invoke-AzRestMethod

$parameters = @{
    ResourceGroupName = "<name-of-existing-resource-group>"
    Name = "<name-of-existing-table-account>"
}
$resourceId = (
    Get-AzCosmosDBAccount @parameters |
        Select-Object -Property Id -First 1
).Id

$parameters = @{
  Path = "$resourceId/tableRoleDefinitions?api-version=2023-04-15"
  Method = "GET"
}
Invoke-AzRestMethod @parameters

K získání jedinečného identifikátoru aktuálního účtu použijteGet-AzCosmosDBAccount.

$parameters = @{
    ResourceGroupName = "<name-of-existing-resource-group>"
    Name = "<name-of-existing-table-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-table
```
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-table. Tento příklad používá fiktivní data a váš identifikátor by se od tohoto příkladu odlišil.

Teď vytvořte nebo aktualizujte přiřazení role pomocí Get-AzCosmosDBAccount a Invoke-AzRestMethod společně za účelem vydání požadavku HTTP PUT . V rámci tohoto požadavku zadejte jedinečný identifikátor GUID pro přiřazení role. Nakonec vytvořte datovou část přiřazení zdroje, která určuje jedinečný identifikátor vaší identity.

$parameters = @{
    ResourceGroupName = "<name-of-existing-resource-group>"
    Name = "<name-of-existing-table-account>"
}
$resourceId = (
    Get-AzCosmosDBAccount @parameters |
        Select-Object -Property Id -First 1
).Id    

$payload = @{
  properties = @{
    roleDefinitionId = "$resourceId/tableRoleDefinitions/00000000-0000-0000-0000-000000000002"
    scope = "$resourceId"
    principalId = "<id-of-existing-identity>"
  }
}

$parameters = @{
  Path = "$resourceId/tableRoleAssignments/e4e4e4e4-ffff-aaaa-bbbb-c5c5c5c5c5c5?api-version=2023-04-15"
  Method = "PUT"
  Payload = $payload | ConvertTo-Json -Depth 2
}
Invoke-AzRestMethod @parameters

Poznámka:

V tomto příkladu byl zadaný jedinečný identifikátor GUID e4e4e4e4-ffff-aaaa-bbbb-c5c5c5c5c5c5. Můžete zadat libovolný jedinečný identifikátor GUID pro vlastní přiřazení role.

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.Identity;
using Azure.Data.Tables;

string endpoint = "<account-endpoint>";

DefaultAzureCredential credential = new();

TableServiceClient client = new(
    endpoint: new Uri(endpoint),
    tokenCredential: credential
);

TableClient table = client.GetTableClient(
    tableName: "<name-of-table>"
);

await table.GetEntityAsync<TableEntity>(
    partitionKey: "<partition-key>",
    rowKey: "<row-key>"
);

const { TableServiceClient, TableClient } = require('@azure/data-tables');
const { DefaultAzureCredential } = require('@azure/identity');

const endpoint = '<account-endpoint>';

let credential = new DefaultAzureCredential();

let client = new TableServiceClient(endpoint, credential);

let table = new TableClient(endpoint, "<table-name>", credential);

await table.getEntity("<partition-key>", "<row-key>");

import { TableServiceClient, TableClient } from '@azure/data-tables';
import { TokenCredential, DefaultAzureCredential } from '@azure/identity';

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

let credential: TokenCredential = new DefaultAzureCredential();

let client: TableServiceClient = new TableServiceClient(endpoint, credential);

let table: TableClient = new TableClient(endpoint, "<table-name>", credential);

await table.getEntity("<partition-key>", "<row-key>");

from azure.data.tables import TableServiceClient
from azure.identity import DefaultAzureCredential

endpoint = "<account-endpoint>"

credential = DefaultAzureCredential()

client = TableServiceClient(endpoint, credential=credential)

table = client.get_table_client("<table-name>")

table.get_entity(
    row_key="<row-key>",
    partition_key="<partition-key>"
)

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

const endpoint = "<account-endpoint>"

func main() {
    credential, _ := azidentity.NewDefaultAzureCredential(nil)
    client, _ := aztables.NewServiceClient(endpoint, credential, nil)
    table := client.NewClient("<table-name>")
    
    _, err := table.GetEntity(context.TODO(), "<partition-key>", "<row-key>", nil)
    if err != nil {
        panic(err)
    }
}

import com.azure.data.tables.TableClient;
import com.azure.data.tables.TableServiceClient;
import com.azure.data.tables.TableServiceClientBuilder;
import com.azure.identity.DefaultAzureCredential;
import com.azure.identity.DefaultAzureCredentialBuilder;

public class Table{
    public static void main(String[] args){
        DefaultAzureCredential credential = new DefaultAzureCredentialBuilder()
            .build();
        
        TableServiceClient client = new TableServiceClientBuilder()
            .endpoint("<table-endpoint>")
            .credential(credential)
            .buildClient();

        TableClient table = client
            .getTableClient("<table-name>");

        table.getEntity("<partition-key>", "<row-key>");
    }
}

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