Conexión a Azure DocumentDB mediante el control de acceso basado en rol y el identificador de Microsoft Entra

Abrir un nuevo terminal.

Inicie sesión en la CLI de Azure.

Use az group show para obtener los metadatos del grupo de recursos actual.

az group show \
    --name "<name-of-existing-resource-group>"

Observe la salida del comando anterior. Registre el valor de la id propiedad para este grupo de recursos, ya que es necesario usar en el paso siguiente.

{
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourcegroups/msdocs-identity-example",
  "location": "westus",
  "name": "msdocs-identity-example",
  "type": "Microsoft.Resources/resourceGroups"
}

Cree un nuevo archivo JSON denominado role-definition.json. En el archivo, cree esta definición de recurso especificando los valores enumerados aquí. En la lista AssignableScopes, agregue la propiedad id del grupo de recursos registrado en el paso anterior.

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

Cree una nueva definición de roles mediante az role definition create. Use el archivo role-definition.json como entrada para el --role-definition argumento .

az role definition create \
    --role-definition role-definition.json

Revise la salida del comando de creación de definiciones. La salida contiene el identificador único de la definición de rol en la id propiedad . Registre este valor como es necesario para usarlo en el paso de asignación más adelante en esta guía.

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

Abrir un nuevo terminal.

Inicie sesión en la CLI de Azure.

Cree un nuevo archivo de Bicep para definir tu rol. Asigne al archivo el nombre control-plane-role-definition.bicep. Agregue estos elementos actions a la definición:

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

Implemente la plantilla de Bicep usando az deployment group create. Especifique el nombre de la plantilla de Bicep y el grupo de recursos de Azure.

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

Revise la salida de la implementación. La salida contiene el identificador único de la definición de rol en la properties.outputs.definitionId.value propiedad . Registre este valor como es necesario para usarlo en el paso de asignación más adelante en esta guía.

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

Cree un nuevo archivo de Bicep para definir la asignación de roles. Asigne al archivo el nombre 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
  }
}

Cree un nuevo archivo de parámetros de Bicep denominado control-plane-role-assignment.bicepparam. En este archivo de parámetros, asigne los identificadores de definición de roles registrados anteriormente al parámetro roleDefinitionId y el identificador único de su identidad al parámetro identityId.

using './control-plane-role-assignment.bicep'

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

Implemente esta plantilla de Bicep mediante 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

Inicie sesión en Azure Portal (https://portal.azure.com).

Escriba Grupo de recursos en la barra de búsqueda global.

En Servicios, seleccione Grupos de recursos.

En el panel Grupos de recursos, seleccione el grupo de recursos existente.

En el panel del grupo de recursos, seleccione Control de acceso (IAM) en el menú servicio.

En el panel Control de acceso (IAM), seleccione Agregar. A continuación, seleccione Agregar rol personalizado.

En el panel Aspectos básicos , configure las siguientes opciones y, a continuación, seleccione Siguiente:

En el panel Permisos , seleccione Agregar permisos. A continuación, busque DocumentDB en el cuadro de diálogo permisos. Por último, seleccione la opción Microsoft.DocumentDB/mongoClusters .

En el cuadro de diálogo Permisos, seleccione todas las acciones para Microsoft.DocumentDB/mongoClusters. A continuación, seleccione Agregar para volver al panel *Permisos .

De nuevo en el panel Permisos , observe la lista de permisos. A continuación, seleccione Revisar y crear.

En el panel Revisar y crear , revise las opciones especificadas para la nueva definición de roles. Por último, seleccione Crear.

Espere a que el portal termine de crear la definición de roles.

En el panel Control de acceso (IAM), seleccione Agregar y, a continuación, Agregar asignación de roles.

En el panel Rol , busque Azure DocumentDB y seleccione el rol Propietario de RBAC de Azure DocumentDB creado anteriormente en esta guía. Después, seleccione Siguiente.

En el panel Miembros , seleccione la opción Seleccionar miembros . En el cuadro de diálogo miembros, seleccione la identidad que desea conceder a este nivel de acceso para los clústeres de Azure DocumentDB y, a continuación, use la opción Seleccionar para confirmar su elección.

De nuevo en el panel Miembros , revise los miembros seleccionados y, a continuación, seleccione Revisar y asignar.

En el panel Revisar y asignar , revise las opciones especificadas para la nueva asignación de roles. Por último, seleccione Revisar y asignar.

Espere a que el portal termine de crear la asignación de roles.

Abrir un nuevo terminal.

Inicie sesión en la CLI de Azure.

Compruebe la suscripción de Azure de destino.

az account show

Cree un nuevo archivo de Terraform para definir la definición de roles. Asigne al archivo el nombre control-plane-role-definition.tf. Agregue estos elementos actions a la definición:

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
}

Inicialice la implementación de Terraform.

terraform init --upgrade

Cree un plan de ejecución para la definición de roles y guárdelo en un archivo denominado role-definition.tfplan.

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

Aplique el plan de ejecución para implementar la definición de roles en Azure.

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

Revise la salida de la implementación. La salida contiene el identificador único de la definición de rol en la definition_id propiedad . Registre este valor como es necesario para usarlo en el paso de asignación más adelante en esta guía.

Cree un nuevo archivo de Terraform para definir la asignación de roles. Asigne al archivo el nombre 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
}

Cree un nuevo archivo de variables de Terraform denominado control-plane-role-assignment.tfvars. En este archivo de variables, asigne los identificadores de definición de roles registrados previamente a la variable role_definition_id y el identificador único de su identidad a la variable identity_id.

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

Inicialice y aplique esta configuración de 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"

Obtenga los detalles de la cuenta que ha iniciado sesión actualmente con az ad signed-in-user.

az ad signed-in-user show

El comando genera una respuesta JSON que contiene varios campos.

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

Habilite la autenticación de Microsoft Entra ID en el clúster actualizando el recurso del clúster para incluir MicrosoftEntraID en el array 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

Compruebe que el cambio se aplicó mediante la lectura de la authConfig propiedad en el clúster mediante az resource show.

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

(Opcional) Obtenga el identificador único de la entidad de seguridad de Microsoft Entra que planea registrar en el clúster. Puede obtenerlo con la CLI de Azure mediante uno de los siguientes comandos:

• Identidad de sesión actual

  az ad signed-in-user show      
  

• Otra identidad humana con el nombre amigable

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

• Entidad de servicio mediante el identificador de aplicación

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

• Identidad administrada mediante el grupo de recursos y el nombre

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

Cree una plantilla de Bicep pequeña que actualice el clúster authConfig para incluir el identificador de Microsoft Entra (guardar como 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'
      ]
    }
  }
}

Implemente la plantilla para actualizar el clúster:

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

Compruebe la authConfig propiedad del clúster mediante az resource show.

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

En el panel Inicio de Azure Portal, busque y seleccione la opción Id. de Entra de Microsoft .

En el panel Información general del inquilino de Microsoft Entra ID, seleccione Usuarios dentro de la sección Administrar del menú del servicio.

En la lista de usuarios, seleccione la identidad (usuario) sobre la que desea obtener más detalles.

En el panel de detalles del usuario específico, observe el valor de la propiedad ID de objeto.

Vaya al recurso de clúster de Azure DocumentDB existente.

En el menú del clúster, en Configuración, seleccione Autenticación.

En la sección Métodos de autenticación , seleccione Native DocumentDB y Microsoft Entra ID para habilitar la autenticación de Id. de Microsoft Entra junto con la autenticación nativa.

Seleccione Guardar para conservar el cambio.

La sección Métodos de autenticación ahora debe enumerar NativeAuth y MicrosoftEntraID como métodos habilitados.

(Opcional) Obtenga el identificador único de la entidad de seguridad de Microsoft Entra que planea registrar en el clúster. Puede obtenerlo con la CLI de Azure mediante uno de los siguientes comandos:

• Identidad de sesión actual

  az ad signed-in-user show      
  

• Otra identidad humana con el nombre amigable

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

• Entidad de servicio mediante el identificador de aplicación

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

• Identidad administrada mediante el grupo de recursos y el nombre

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

Cree un archivo de configuración de Terraform para habilitar la autenticación de Microsoft Entra ID en su clúster existente. Guarde el archivo como 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
}

Cree un archivo de variables denominado enable-entra-id.tfvars con los detalles del clúster:

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

Inicialice y aplique la configuración de Terraform para habilitar la autenticación de Microsoft Entra ID.

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"

Compruebe la authConfig propiedad del clúster mediante az resource show.

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

Obtenga el identificador único (id. de objeto) de la entidad de Microsoft Entra a la que desea conceder acceso mediante uno de los siguientes comandos:

• Identidad de sesión actual

  az ad signed-in-user show      
  

• Otra identidad humana con el nombre amigable

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

• Entidad de servicio mediante el identificador de aplicación

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

• Identidad administrada mediante el grupo de recursos y el nombre

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

Registre el principal en el clúster y asígnelo a los roles de base de datos de MongoDB. El siguiente ejemplo registra un principal como usuario readWrite en la base de datos sales.

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

• Reemplazar principalType por servicePrincipal para los principales de aplicaciones o servicios o ManagedIdentity para las identidades administradas.
• Para conceder privilegios administrativos, use {"db":"admin","role":"root"} en la roles matriz.

Enumerar todos los principales registrados y sus roles asignados (vista de nivel de clúster):

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"

• La respuesta contiene una matriz de recursos de usuario, cada una con identityProvider metadatos y una roles matriz que muestra los roles de base de datos asignados.

Obtenga los detalles de un principal registrado específico (reemplace <principal-id>):

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

Eliminar un principal registrado (revocar acceso al plano de datos):

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

Cree un archivo de Bicep (por ejemplo register-principal.bicep) para registrar las entidades de seguridad y asignar los roles de la base de datos:

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

Implemente la plantilla de Bicep para registrar la entidad de seguridad:

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

Enumerar todas las entidades de seguridad registradas del clúster mediante la API de REST, lo cual es útil después de la implementación con 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"

Obtenga los detalles de una entidad de seguridad registrada específica creado por Bicep (reemplace <principal-id>):

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

Quite el principal mediante la eliminación del recurso (o implemente una plantilla sin el recurso del usuario):

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

Abra el clúster de Azure DocumentDB de destino en Azure Portal.

En Configuración, seleccione Autenticación.

En la sección autenticación de Microsoft Entra ID, el portal muestra las entidades de seguridad registradas de Microsoft Entra por identificador de objeto. Utilice esta vista para:

• Examine la lista para ver los identificadores de objeto esperados.
• Inspeccione los detalles de una sola entidad principal seleccionando una entrada enumerada (o use la función de búsqueda del portal).
• Utiliza la acción Quitar junto a una entrada para revocar inmediatamente el acceso al plano de datos de ese principal.

Para obtener nombres comprensibles para los identificadores de objeto que se muestran en la lista del portal, use la página Usuarios de la sección Microsoft Entra ID. A continuación, busque por identificador de objeto o nombre amigable.

Obtenga el identificador único (id. de objeto) de la entidad de Microsoft Entra a la que desea conceder acceso mediante uno de los siguientes comandos:

• Identidad de sesión actual

  az ad signed-in-user show      
  

• Otra identidad humana con el nombre amigable

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

• Entidad de servicio mediante el identificador de aplicación

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

• Identidad administrada mediante el grupo de recursos y el nombre

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

Cree un archivo de Terraform (por ejemplo register-principal.tf) para registrar la entidad de seguridad y asignar roles de base de datos utilizando el proveedor 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
    }
  }
}

Cree un archivo de variables denominado register-principal.tfvars:

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

Inicie y aplique la configuración de Terraform para registrar la entidad de seguridad:

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"

Enumere todos los principales registrados del clúster mediante la API REST (útil después de la implementación de 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"

Obtenga detalles de un principal registrado específico creado por Terraform (reemplace <principal-id>):

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

Elimine el principal destruyendo el recurso de Terraform:

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

Vaya al clúster de Azure DocumentDB.

Seleccione la opción de menú de navegación Cadenas de conexión.

Copie o registre el valor del campo Cadena de conexión .