Nawiązywanie połączenia z usługą Azure Cosmos DB for NoSQL przy użyciu kontroli dostępu opartej na rolach i identyfikatora Entra firmy Microsoft

Dotyczy: ✅ NoSQL

Kontrola dostępu oparta na rolach odnosi się do metody zarządzania dostępem do zasobów na platformie Azure. Ta metoda opiera się na przypisaniu określonym tożsamościom ról, które zarządzają poziomem dostępu do jednego lub więcej zasobów. Kontrola dostępu oparta na rolach zapewnia elastyczny system precyzyjnego zarządzania dostępem, który zapewnia tożsamościom tylko najmniej uprzywilejowany poziom dostępu, którego potrzebują do wykonania zadania.

Aby uzyskać więcej informacji, zobacz Kontrola dostępu oparta na rolach.

Wymagania wstępne

Konto Azure z aktywną subskrypcją. Utwórz konto bezpłatnie.
Istniejące konto usługi Azure Cosmos DB for NoSQL.
Co najmniej jedna istniejąca tożsamość w identyfikatorze Entra firmy Microsoft.

Użyj środowiska Bash w Azure Cloud Shell. Aby uzyskać więcej informacji, zobacz Get started with Azure Cloud Shell.
Jeśli wolisz uruchamiać polecenia referencyjne interfejsu wiersza polecenia lokalnie, zainstaluj Azure CLI. Jeśli korzystasz z systemu Windows lub macOS, rozważ uruchomienie Azure CLI w kontenerze Docker. Aby uzyskać więcej informacji, zobacz Jak uruchomić Azure CLI w kontenerze Docker.
- Jeśli korzystasz z instalacji lokalnej, zaloguj się do Azure CLI za pomocą polecenia az login. Aby zakończyć proces uwierzytelniania, wykonaj kroki wyświetlane na Twoim terminalu. Aby uzyskać inne opcje logowania, zobacz Uwierzytelnianie na platformie Azure przy użyciu interfejsu wiersza polecenia platformy Azure.
- Gdy zostaniesz o to poproszony/a, zainstaluj rozszerzenie Azure CLI przy pierwszym użyciu. Aby uzyskać więcej informacji na temat rozszerzeń, zobacz Używanie rozszerzeń i zarządzanie nimi za pomocą interfejsu wiersza polecenia platformy Azure.
- Uruchom az version, aby sprawdzić zainstalowaną wersję i biblioteki zależne. Aby zaktualizować do najnowszej wersji, uruchom az upgrade.

Jeśli zdecydujesz się używać programu Azure PowerShell lokalnie:
- Zainstaluj najnowszą wersję modułu Az programu PowerShell.
- Połącz się z kontem platformy Azure przy użyciu polecenia cmdlet Connect-AzAccount .
Jeśli zdecydujesz się używać usługi Azure Cloud Shell:
- Aby uzyskać więcej informacji, zobacz Omówienie usługi Azure Cloud Shell .

Wyłączanie uwierzytelniania opartego na kluczach

Wyłączenie autoryzacji opartej na kluczach uniemożliwia korzystanie z konta bez bezpieczniejszej metody uwierzytelniania identyfikatora Entra firmy Microsoft. Ta procedura jest krokiem, który powinien być wykonany na nowych kontach w bezpiecznych środowiskach pracy. Alternatywnie wykonaj tę procedurę na istniejących kontach migrowanych do bezpiecznego wzorca obciążenia.

Najpierw wyłącz uwierzytelnianie oparte na kluczach na istniejącym koncie, aby aplikacje musiały korzystać z uwierzytelniania identyfikatora Entra firmy Microsoft. Użyj az resource update do zmodyfikowania istniejącego properties.disableLocalAuth konta.

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

Najpierw utwórz nowe konto z wyłączonym uwierzytelnianiem opartym na kluczach, aby aplikacje musiały korzystać z uwierzytelniania firmy Microsoft Entra.

Utwórz nowy plik Bicep, aby wdrożyć nowe konto z wyłączonym uwierzytelnianiem opartym na kluczach. Nadaj plikowi nazwę 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
  }
}

Użyj az deployment group create polecenia, aby wdrożyć plik Bicep z użyciem nowego konta.

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

Najpierw wyłącz uwierzytelnianie oparte na kluczach na istniejącym koncie, aby aplikacje musiały korzystać z uwierzytelniania firmy Microsoft Entra. Użyj Get-AzResource i Set-AzResource , aby odpowiednio odczytać i zaktualizować istniejące konto.

$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

Wykonaj następujące kroki, aby utworzyć nowe konto usługi Azure Cosmos DB for NoSQL z wyłączonym uwierzytelnianiem na podstawie kluczy, aby aplikacje korzystały wyłącznie z uwierzytelniania Microsoft Entra.

Podczas konfigurowania nowego konta usługi Azure Cosmos DB for NoSQL przejdź do sekcji Zabezpieczenia procesu tworzenia konta.
Następnie wybierz pozycję Wyłącz dla opcji uwierzytelnianie oparte na kluczach .

Ważne

Modyfikacja konta usługi Azure Cosmos DB wymaga roli w ramach platformy Azure z co najmniej uprawnieniem Microsoft.DocumentDb/databaseAccounts/*/write. Aby uzyskać więcej informacji, zobacz uprawnienia dla usługi Azure Cosmos DB.

Sprawdzanie, czy uwierzytelnianie oparte na kluczach jest wyłączone

Aby sprawdzić, czy dostęp oparty na kluczach jest wyłączony, spróbuj użyć zestawu Azure SDK do nawiązania połączenia z usługą Azure Cosmos DB for NoSQL przy użyciu poświadczeń hasła właściciela zasobu (ROPC). Ta próba powinna zakończyć się niepowodzeniem. W razie potrzeby podano tutaj przykłady kodu dla typowych języków programowania.

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

Udzielanie dostępu do płaszczyzny sterowania na podstawie ról

Dostęp do płaszczyzny sterowania odnosi się do możliwości zarządzania zasobami dla usługi platformy Azure bez zarządzania danymi. Na przykład dostęp do płaszczyzny sterowania usługi Azure Cosmos DB może obejmować następujące możliwości:

Odczytywanie wszystkich metadanych konta i zasobów
Odczytywanie i ponowne generowanie kluczy konta i parametrów połączenia
Wykonywanie kopii zapasowych i przywracanie konta
Uruchamianie i śledzenie zadań transferu danych
Zarządzanie bazami danych i kontenerami
Modyfikowanie właściwości konta

Ważne

W usłudze Azure Cosmos DB potrzebny jest dostęp do płaszczyzny sterowania, aby zarządzać natywnymi definicjami i przypisaniami kontroli dostępu opartej na rolach na płaszczyźnie danych. Ponieważ mechanizm kontroli dostępu opartej na rolach płaszczyzny danych usługi Azure Cosmos DB jest natywny, potrzebny jest dostęp do płaszczyzny sterowania w celu tworzenia definicji i przypisań oraz przechowywania ich jako zasobów na koncie usługi Azure Cosmos DB.

Najpierw należy przygotować definicję roli z listą actions , aby udzielić dostępu do zarządzania zasobami konta w usłudze Azure Cosmos DB. W tym przewodniku przygotujesz wbudowaną i niestandardową rolę. Następnie przypisz nowo zdefiniowaną rolę do tożsamości, aby aplikacje mogły uzyskiwać dostęp do zasobów w usłudze Azure Cosmos DB.

Wyświetl listę wszystkich definicji ról skojarzonych z kontem usługi Azure Cosmos DB przy użyciu polecenia az role definition list.
```
az role definition list \
    --name "Cosmos DB Operator"
```

Przejrzyj dane wyjściowe i znajdź definicję roli o nazwie Operator usługi Cosmos DB. Dane wyjściowe zawierają unikatowy identyfikator definicji roli w właściwości id. Zapisz tę wartość, ponieważ jest ona wymagana do użycia w kroku przypisania w dalszej części tego przewodnika.

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

Uwaga / Notatka

W tym przykładzie wartość id wynosi /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/providers/Microsoft.Authorization/roleDefinitions/230815da-be43-4aae-9cb4-875f7bd000aa. W tym przykładzie użyto fikcyjnych danych, a identyfikator będzie inny niż w tym przykładzie. Jednak identyfikator (230815da-be43-4aae-9cb4-875f7bd000aa) jest globalnie unikatowy we wszystkich definicjach ról na platformie Azure.

Użyj az group show, aby pobrać metadane dla bieżącej grupy zasobów.
```
az group show \
    --name "<name-of-existing-resource-group>"
```
Zwróć uwagę na dane wyjściowe poprzedniego polecenia. Zapisz wartość id właściwości dla tej grupy zasobów, ponieważ jest ona wymagana do użycia w następnym kroku.
```
{
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example",
  "location": "westus",
  "name": "msdocs-identity-example",
  "type": "Microsoft.Resources/resourceGroups"
}
```
Uwaga / Notatka

W tym przykładzie wartość id wynosi /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example. W tym przykładzie użyto fikcyjnych danych, a identyfikator będzie inny niż w tym przykładzie. Ten ciąg jest skróconym przykładem wyniku.
Utwórz nowy plik JSON o nazwie role-definition.json. W pliku utwórz tę definicję zasobu, określając wartości wymienione tutaj. AssignableScopes Na liście dodaj id właściwość grupy zasobów zarejestrowanej w poprzednim 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"
  ]
}
```
Uwaga / Notatka

W tym przykładzie /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example użyto wartości zarejestrowanej w poprzednim kroku. Rzeczywisty identyfikator zasobu może być inny.
Utwórz nową definicję roli przy użyciu polecenia az role definition create. Użyj pliku role-definition.json jako danych wejściowych argumentu --role-definition .
```
az role definition create \
    --role-definition role-definition.json
```
Przejrzyj dane wyjściowe z polecenia tworzenia definicji. Dane wyjściowe zawierają unikatowy identyfikator definicji roli w właściwości id. Zapisz tę wartość, ponieważ jest ona wymagana do użycia w kroku przypisania w dalszej części tego przewodnika.
```
{
  "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"
}
```
Uwaga / Notatka

W tym przykładzie wartość id wynosi /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleDefinitions/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1. W tym przykładzie użyto fikcyjnych danych, a identyfikator będzie inny niż w tym przykładzie. W tym przykładzie przedstawiono podzbiór typowych danych wyjściowych JSON z wdrożenia w celu zapewnienia przejrzystości.
Użyj polecenia az group show , aby ponownie pobrać metadane dla bieżącej grupy zasobów.
```
az group show \
    --name "<name-of-existing-resource-group>"
```
Zwróć uwagę na dane wyjściowe poprzedniego polecenia. Zapisz wartość id właściwości dla tej grupy zasobów, ponieważ jest ona wymagana do użycia w następnym kroku.
```
{
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example",
  "location": "westus",
  "name": "msdocs-identity-example",
  "type": "Microsoft.Resources/resourceGroups"
}
```
Uwaga / Notatka

W tym przykładzie wartość id wynosi /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example. W tym przykładzie użyto fikcyjnych danych, a identyfikator będzie inny niż w tym przykładzie. Ten ciąg jest skróconym przykładem wyniku.
Przypisz nową rolę przy użyciu polecenia az role assignment create. Użyj identyfikatora grupy zasobów dla argumentu --scope , identyfikatora roli dla -role argumentu i unikatowego identyfikatora tożsamości do argumentu --assignee .
```
az role assignment create \
    --assignee "<your-principal-identifier>" \
    --role "subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleDefinitions/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1" \
    --scope "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example"
```
Uwaga / Notatka

W tym przykładowym poleceniu scope został ustawiony na fikcyjny przykład z poprzedniego kroku, czyli /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example. Identyfikator grupy zasobów będzie inny niż w tym przykładzie. role został również ustawiony na fikcyjne /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleDefinitions/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1. Ponownie identyfikator roli będzie odrębny.

Zwróć uwagę na dane wyjściowe polecenia . Dane wyjściowe zawierają unikatowy identyfikator przypisania w właściwości 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"
}

Uwaga / Notatka

W tym przykładzie id właściwość to /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleAssignments/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1, która jest innym fikcyjnym przykładem.

Powtórz te kroki, aby przyznać dostęp do konta dla jakichkolwiek innych tożsamości, których chciałbyś użyć.

Wskazówka

Możesz powtórzyć te kroki dla dowolnej liczby tożsamości. Zazwyczaj te kroki są powtarzane co najmniej w celu umożliwienia deweloperom dostępu do konta przy użyciu tożsamości ludzkiej i umożliwienia aplikacjom dostępu do danych przy użyciu tożsamości zarządzanej.

Wyświetl listę wszystkich definicji ról skojarzonych z kontem usługi Azure Cosmos DB przy użyciu polecenia 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",
  }
]

Uwaga / Notatka

Utwórz nowy plik Bicep, aby zdefiniować definicję roli. Nadaj plikowi nazwę control-plane-role-definition.bicep. Dodaj te actions do definicji:

	Description
*`Microsoft.DocumentDb/`**	Włącza wszystkie możliwe akcje.

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

Wdróż szablon Bicep za pomocą az deployment group create. Określ nazwę szablonu Bicep i grupę zasobów platformy Azure.

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

Przejrzyj dane wyjściowe z wdrożenia. Dane wyjściowe zawierają unikatowy identyfikator definicji roli w właściwości properties.outputs.definitionId.value. Zapisz tę wartość, ponieważ jest ona wymagana do użycia w kroku przypisania w dalszej części tego przewodnika.
```
{
  "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"
      }
    }
  }
}
```
Uwaga / Notatka

W tym przykładzie wartość id wynosi /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleDefinitions/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1. W tym przykładzie użyto fikcyjnych danych, a identyfikator będzie inny niż w tym przykładzie. W tym przykładzie przedstawiono podzbiór typowych danych wyjściowych JSON z wdrożenia w celu zapewnienia przejrzystości.

Utwórz nowy plik Bicep, aby zdefiniować przypisanie roli. Nadaj plikowi nazwę 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
  }
}

Utwórz nowy plik parametrów Bicep o nazwie control-plane-role-assignment.bicepparam. W tym pliku parametrów; przypisz wcześniej zarejestrowane identyfikatory definicji roli do parametru roleDefinitionId i unikatowy identyfikator tożsamości do parametru identityId .
```
using './control-plane-role-assignment.bicep'

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

Wdróż ten szablon Bicep przy użyciu 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

Powtórz te kroki, aby przyznać dostęp do konta dla jakichkolwiek innych tożsamości, których chciałbyś użyć.

Wskazówka

Możesz powtórzyć te kroki dla dowolnej liczby tożsamości. Zazwyczaj te kroki są powtarzane co najmniej w celu umożliwienia deweloperom dostępu do konta przy użyciu tożsamości ludzkiej i umożliwienia aplikacjom dostępu do danych przy użyciu tożsamości zarządzanej.

Zaloguj się do witryny Azure Portal (https://portal.azure.com).
Wprowadź pozycję Grupa zasobów na pasku wyszukiwania globalnego.
W obszarze Usługi wybierz pozycję Grupy zasobów.
W okienku Grupy zasobów wybierz istniejącą grupę zasobów.

Uwaga / Notatka

Ten przykładowy zrzut ekranu zawiera grupę msdocs-identity-example zasobów. Rzeczywista nazwa grupy zasobów może być inna.
W okienku grupy zasobów wybierz pozycję Kontrola dostępu (Zarządzanie dostępem i tożsamościami) w menu usługi.
W okienku Kontrola dostępu (Zarządzanie dostępem i tożsamościami) wybierz pozycję Role.
W sekcji Role użyj frazy wyszukiwania Cosmos DB i znajdź definicję roli Operator usługi Cosmos DB . Następnie wybierz opcję Wyświetl skojarzone z tą definicją.
W oknie dialogowym Definicja roli operatora usługi Cosmos DB obserwuj akcje przypisane w ramach tej definicji roli.
Zamknij okno dialogowe Definicja roli operatora usługi Cosmos DB .
Ponownie w okienku Kontrola dostępu (IAM), wybierz Dodaj. Następnie wybierz pozycję Dodaj rolę niestandardową.

W okienku Podstawowe skonfiguruj następujące opcje, a następnie wybierz pozycję Dalej:

	Wartość
Nazwa roli niestandardowej	`Azure Cosmos DB Control Plane Owner`
Opis	`Can perform all control plane actions for an Azure Cosmos DB account.`
Podstawowe uprawnienia	Zacznij od podstaw

Zrzut ekranu przedstawiający okienko

W okienku Uprawnienia wybierz pozycję Dodaj uprawnienia. Następnie wyszukaj DocumentDB w oknie dialogowym uprawnień. Na koniec wybierz opcję Microsoft.DocumentDB .
W oknie dialogowym uprawnień wybierz wszystkie Akcje dla elementu Microsoft.DocumentDB. Następnie wybierz pozycję Dodaj , aby powrócić do okienka *Uprawnienia .
Wracając do panelu Uprawnienia, przejrzyj listę uprawnień. Następnie wybierz pozycję Przegląd + utwórz.
W okienku Przeglądanie i tworzenie przejrzyj określone opcje nowej definicji roli. Na koniec wybierz pozycję Utwórz.
Poczekaj, aż portal zakończy tworzenie definicji roli.
W okienku Kontrola dostępu (Zarządzanie dostępem i tożsamościami) wybierz pozycję Dodaj , a następnie dodaj przypisanie roli.
W okienku Rola wyszukaj Azure Cosmos DB , a następnie wybierz rolę Właściciel płaszczyzny sterowania usługi Azure Cosmos DB utworzoną wcześniej w tym przewodniku. Następnie wybierz Dalej.

Wskazówka

Opcjonalnie można filtrować listę ról, aby uwzględnić tylko role niestandardowe.
W okienku Członkowie wybierz opcję Wybierz członków . W oknie dialogowym Członkowie wybierz tożsamość, której chcesz przyznać ten poziom dostępu dla konta usługi Azure Cosmos DB, a następnie użyj opcji Wybierz, aby potwierdzić wybór.

Uwaga / Notatka

Ten zrzut ekranu przedstawia przykładowego użytkownika o nazwie "Kai Carter" z główną nazwą użytkownika kai@adventure-works.com.
Wróć do okienka Członkowie , przejrzyj wybranego członka[s], a następnie wybierz pozycję Przejrzyj i przypisz.
W okienku Przeglądanie i przypisywanie przejrzyj określone opcje nowego przypisania roli. Na koniec wybierz pozycję Przejrzyj i przypisz.
Poczekaj, aż portal zakończy tworzenie przypisania roli.

Użyj Get-AzRoleDefinition polecenia , aby wyświetlić listę wszystkich definicji ról skojarzonych z kontem usługi Azure Cosmos DB.
```
$parameters = @{
    Name = "Cosmos DB Operator"
}
Get-AzRoleDefinition @parameters
```

Przejrzyj dane wyjściowe i znajdź definicję roli o nazwie Współautor danych wbudowanych w usłudze Cosmos DB. Dane wyjściowe zawierają unikatowy identyfikator definicji roli w właściwości Id. Zapisz tę wartość, ponieważ jest ona wymagana do użycia w kroku przypisania w dalszej części tego przewodnika.

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

Uwaga / Notatka

W tym przykładzie wartość Id wynosi 230815da-be43-4aae-9cb4-875f7bd000aa. Identyfikator jest globalnie unikatowy we wszystkich definicjach ról na platformie Azure.

Użyj Get-AzResourceGroup, aby pobrać metadane dla bieżącej grupy zasobów.

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

Zwróć uwagę na dane wyjściowe poprzedniego polecenia. Zapisz wartość ResourceId właściwości dla tej grupy zasobów, ponieważ jest ona wymagana do użycia w następnym kroku.
```
ResourceGroupName : msdocs-identity-example
Location          : westus
ProvisioningState : Succeeded
ResourceId        : /subscriptions/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1/resourcegroups/msdocs-identity-example
```
Uwaga / Notatka

W tym przykładzie wartość ResourceId wynosi /subscriptions/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1/resourcegroups/msdocs-identity-example. W tym przykładzie użyto fikcyjnych danych, a identyfikator będzie inny niż w tym przykładzie. Ten ciąg jest skróconym przykładem typowego wyniku.
Najpierw zaimportuj Az.Resources moduł. Następnie utwórz nowy Microsoft.Azure.Commands.Resources.Models.Authorization.PSRoleDefinition obiekt. W obiekcie utwórz tę definicję zasobu, określając wartości wymienione tutaj. AssignableScopes Na liście dodaj ResourceId właściwość grupy zasobów zarejestrowanej w poprzednim kroku. Na koniec użyj obiektu definicji roli jako danych wejściowych dla parametru -Role w 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
```
Uwaga / Notatka

W tym przykładzie /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example użyto wartości zarejestrowanej w poprzednim kroku. Rzeczywisty identyfikator zasobu może być inny.
Przejrzyj dane wyjściowe z polecenia tworzenia definicji. Dane wyjściowe zawierają unikatowy identyfikator definicji roli w właściwości Name. Zapisz tę wartość, ponieważ jest ona wymagana do użycia w kroku przypisania w dalszej części tego przewodnika.
```
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}
```
Uwaga / Notatka

W tym przykładzie wartość Name wynosi Azure Cosmos DB Control Plane Owner. Ten przykład jest podzbiorem typowych danych wyjściowych wdrożenia w celu zapewnienia przejrzystości.

Przypisz nową rolę przy użyciu polecenia New-AzRoleAssignment. Użyj nazwy roli dla parametru RoleDefinitionName i unikatowego identyfikatora tożsamości do parametru ObjectId .

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

Zwróć uwagę na dane wyjściowe polecenia . Dane wyjściowe zawierają unikatowy identyfikator przypisania w właściwości 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

Uwaga / Notatka

W tym przykładzie RoleAssignmentId właściwość to /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.Authorization/roleAssignments/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1, która jest innym fikcyjnym przykładem. Ten przykład jest podzbiorem typowych danych wyjściowych wdrożenia w celu zapewnienia przejrzystości.

Powtórz te kroki, aby przyznać dostęp do konta dla jakichkolwiek innych tożsamości, których chciałbyś użyć.

Wskazówka

Możesz powtórzyć te kroki dla dowolnej liczby tożsamości. Zazwyczaj te kroki są powtarzane co najmniej w celu umożliwienia deweloperom dostępu do konta przy użyciu tożsamości ludzkiej i umożliwienia aplikacjom dostępu do danych przy użyciu tożsamości zarządzanej.

Ważne

Przypisanie definicji roli wymaga posiadania unikatowego identyfikatora dowolnej tożsamości, której chcesz przyznać uprawnienia do kontroli dostępu opartej na rolach.

Weryfikowanie dostępu opartego na rolach płaszczyzny sterowania w kodzie

Sprawdź, czy prawidłowo udzielono dostępu przy użyciu kodu aplikacji i zestawu 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);
    }
}

Udzielanie dostępu do płaszczyzny danych opartego na rolach

Dostęp do płaszczyzny danych odnosi się do możliwości odczytywania i zapisywania danych w usłudze platformy Azure bez możliwości zarządzania zasobami na koncie. Na przykład dostęp do płaszczyzny danych usługi Azure Cosmos DB może obejmować następujące możliwości:

Odczytywanie niektórych metadanych konta i zasobów
Tworzenie, odczytywanie, aktualizowanie, poprawianie i usuwanie elementów
Wykonywanie zapytań NoSQL
Odczytywanie z kanału zmian kontenera
Wykonaj procedury składowane
Zarządzanie konfliktami w strumieniu konfliktów

Najpierw należy przygotować definicję roli z listą dataActions , aby udzielić dostępu do odczytu, wykonywania zapytań i zarządzania danymi w usłudze Azure Cosmos DB for NoSQL. W tej instrukcji przygotujesz niestandardową rolę. Następnie przypisz nowo zdefiniowaną rolę do tożsamości, aby aplikacje mogły uzyskiwać dostęp do danych w usłudze Azure Cosmos DB for NoSQL.

Ważne

Uzyskanie istniejącej definicji roli płaszczyzny danych wymaga następujących uprawnień płaszczyzny sterowania:

Microsoft.DocumentDB/databaseAccounts/sqlRoleDefinitions/read

Utworzenie nowej definicji roli płaszczyzny danych wymaga następujących uprawnień płaszczyzny sterowania:

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

Utworzenie nowego przypisania roli płaszczyzny danych wymaga następujących uprawnień płaszczyzny sterowania:

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

Ostrzeżenie

Natywna kontrola dostępu oparta na rolach w Azure Cosmos DB for NoSQL nie obsługuje właściwości notDataActions. Każda akcja, która nie jest określona jako dozwolona dataAction , jest automatycznie wykluczana.

Wyświetl listę wszystkich definicji ról skojarzonych z kontem usługi Azure Cosmos DB for NoSQL przy użyciu polecenia 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>"
```

Utwórz nowy plik JSON o nazwie role-definition.json, który jest używany do tworzenia roli niestandardowej. W tym pliku utwórz definicję zasobu określającą akcje danych wymienione tutaj:

	Description
`Microsoft.DocumentDB/databaseAccounts/readMetadata`	Może odczytywać metadane na poziomie konta
*`Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/`**	Może wykonywać dowolne operacje na danych na poziomie kontenera
*`Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/`**	Może wykonywać dowolną operację na elementach z kontenerami

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

Następnie użyj polecenia az cosmosdb sql role definition create , aby utworzyć definicję roli. Użyj role-definition.json jako danych wejściowych argumentu --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"

Przejrzyj dane wyjściowe z poprzedniego polecenia. Znajdź właśnie utworzoną definicję roli o nazwie Azure Cosmos DB for NOSQL Data Plane Owner (Właściciel płaszczyzny danych NOSQL). Dane wyjściowe zawierają unikatowy identyfikator definicji roli w właściwości id. Zapisz tę wartość, ponieważ jest ona wymagana do użycia w kroku przypisania w dalszej części tego przewodnika --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"
}

Uwaga / Notatka

W tym przykładzie wartość --role-definition-id wynosi bbbbbbbb-1111-2222-3333-cccccccccccc. W tym przykładzie użyto fikcyjnych danych, a identyfikator będzie inny niż w tym przykładzie.

Użyj elementu id uzyskanego w poprzednim kroku i określ --scope , usuwając wszystko po nazwie konta.

Uwaga / Notatka

W tym przykładzie wartość --scope wynosi /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql. W tym przykładzie użyto fikcyjnych danych, a identyfikator będzie inny niż w tym przykładzie.
Przypisz nową rolę przy użyciu polecenia az cosmosdb sql role assignment create.
Użyj wcześniej zarejestrowanych identyfikatorów definicji roli do argumentu --role-definition-id ,
unikatowego identyfikatora tożsamości do --principal-id argumentu,
a na koniec użyj identyfikatora konta dla argumentu --scope .
```
az cosmosdb sql role assignment create \
    --resource-group "<name-of-existing-resource-group>" \
    --account-name "<name-of-existing-nosql-account>" \
    --role-definition-id "<id-of-new-role-definition>" \ 
    --principal-id "<id-of-existing-identity>" \
    --scope "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql"
```
Wskazówka

Jeśli próbujesz udzielić kontroli dostępu opartej na rolach płaszczyzny danych do własnej tożsamości, możesz użyć tego polecenia, aby uzyskać tożsamość:
```
az ad signed-in-user show
```
Aby uzyskać więcej informacji, zobacz az ad signed-in-user.
Wskazówka

W natywnej implementacji kontroli dostępu opartej na rolach w usłudze Azure Cosmos DB zakres odnosi się do stopnia szczegółowości zasobów w ramach konta, dla którego chcesz zastosować uprawnienia. Na najwyższym poziomie można przypisać kontrolę dostępu opartą na rolach w płaszczyźnie danych do całego konta, korzystając z najszerszego zakresu. Ten zakres obejmuje wszystkie bazy danych i kontenery w ramach konta:
```
/subscriptions/<subscription-id>/resourcegroups/<resource-group-name>/providers/Microsoft.DocumentDB/databaseAccounts/<account-name>/
```
Możesz też określić zakres przypisania roli płaszczyzny danych do określonej bazy danych:
```
/subscriptions/<subscription-id>/resourcegroups/<resource-group-name>/providers/Microsoft.DocumentDB/databaseAccounts/<account-name>/dbs/<database-name>
```
Na koniec możesz ograniczyć zakres przypisania do pojedynczego kontenera, który stanowi najbardziej szczegółowy zakres:
```
/subscriptions/<subscription-id>/resourcegroups/<resource-group-name>/providers/Microsoft.DocumentDB/databaseAccounts/<account-name>/dbs/<database-name>/colls/<container-name>
```
W wielu przypadkach można użyć zakresu względnego zamiast w pełni kwalifikowanego zakresu. Na przykład możesz użyć tego względnego zakresu, aby udzielić uprawnień kontroli dostępu oparte na rolach do określonej bazy danych i kontenera z polecenia Azure CLI.
```
/dbs/<database-name>/colls/<container-name>
```
Można również udzielić uniwersalnego dostępu do wszystkich baz danych i kontenerów przy użyciu zakresu względnego:
```
/
```
Użyj az cosmosdb sql role assignment list polecenia , aby wyświetlić listę wszystkich przypisań ról dla konta usługi Azure Cosmos DB for NoSQL. Przejrzyj dane wyjściowe, aby upewnić się, że przypisanie roli zostało utworzone.
```
az cosmosdb sql role assignment list \
    --resource-group "<name-of-existing-resource-group>" \
    --account-name "<name-of-existing-nosql-account>"
```

Wyświetl listę wszystkich definicji ról skojarzonych z kontem usługi Azure Cosmos DB for NoSQL przy użyciu polecenia 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>"
```

Przejrzyj dane wyjściowe i znajdź definicję roli o nazwie Współautor danych wbudowanych w usłudze Cosmos DB. Dane wyjściowe zawierają unikatowy identyfikator definicji roli w właściwości id. Zapisz tę wartość, ponieważ jest ona wymagana do użycia w kroku przypisania w dalszej części tego przewodnika.

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

Uwaga / Notatka

W tym przykładzie wartość id wynosi /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql/sqlRoleDefinitions/00000000-0000-0000-0000-000000000002. W tym przykładzie użyto fikcyjnych danych, a identyfikator będzie inny niż w tym przykładzie.

Utwórz nowy plik Bicep, aby zdefiniować definicję roli. Nadaj plikowi nazwę data-plane-role-definition.bicep. Dodaj te dataActions do definicji:

	Description
`Microsoft.DocumentDB/databaseAccounts/readMetadata`	Może odczytywać metadane na poziomie konta
*`Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/`**	Może wykonywać dowolne operacje na danych na poziomie kontenera
*`Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/`**	Może wykonywać dowolną operację na elementach z kontenerami

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

Wskazówka

W natywnej implementacji kontroli dostępu opartej na rolach w usłudze Azure Cosmos DB zakres odnosi się do stopnia szczegółowości zasobów w ramach konta, dla którego chcesz zastosować uprawnienia. Na najwyższym poziomie można przypisać kontrolę dostępu opartą na rolach w płaszczyźnie danych do całego konta, korzystając z najszerszego zakresu. Ten zakres obejmuje wszystkie bazy danych i kontenery w ramach konta:

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

Możesz też określić zakres przypisania roli płaszczyzny danych do określonej bazy danych:

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

Na koniec możesz ograniczyć zakres przypisania do pojedynczego kontenera, który stanowi najbardziej szczegółowy zakres:

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

W wielu przypadkach można użyć zakresu względnego zamiast w pełni kwalifikowanego zakresu. Na przykład możesz użyć tego względnego zakresu, aby udzielić uprawnień kontroli dostępu oparte na rolach do określonej bazy danych i kontenera z polecenia Azure CLI.

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

Można również udzielić uniwersalnego dostępu do wszystkich baz danych i kontenerów przy użyciu zakresu względnego:

Utwórz nowy plik parametrów Bicep o nazwie data-plane-role-definition.bicepparam. W tym pliku parametrów przypisz nazwę istniejącego konta usługi Azure Cosmos DB for NoSQL do parametru accountName .
```
using './data-plane-role-definition.bicep'

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

Wdróż szablon Bicep za 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

Utwórz nowy plik Bicep, aby zdefiniować przypisanie roli. Nadaj plikowi nazwę 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

Utwórz nowy plik parametrów Bicep o nazwie data-plane-role-assignment.bicepparam. W tym pliku parametrów przypisz nazwę istniejącego konta usługi Azure Cosmos DB for NoSQL do accountName parametru, wcześniej zarejestrowanych identyfikatorów definicji roli do parametru roleDefinitionId i unikatowy identyfikator tożsamości do parametru identityId .
```
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>'
```
Wskazówka

Jeśli próbujesz udzielić dostępu do zasobów danych na podstawie ról dla własnej tożsamości, możesz pominąć parametr identityId. Następnie szablon Bicep używa deployer().objectId do uzyskania tożsamości głównego podmiotu, który wdrożył szablon. Aby uzyskać więcej informacji, zobacz deployer.

Wdróż szablon Bicep za 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

Powtórz te kroki, aby przyznać dostęp do konta dla jakichkolwiek innych tożsamości, których chciałbyś użyć.

Wskazówka

Możesz powtórzyć te kroki dla dowolnej liczby tożsamości. Zazwyczaj te kroki są co najmniej powtarzane, aby umożliwić deweloperom dostęp do konta przy użyciu ich tożsamości ludzkiej. Możesz również powtórzyć te kroki, aby umożliwić aplikacjom dostęp do zasobów przy użyciu tożsamości zarządzanej.

Użyj Get-AzCosmosDBSqlRoleDefinition polecenia , aby wyświetlić listę wszystkich definicji ról skojarzonych z kontem usługi Azure Cosmos DB for NoSQL.

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

Przejrzyj dane wyjściowe i znajdź definicję roli o nazwie Współautor danych wbudowanych w usłudze Cosmos DB. Dane wyjściowe zawierają unikatowy identyfikator definicji roli w właściwości Id. Zapisz tę wartość, ponieważ jest ona wymagana do użycia w kroku przypisania w dalszej części tego przewodnika.
```
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 : 
```
Uwaga / Notatka

W tym przykładzie wartość Id wynosi /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql/sqlRoleDefinitions/00000000-0000-0000-0000-000000000002. W tym przykładzie użyto fikcyjnych danych, a identyfikator będzie inny niż w tym przykładzie. Jednak identyfikator (00000000-0000-0000-0000-000000000002) jest unikatowy we wszystkich definicjach ról na twoim koncie.

Utwórz nową definicję roli przy użyciu polecenia New-AzCosmosDBSqlRoleDefinition. Dla parametru DataAction określ akcje danych wymienione tutaj:

	Description
`Microsoft.DocumentDB/databaseAccounts/readMetadata`	Może odczytywać metadane na poziomie konta
*`Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/`**	Może wykonywać dowolne operacje na danych na poziomie kontenera
*`Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/`**	Może wykonywać dowolną operację na elementach z kontenerami

$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

Wskazówka

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

Możesz też określić zakres przypisania roli płaszczyzny danych do określonej bazy danych:

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

Na koniec możesz ograniczyć zakres przypisania do pojedynczego kontenera, który stanowi najbardziej szczegółowy zakres:

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

Można również udzielić uniwersalnego dostępu do wszystkich baz danych i kontenerów przy użyciu zakresu względnego:

Użyj Get-AzCosmosDBSqlRoleDefinition polecenia , aby wyświetlić listę wszystkich definicji ról skojarzonych z kontem usługi Azure Cosmos DB for NoSQL.

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

Przejrzyj dane wyjściowe z poprzedniego polecenia. Znajdź właśnie utworzoną definicję roli o nazwie Azure Cosmos DB for NOSQL Data Plane Owner (Właściciel płaszczyzny danych NOSQL). Dane wyjściowe zawierają unikatowy identyfikator definicji roli w właściwości Id. Zapisz tę wartość, ponieważ jest ona wymagana do użycia w kroku przypisania w dalszej części tego przewodnika.

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 :

Uwaga / Notatka

W tym przykładzie wartość Id wynosi /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql/sqlRoleDefinitions/bbbbbbbb-1111-2222-3333-cccccccccccc. W tym przykładzie użyto fikcyjnych danych, a identyfikator będzie inny niż w tym przykładzie.

Użyj Get-AzCosmosDBAccount, aby pobrać metadane dla bieżącego konta.

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

Zwróć uwagę na dane wyjściowe poprzedniego polecenia. Zapisz wartość Id właściwości dla tego konta, ponieważ jest ona wymagana do użycia w następnym kroku.
```
Id
--    
/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql
```
Uwaga / Notatka

W tym przykładzie wartość Id wynosi /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/msdocs-identity-example/providers/Microsoft.DocumentDB/databaseAccounts/msdocs-identity-example-nosql. W tym przykładzie użyto fikcyjnych danych, a identyfikator będzie inny niż w tym przykładzie.

Użyj polecenia New-AzCosmosDBSqlRoleAssignment , aby przypisać nową rolę. Użyj wcześniej zarejestrowanych identyfikatorów definicji roli do parametru RoleDefinitionId i unikatowego identyfikatora tożsamości do parametru PrincipalId . Na koniec użyj identyfikatora konta dla parametru Scope .

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

Wskazówka

Jeśli próbujesz udzielić kontroli dostępu opartej na rolach płaszczyzny danych do własnej tożsamości, możesz użyć tego polecenia, aby uzyskać tożsamość:

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

Aby uzyskać więcej informacji, zobacz Get-AzADUser.

Wyświetl listę wszystkich przypisań ról dla konta usługi Azure Cosmos DB for NoSQL przy użyciu polecenia Get-AzCosmosDBSqlRoleAssignment. Przejrzyj dane wyjściowe, aby upewnić się, że przypisanie roli zostało utworzone.
```
$parameters = @{
    ResourceGroupName = "<name-of-existing-resource-group>"
    AccountName = "<name-of-existing-nosql-account>"
}
Get-AzCosmosDBSqlRoleAssignment @parameters
```

Ostrzeżenie

Zarządzanie kontrolą dostępu opartą na rolach płaszczyzny danych nie jest obsługiwane w witrynie Azure Portal.

Weryfikowanie dostępu opartego na rolach płaszczyzny danych w kodzie

Sprawdź, czy prawidłowo udzielono dostępu przy użyciu kodu aplikacji i zestawu 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();
}

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-12-19

Udostępnij przez

Nawiązywanie połączenia z usługą Azure Cosmos DB for NoSQL przy użyciu kontroli dostępu opartej na rolach i identyfikatora Entra firmy Microsoft

Wymagania wstępne

Wyłączanie uwierzytelniania opartego na kluczach

Sprawdzanie, czy uwierzytelnianie oparte na kluczach jest wyłączone

Udzielanie dostępu do płaszczyzny sterowania na podstawie ról

Weryfikowanie dostępu opartego na rolach płaszczyzny sterowania w kodzie

Udzielanie dostępu do płaszczyzny danych opartego na rolach

Weryfikowanie dostępu opartego na rolach płaszczyzny danych w kodzie

Treści powiązane

Sprzężenie zwrotne

Dodatkowe źródła