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

Otwórz nowy terminal.

Zaloguj się do Azure CLI.

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

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 DocumentDB RBAC Owner",
  "IsCustom": true,
  "Description": "Can perform all Azure role-based access control actions for Azure DocumentDB clusters.",
  "Actions": [
    "Microsoft.DocumentDb/mongoClusters/*"
  ],
  "AssignableScopes": [
    "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example"
  ]
}

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 Azure role-based access control actions for Azure DocumentDB clusters.",
  "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 DocumentDB RBAC Owner",
  "roleType": "CustomRole"
}

Otwórz nowy terminal.

Zaloguj się do Azure CLI.

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

metadata description = 'Create RBAC definition for Azure role-based access control access to Azure DocumentDB.'

@description('Name of the role definition.')
param roleDefinitionName string = 'Azure DocumentDB RBAC Owner'

@description('Description of the role definition.')
param roleDefinitionDescription string = 'Can perform all Azure role-based access control actions for Azure DocumentDB clusters.'

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

Utwórz nowy plik Bicep, aby zdefiniować przypisanie roli. Nadaj plikowi nazwę control-plane-role-assignment.bicep.

metadata description = 'Assign RBAC role for Azure role-based access control access to Azure DocumentDB.'

@description('Id of the role definition to assign to the targeted principal in the context of the cluster.')
param roleDefinitionId string

@description('Id of the identity/principal to assign this role in the context of the cluster.')
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

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.

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ę Dodaj. Następnie wybierz pozycję Dodaj rolę niestandardową.

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

W okienku Uprawnienia wybierz pozycję Dodaj uprawnienia. Następnie wyszukaj DocumentDB w oknie dialogowym uprawnień. Na koniec wybierz opcję Microsoft.DocumentDB/mongoClusters .

W oknie dialogowym uprawnień wybierz wszystkie Akcje dla elementu Microsoft.DocumentDB/mongoClusters. 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 DocumentDB , a następnie wybierz rolę Właściciela RBAC usługi Azure DocumentDB utworzoną wcześniej w tym przewodniku. Następnie wybierz Dalej.

W okienku Członkowie wybierz opcję Wybierz członków . W oknie dialogowym członków wybierz tożsamość, której chcesz przyznać ten poziom dostępu dla klastrów usługi Azure DocumentDB, a następnie użyj opcji Wybierz, aby potwierdzić wybór.

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.

Otwórz nowy terminal.

Zaloguj się do Azure CLI.

Sprawdź docelową subskrypcję platformy Azure.

az account show

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

variable "role_definition_name" {
  type        = string
  description = "Name of the role definition."
  default     = "Azure DocumentDB RBAC Owner"
}

variable "role_definition_description" {
  type        = string
  description = "Description of the role definition."
  default     = "Can perform all Azure role-based access control actions for Azure DocumentDB clusters."
}

terraform {
  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~> 4.0"
    }
  }
}

provider "azurerm" {
  features {}
}

data "azurerm_client_config" "current" {}

data "azurerm_resource_group" "existing" {
  name = "<name-of-existing-resource-group>"
}

resource "azurerm_role_definition" "control_plane" {
  name               = var.role_definition_name
  scope              = data.azurerm_resource_group.existing.id
  description        = var.role_definition_description

  permissions {
    actions = [
      "Microsoft.DocumentDb/mongoClusters/*"
    ]
  }

  assignable_scopes = [
    data.azurerm_resource_group.existing.id
  ]
}

output "definition_id" {
  value = azurerm_role_definition.control_plane.id
}

Zainicjuj wdrożenie programu Terraform.

terraform init --upgrade

Utwórz plan wykonania dla definicji roli i zapisz go w pliku o nazwie role-definition.tfplan.

ARM_SUBSCRIPTION_ID=$(az account show --query id --output tsv) terraform plan --out "role-definition.tfplan"

Zastosuj plan wykonywania, aby wdrożyć definicję roli na platformie Azure.

ARM_SUBSCRIPTION_ID=$(az account show --query id --output tsv) terraform apply "role-definition.tfplan"

Przejrzyj dane wyjściowe z wdrożenia. Dane wyjściowe zawierają unikatowy identyfikator definicji roli w właściwości definition_id. Zapisz tę wartość, ponieważ jest ona wymagana do użycia w kroku przypisania w dalszej części tego przewodnika.

Utwórz nowy plik Terraform, aby zdefiniować przypisanie roli. Nadaj plikowi nazwę control-plane-role-assignment.tf.

variable "role_definition_id" {
  type        = string
  description = "Id of the role definition to assign to the targeted principal in the context of the cluster."
}

variable "identity_id" {
  type        = string
  description = "Id of the identity/principal to assign this role in the context of the cluster."
}

terraform {
  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~> 4.0"
    }
  }
}

provider "azurerm" {
  features {}
}

data "azurerm_resource_group" "existing" {
  name = "<name-of-existing-resource-group>"
}

resource "azurerm_role_assignment" "control_plane" {
  scope              = data.azurerm_resource_group.existing.id
  role_definition_id = var.role_definition_id
  principal_id       = var.identity_id
}

Utwórz nowy plik zmiennych Terraform o nazwie control-plane-role-assignment.tfvars. W tym pliku zmiennych, przypisz wcześniej zarejestrowane identyfikatory definicji roli do zmiennej role_definition_id oraz unikatowy identyfikator tożsamości do zmiennej identity_id.

role_definition_id = "<id-of-new-role-definition>"
identity_id        = "<id-of-existing-identity>"

Zainicjuj i zastosuj tę konfigurację programu Terraform.

terraform init --upgrade

ARM_SUBSCRIPTION_ID=$(az account show --query id --output tsv) terraform plan --var-file="control-plane-role-assignment.tfvars" --out "role-assignment.tfplan"

ARM_SUBSCRIPTION_ID=$(az account show --query id --output tsv) terraform apply "role-assignment.tfplan"

Uzyskaj szczegółowe informacje o aktualnie zalogowanym koncie przy użyciu polecenia az ad signed-in-user.

az ad signed-in-user show

Polecenie zwraca odpowiedź JSON zawierającą różne pola.

{
  "@odata.context": "<https://graph.microsoft.com/v1.0/$metadata#users/$entity>",
  "businessPhones": [],
  "displayName": "Kai Carter",
  "givenName": "Kai",
  "id": "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb",
  "jobTitle": "Senior Sales Representative",
  "mail": "<kai@adventure-works.com>",
  "mobilePhone": null,
  "officeLocation": "Redmond",
  "preferredLanguage": null,
  "surname": "Carter",
  "userPrincipalName": "<kai@adventure-works.com>"
}

Włącz uwierzytelnianie przy użyciu Microsoft Entra ID w klastrze, aktualizując zasób klastra, aby uwzględnić MicrosoftEntraID w tablicy authConfig.allowedModes:

az resource patch \
    --resource-group "<resource-group>" \
    --name "<cluster-name>" \
    --resource-type "Microsoft.DocumentDB/mongoClusters" \
    --properties '{"authConfig":{"allowedModes":["MicrosoftEntraID","NativeAuth"]}}' \
    --latest-include-preview

Sprawdź, czy zmiana została zastosowana, odczytując właściwość authConfig w klastrze za pomocą az resource show.

az resource show \
    --resource-group "<resource-group>" \
    --name "<cluster-name>" \
    --resource-type "Microsoft.DocumentDB/mongoClusters" \
    --query "properties.authConfig" \
    --latest-include-preview

(Opcjonalnie) Uzyskaj unikalny identyfikator dla głównego podmiotu Microsoft Entra, który planujesz zarejestrować w klastrze. Możesz uzyskać go za pomocą interfejsu wiersza polecenia platformy Azure przy użyciu jednego z następujących poleceń:

• Bieżąca zalogowana tożsamość

  az ad signed-in-user show      
  

• Inna tożsamość człowieka używająca przyjaznej nazwy

  az ad user show \
    --id "<user-alias-and-domain>"
  

• Jednostka usługi korzystająca z identyfikatora aplikacji

  az ad sp show \
    --id "<application-id>"
  

• Tożsamość zarządzana przy użyciu grupy zasobów i nazwy

  az identity show \
    --resource-group "<resource-group>" \
    --name "<managed-identity-name>"      
  

Utwórz mały szablon Bicep, który aktualizuje klaster authConfig w celu uwzględnienia identyfikatora Entra firmy Microsoft (zapisz jako enable-entra-id.bicep):

param clusterName string
param location string = resourceGroup().location

resource cluster 'Microsoft.DocumentDB/mongoClusters@2025-09-01' = {
  name: clusterName
  location: location
  properties: {
    authConfig: {
      allowedModes: [
        'MicrosoftEntraID'
        'NativeAuth'
      ]
    }
  }
}

Wdróż szablon, aby zaktualizować klaster:

az deployment group create \
    --resource-group "<resource-group>" \
    --template-file enable-entra-id.bicep \
    --parameters clusterName="<cluster-name>"

Sprawdź właściwość authConfig w klastrze za pomocą az resource show.

az resource show \
    --resource-group "<resource-group>" \
    --name "<cluster-name>" \
    --resource-type "Microsoft.DocumentDB/mongoClusters" \
    --query "properties.authConfig" \
    --latest-include-preview

W okienku Narzędzia główne w witrynie Azure Portal znajdź i wybierz opcję Microsoft Entra ID .

W panelu Przegląd dzierżawy Microsoft Entra ID wybierz Użytkownicy w sekcji Zarządzanie menu usługi.

Na liście użytkowników wybierz użytkownika, o którym chcesz uzyskać więcej szczegółowych informacji.

W okienku szczegółów określonego użytkownika sprawdź wartość właściwości Identyfikator obiektu .

Przejdź do istniejącego zasobu klastra usługi Azure DocumentDB.

W menu klastra w obszarze Ustawienia wybierz pozycję Uwierzytelnianie.

W sekcji Metody uwierzytelniania wybierz pozycję Native DocumentDB i Microsoft Entra ID , aby włączyć uwierzytelnianie identyfikatora Entra firmy Microsoft wraz z uwierzytelnianiem natywnym.

Wybierz Zapisz, aby zapisać zmianę.

Sekcja Metody uwierzytelniania powinna teraz zawierać listę metod NativeAuth i MicrosoftEntraID jako metody włączone.

(Opcjonalnie) Uzyskaj unikalny identyfikator dla głównego podmiotu Microsoft Entra, który planujesz zarejestrować w klastrze. Możesz uzyskać go za pomocą interfejsu wiersza polecenia platformy Azure przy użyciu jednego z następujących poleceń:

• Bieżąca zalogowana tożsamość

  az ad signed-in-user show      
  

• Inna tożsamość człowieka używająca przyjaznej nazwy

  az ad user show \
    --id "<user-alias-and-domain>"
  

• Jednostka usługi korzystająca z identyfikatora aplikacji

  az ad sp show \
    --id "<application-id>"
  

• Tożsamość zarządzana przy użyciu grupy zasobów i nazwy

  az identity show \
    --resource-group "<resource-group>" \
    --name "<managed-identity-name>"      
  

Utwórz plik konfiguracji narzędzia Terraform, aby włączyć uwierzytelnianie identyfikatora entra firmy Microsoft w istniejącym klastrze. Zapisz plik jako enable-entra-id.tf:

variable "cluster_name" {
  type        = string
  description = "Name of the existing cluster"
}

variable "resource_group_name" {
  type        = string
  description = "Name of the existing resource group"
}

terraform {
  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~> 4.0"
    }
  }
}

provider "azurerm" {
  features {}
}

data "azurerm_resource_group" "existing" {
  name = var.resource_group_name
}

data "azurerm_mongo_cluster" "existing" {
  name                = var.cluster_name
  resource_group_name = data.azurerm_resource_group.existing.name
}

resource "azurerm_mongo_cluster" "enable_entra" {
  name                   = data.azurerm_mongo_cluster.existing.name
  resource_group_name    = data.azurerm_resource_group.existing.name
  location               = data.azurerm_mongo_cluster.existing.location
  administrator_username = data.azurerm_mongo_cluster.existing.administrator_username
  administrator_password = data.azurerm_mongo_cluster.existing.administrator_password
  shard_count            = data.azurerm_mongo_cluster.existing.shard_count
  compute_tier           = data.azurerm_mongo_cluster.existing.compute_tier
  high_availability_mode = data.azurerm_mongo_cluster.existing.high_availability_mode
  storage_size_in_gb     = data.azurerm_mongo_cluster.existing.storage_size_in_gb
  version                = data.azurerm_mongo_cluster.existing.version

  # Enable both Microsoft Entra ID and Native authentication
  authentication_enabled = true
}

Utwórz plik zmiennych o nazwie enable-entra-id.tfvars z szczegółami Twojego klastra.

cluster_name        = "<cluster-name>"
resource_group_name = "<resource-group>"

Zainicjuj i zastosuj konfigurację narzędzia Terraform, aby włączyć uwierzytelnianie identyfikatora Entra firmy Microsoft:

terraform init --upgrade

ARM_SUBSCRIPTION_ID=$(az account show --query id --output tsv) terraform plan --var-file="enable-entra-id.tfvars" --out "enable-entra.tfplan"

ARM_SUBSCRIPTION_ID=$(az account show --query id --output tsv) terraform apply "enable-entra.tfplan"

Sprawdź właściwość authConfig w klastrze za pomocą az resource show.

az resource show \
    --resource-group "<resource-group>" \
    --name "<cluster-name>" \
    --resource-type "Microsoft.DocumentDB/mongoClusters" \
    --query "properties.authConfig" \
    --latest-include-preview

Uzyskaj unikatowy identyfikator (identyfikator obiektu) podmiotu Microsoft Entra, któremu chcesz przyznać dostęp, używając jednego z następujących poleceń:

• Bieżąca zalogowana tożsamość

  az ad signed-in-user show      
  

• Inna tożsamość człowieka używająca przyjaznej nazwy

  az ad user show \
    --id "<user-alias-and-domain>"
  

• Jednostka usługi korzystająca z identyfikatora aplikacji

  az ad sp show \
    --id "<application-id>"
  

• Tożsamość zarządzana przy użyciu grupy zasobów i nazwy

  az identity show \
    --resource-group "<resource-group>" \
    --name "<managed-identity-name>"      
  

Zarejestruj główny podmiot w klastrze i przypisz go do ról bazy danych MongoDB. Poniższy przykład rejestruje podmiot zabezpieczeń jako użytkownika w bazie danych readWrite.

az resource create \
    --resource-group "<resource-group>" \
    --name "<cluster-name>/users/<principal-id>" \
    --resource-type "Microsoft.DocumentDB/mongoClusters/users" \
    --location "<cluster-region>" \
    --properties '{"identityProvider":{"type":"MicrosoftEntraID","properties":{"principalType":"User"}},"roles":[{"db":"sales","role":"readWrite"}]}' \
    --latest-include-preview

• Zastąp principalType przez servicePrincipal dla jednostek aplikacji/usługi lub ManagedIdentity dla tożsamości zarządzanych.
• Aby udzielić uprawnień administracyjnych, użyj polecenia {"db":"admin","role":"root"} w tablicy roles .

Wyświetl listę wszystkich zarejestrowanych podmiotów i przypisanych ról (na poziomie klastra):

az rest \
    --method "GET" \
    --url "https://management.azure.com/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.DocumentDB/mongoClusters/<cluster-name>/users?api-version=2025-09-01"

• Odpowiedź zawiera tablicę zasobów użytkownika, z których każda ma identityProvider metadane i tablicę przedstawiającą roles zamapowane role bazy danych.

Uzyskaj szczegóły dotyczące określonego zarejestrowanego podmiotu zabezpieczeń (zastąp <principal-id>):

az resource show \
    --resource-group "<resource-group>" \
    --name "<cluster-name>/users/<principal-id>" \
    --resource-type "Microsoft.DocumentDB/mongoClusters/users" \
    --latest-include-preview

Usuń zarejestrowanego głównego (cofnij dostęp do płaszczyzny danych)

az resource delete \
    --resource-group "<resource-group>" \
    --name "<cluster-name>/users/<principal-id>" \
    --resource-type "Microsoft.DocumentDB/mongoClusters/users" \
    --latest-include-preview

Utwórz plik Bicep (na przykład register-principal.bicep), aby zarejestrować użytkownika oraz przypisać role w bazie danych.

param clusterName string
param principalId string
param location string = resourceGroup().location
param principalType string = 'User'
param roles array = [
  {
    db: 'sales'
    role: 'readWrite'
  }
]

resource user 'Microsoft.DocumentDB/mongoClusters/users@2025-09-01' = {
  name: '${clusterName}/users/${principalId}'
  location: location
  properties: {
    identityProvider: {
      type: 'Microsoft.EntraID'
      properties: {
        principalType: principalType
      }
    }
    roles: roles
  }
}

Wdróż szablon Bicep, aby zarejestrować podmiot główny:

az deployment group create \
    --resource-group "<resource-group>" \
    --template-file register-principal.bicep \
    --parameters clusterName="<cluster-name>" principalId="<principal-id>"

Wyświetl listę wszystkich zarejestrowanych podmiotów dla klastra przy użyciu interfejsu API REST (przydatne po wdrożeniu Bicep):

az rest \
    --method GET \
    --url "https://management.azure.com/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.DocumentDB/mongoClusters/<cluster-name>/users?api-version=2025-09-01"

Uzyskaj szczegółowe informacje dotyczące określonego zarejestrowanego głównego podmiotu utworzonego przez Bicep (zastąp <principal-id>):

az resource show \
    --resource-group "<resource-group>" \
    --name "<cluster-name>/users/<principal-id>" \
    --resource-type "Microsoft.DocumentDB/mongoClusters/users" \
    --latest-include-preview

Aby usunąć główny zasób, usuń zasób (lub wdróż szablon bez zasobu użytkownika):

az resource delete \
    --resource-group "<resource-group>" \
    --name "<cluster-name>/users/<principal-id>" \
    --resource-type "Microsoft.DocumentDB/mongoClusters/users" \
    --latest-include-preview

Otwórz docelowy klaster usługi Azure DocumentDB w witrynie Azure Portal.

W sekcji Ustawienia wybierz pozycję Uwierzytelnianie.

W sekcji Uwierzytelnianie identyfikatora entra firmy Microsoft portal wyświetla listę zarejestrowanych podmiotów zabezpieczeń firmy Microsoft według identyfikatora obiektu. Użyj tego widoku, aby:

• Przeskanuj listę pod kątem oczekiwanych identyfikatorów obiektów.
• Sprawdź szczegóły pojedynczego podmiotu, wybierając wpis na liście (lub użyj funkcji wyszukiwania w portalu).
• Użyj akcji Usuń obok wpisu, aby natychmiast odwołać dostęp tego podmiotu do płaszczyzny danych.

Aby uzyskać przyjazne nazwy identyfikatorów obiektów wyświetlanych na liście portalu, użyj strony Użytkownicy w sekcji Microsoft Entra ID . Następnie wyszukaj według identyfikatora obiektu lub przyjaznej nazwy.

Uzyskaj unikatowy identyfikator (identyfikator obiektu) podmiotu Microsoft Entra, któremu chcesz przyznać dostęp, używając jednego z następujących poleceń:

• Bieżąca zalogowana tożsamość

  az ad signed-in-user show      
  

• Inna tożsamość człowieka używająca przyjaznej nazwy

  az ad user show \
    --id "<user-alias-and-domain>"
  

• Jednostka usługi korzystająca z identyfikatora aplikacji

  az ad sp show \
    --id "<application-id>"
  

• Tożsamość zarządzana przy użyciu grupy zasobów i nazwy

  az identity show \
    --resource-group "<resource-group>" \
    --name "<managed-identity-name>"      
  

Utwórz plik Terraform (na przykład register-principal.tf), aby zarejestrować jednostkę główną i zmapować role bazodanowe przy użyciu dostawcy AzAPI.

variable "cluster_name" {
  type        = string
  description = "Name of the existing cluster"
}

variable "resource_group_name" {
  type        = string
  description = "Name of the existing resource group"
}

variable "principal_id" {
  type        = string
  description = "Object ID of the Microsoft Entra principal"
}

variable "principal_type" {
  type        = string
  description = "Type of principal: User, ServicePrincipal, or ManagedIdentity"
  default     = "User"
}

variable "roles" {
  type = list(object({
    db   = string
    role = string
  }))
  description = "Database roles to assign"
  default = [
    {
      db   = "sales"
      role = "readWrite"
    }
  ]
}

terraform {
  required_providers {
    azapi = {
      source  = "azure/azapi"
      version = "~> 2.0"
    }
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~> 4.0"
    }
  }
}

provider "azurerm" {
  features {}
}

provider "azapi" {}

data "azurerm_resource_group" "existing" {
  name = var.resource_group_name
}

data "azurerm_mongo_cluster" "existing" {
  name                = var.cluster_name
  resource_group_name = var.resource_group_name
}

resource "azapi_resource" "mongo_cluster_user" {
  type      = "Microsoft.DocumentDB/mongoClusters/users@2025-09-01"
  name      = var.principal_id
  parent_id = data.azurerm_mongo_cluster.existing.id
  location  = data.azurerm_resource_group.existing.location

  body = {
    properties = {
      identityProvider = {
        type = "MicrosoftEntraID"
        properties = {
          principalType = var.principal_type
        }
      }
      roles = var.roles
    }
  }
}

Utwórz plik zmiennych o nazwie register-principal.tfvars:

cluster_name        = "<cluster-name>"
resource_group_name = "<resource-group>"
principal_id        = "<principal-id>"
principal_type      = "User"
roles = [
  {
    db   = "sales"
    role = "readWrite"
  }
]

Zainicjować i zastosować konfigurację Terraform, aby zarejestrować podmiot:

terraform init --upgrade

ARM_SUBSCRIPTION_ID=$(az account show --query id --output tsv) terraform plan --var-file="register-principal.tfvars" --out "register-principal.tfplan"

ARM_SUBSCRIPTION_ID=$(az account show --query id --output tsv) terraform apply "register-principal.tfplan"

Wyświetl listę wszystkich zarejestrowanych podmiotów klastra przy użyciu interfejsu REST API (przydatne po wdrożeniu Terraform):

az rest \
    --method GET \
    --url "https://management.azure.com/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.DocumentDB/mongoClusters/<cluster-name>/users?api-version=2025-09-01"

Uzyskaj szczegóły dotyczące określonego zarejestrowanego użytkownika utworzonego przez Terraform (zastąp <principal-id>):

az resource show \
    --resource-group "<resource-group>" \
    --name "<cluster-name>/users/<principal-id>" \
    --resource-type "Microsoft.DocumentDB/mongoClusters/users" \
    --latest-include-preview

Usuń główny zasób, niszcząc zasób Terraform.

ARM_SUBSCRIPTION_ID=$(az account show --query id --output tsv) terraform destroy --var-file="register-principal.tfvars"

Przejdź do klastra usługi Azure DocumentDB.

Wybierz opcję menu nawigacji Parametry połączenia .

Skopiuj lub zapisz wartość z pola Parametry połączenia .