Share via

Uso de una identidad administrada asignada por el usuario para una cuenta de Azure Automation

  • Artículo

En este artículo, se muestra cómo agregar una identidad administrada asignada por el usuario para una cuenta de Azure Automation y cómo usarla para acceder a otros recursos. Para más información sobre cómo funcionan las identidades administradas con Azure Automation, consulte Identidades administradas (versión preliminar).

Nota:

No es posible usar una identidad administrada asignada por el usuario en una instancia de Hybrid Runbook Worker cuando se ha creado una identidad administrada (asignada por el sistema o por el usuario) para la cuenta de Automation. Si la identidad administrada no se ha asignado a la cuenta de Automation, es posible usar la identidad administrada asignada por el sistema o por el usuario de la máquina virtual en una instancia de Hybrid Runbook Worker que sea una máquina virtual de Azure con las identidades administradas asignadas.

Si no tiene una suscripción a Azure, cree una cuenta gratuita antes de empezar.

Requisitos previos

  • Una cuenta de Azure Automation Para obtener instrucciones, consulte Creación de una cuenta de Azure Automation.

  • La identidad administrada asignada por el usuario y los recursos de Azure de destino que administra el runbook con esa identidad pueden estar en diferentes suscripciones de Azure.

  • La versión más reciente de los módulos de cuenta de Azure. Actualmente, es la versión 2.2.8. (Consulte Az.Accounts para obtener más información sobre esta versión).

  • Un recurso de Azure al que desea acceder desde el runbook de Automation. Este recurso debe tener un rol definido para la identidad administrada asignada por el usuario, lo que ayuda al runbook de Automation a autenticar el acceso al recurso. Para agregar roles, debe ser propietario del recurso en el inquilino de Microsoft Entra correspondiente.

  • Para asignar un rol de Azure debe tener permisos Microsoft.Authorization/roleAssignments/write, como Administrador de acceso de usuario o Propietario.

Adición de una identidad administrada asignada por el usuario para una cuenta de Azure Automation

Puede agregar una identidad administrada asignada por el usuario para una cuenta de Azure Automation mediante Azure Portal, PowerShell, la API REST de Azure o una plantilla de ARM. Para los ejemplos que implican PowerShell, inicie sesión primero en Azure de forma interactiva con el cmdlet Connect-AzAccount y siga las instrucciones.

# Sign in to your Azure subscription
$sub = Get-AzSubscription -ErrorAction SilentlyContinue
if(-not($sub))
{
    Connect-AzAccount
}

# If you have multiple subscriptions, set the one to use
# Select-AzSubscription -SubscriptionId "<SUBSCRIPTIONID>"

A continuación, inicialice un conjunto de variables que se usarán a lo largo de los ejemplos. Revise los valores siguientes y, a continuación, ejecute:

$subscriptionID = "subscriptionID"
$resourceGroup = "resourceGroupName"
$automationAccount = "automationAccountName"
$userAssignedOne = "userAssignedIdentityOne"
$userAssignedTwo = "userAssignedIdentityTwo"

Adición mediante Azure Portal

Lleve a cabo los siguiente pasos:

  1. Inicie sesión en Azure Portal.

  2. En Azure Portal, vaya a su cuenta de Automation.

  3. En Configuración de la cuenta, seleccione Identidad.

  4. Seleccione la pestaña Usuario asignado y, a continuación, seleccione Agregar.

  5. Seleccione la identidad administrada asignada por el usuario existente y, a continuación, seleccione Agregar. A continuación, volverá a la pestaña Usuario asignado.

    Output from Portal.

Incorporación mediante PowerShell

Use el cmdlet de PowerShell Set-AzAutomationAccount para agregar las identidades administradas asignadas por el usuario. En primer lugar, debe tener en cuenta si hay una identidad administrada asignada por el sistema existente. En el ejemplo siguiente, se agregan dos identidades administradas asignadas por el usuario existentes a una cuenta de Automation existente y se deshabilitará una identidad administrada asignada por el sistema si existe una.

$output = Set-AzAutomationAccount `
    -ResourceGroupName $resourceGroup `
    -Name $automationAccount `
    -AssignUserIdentity "/subscriptions/$subscriptionID/resourcegroups/$resourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/$userAssignedOne", `
        "/subscriptions/$subscriptionID/resourcegroups/$resourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/$userAssignedTwo"

$output

Para mantener una identidad administrada asignada por el sistema existente, use lo siguiente:

$output = Set-AzAutomationAccount `
    -ResourceGroupName $resourceGroup `
    -Name $automationAccount `
    -AssignUserIdentity "/subscriptions/$subscriptionID/resourcegroups/$resourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/$userAssignedOne", `
        "/subscriptions/$subscriptionID/resourcegroups/$resourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/$userAssignedTwo" `
    -AssignSystemIdentity

$output

La salida debe tener una apariencia similar a la siguiente:

Output from Set-AzAutomationAccount command.

Para obtener una salida adicional, ejecute: $output.identity | ConvertTo-Json.

Adición mediante una API REST

A continuación, se proporcionan los pasos de ejemplo y la sintaxis.

Sintaxis

La sintaxis del cuerpo del ejemplo siguiente habilita una identidad administrada asignada por el sistema si aún no está habilitada y asigna dos identidades administradas asignadas por el usuario existentes a la cuenta de Automation existente.

PATCH

{
  "identity": {
    "type": "SystemAssigned, UserAssigned",
    "userAssignedIdentities": {
      "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resource-group-name/providers/Microsoft.ManagedIdentity/userAssignedIdentities/firstIdentity": {},
      "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resource-group-name/providers/Microsoft.ManagedIdentity/userAssignedIdentities/secondIdentity": {}
    }
  }
}

La sintaxis de la API es la siguiente:

https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resource-group-name/providers/Microsoft.Automation/automationAccounts/automation-account-name?api-version=2020-01-13-preview

Ejemplo

Lleve a cabo los pasos siguientes.

  1. Revise la sintaxis del cuerpo anterior en un archivo llamado body_ua.json. Guarde el archivo en la máquina local o en una cuenta de almacenamiento de Azure.

  2. Revise el valor de la variable siguiente y, a continuación, ejecute:

    $file = "path\body_ua.json"

  3. Este ejemplo usa el cmdlet de PowerShell Invoke-RestMethod para enviar una solicitud PATCH a la cuenta de Automation.

    # build URI
$URI = "https://management.azure.com/subscriptions/$subscriptionID/resourceGroups/$resourceGroup/providers/Microsoft.Automation/automationAccounts/$automationAccount`?api-version=2020-01-13-preview"

# build body
$body = Get-Content $file

# obtain access token
$azContext = Get-AzContext
$azProfile = [Microsoft.Azure.Commands.Common.Authentication.Abstractions.AzureRmProfileProvider]::Instance.Profile
$profileClient = New-Object -TypeName Microsoft.Azure.Commands.ResourceManager.Common.RMProfileClient -ArgumentList ($azProfile)
$token = $profileClient.AcquireAccessToken($azContext.Subscription.TenantId)
$authHeader = @{
    'Content-Type'='application/json'
    'Authorization'='Bearer ' + $token.AccessToken
}

# Invoke the REST API
$response = Invoke-RestMethod -Uri $URI -Method PATCH -Headers $authHeader -Body $body

# Review output
$response.identity | ConvertTo-Json

    La salida debe tener una apariencia similar a la siguiente:

    {
"type": "SystemAssigned, UserAssigned",
"principalId": "00000000-0000-0000-0000-000000000000",
"tenantId": "00000000-0000-0000-0000-000000000000",
"userAssignedIdentities":  {
    "/subscriptions/ContosoID/resourcegroups/ContosoLab/providers/Microsoft.ManagedIdentity/userAssignedIdentities/ContosoUAMI1":  {
            "PrincipalId":  "00000000-0000-0000-0000-000000000000",
            "ClientId":  "00000000-0000-0000-0000-000000000000"
                },
    "/subscriptions/ContosoID/resourcegroups/ContosoLab/providers/Microsoft.ManagedIdentity/userAssignedIdentities/ContosoUAMI2":  {
            "PrincipalId":  "00000000-0000-0000-0000-000000000000",
            "ClientId":  "00000000-0000-0000-0000-000000000000"
                }
    }
}

Adición mediante una plantilla de ARM

A continuación, se proporcionan los pasos de ejemplo y la sintaxis.

Sintaxis de plantillas

La sintaxis de la plantilla de ejemplo siguiente habilita una identidad administrada asignada por el sistema si aún no está habilitada y asigna dos identidades administradas asignadas por el usuario existentes a la cuenta de Automation existente.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "automationAccountName": {
     "defaultValue": "YourAutomationAccount",
      "type": "String",
      "metadata": {
        "description": "Automation account name"
      }
    },
    "userAssignedOne": {
     "defaultValue": "userAssignedOne",
      "type": "String",
      "metadata": {
        "description": "User-assigned managed identity"
      }
	  },
    "userAssignedTwo": {
     "defaultValue": "userAssignedTwo",
      "type": "String",
      "metadata": {
        "description": "User-assigned managed identity"
      }
	  }
   },
  "resources": [
    {
      "type": "Microsoft.Automation/automationAccounts",
      "apiVersion": "2020-01-13-preview",
      "name": "[parameters('automationAccountName')]",
      "location": "[resourceGroup().location]",
      "identity": {
        "type": "SystemAssigned, UserAssigned",
        "userAssignedIdentities": {
          "[resourceID('Microsoft.ManagedIdentity/userAssignedIdentities/',parameters('userAssignedOne'))]": {},
          "[resourceID('Microsoft.ManagedIdentity/userAssignedIdentities/',parameters('userAssignedTwo'))]": {}
        }
      },
      "properties": {
        "sku": {
          "name": "Basic"
        },
        "encryption": {
          "keySource": "Microsoft.Automation",
          "identity": {}
        }
      }
    }
  ]
}

Ejemplo

Lleve a cabo los pasos siguientes.

  1. Copie y pegue la plantilla en un archivo llamado template_ua.json. Guarde el archivo en la máquina local o en una cuenta de almacenamiento de Azure.

  2. Revise el valor de la variable siguiente y, a continuación, ejecute:

    $templateFile = "path\template_ua.json"

  3. Use el cmdlet de PowerShell New-AzResourceGroupDeployment para implementar la plantilla.

    New-AzResourceGroupDeployment `
    -Name "UserAssignedDeployment" `
    -ResourceGroupName $resourceGroup `
    -TemplateFile $templateFile `
    -automationAccountName $automationAccount `
    -userAssignedOne $userAssignedOne `
    -userAssignedTwo $userAssignedTwo

    El comando no producirá ninguna salida; sin embargo, puede usar el código siguiente para comprobarlo:

    (Get-AzAutomationAccount `
-ResourceGroupName $resourceGroup `
-Name $automationAccount).Identity | ConvertTo-Json

    La salida tendrá un aspecto similar al que se muestra en el ejemplo anterior de la API REST.

Asignación de un rol a una identidad administrada asignada por el usuario

Una cuenta de Automation puede utilizar su identidad administrada asignada por el usuario para obtener tokens para acceder a otros recursos protegidos por Microsoft Entra ID, como Azure Key Vault. Estos tokens no representan a ningún usuario específico de la aplicación, sino que representan la aplicación que accede al recurso. En este caso, por ejemplo, el token representa una cuenta de Automation.

Para poder usar la identidad administrada asignada por el usuario para la autenticación, configure el acceso para esa identidad en el recurso de Azure en el que planea usar la identidad. Para completar esta tarea, asigne el rol adecuado a esa identidad en el recurso de Azure de destino.

Siga la entidad de seguridad con menos privilegios y asigne cuidadosamente solo los permisos necesarios para ejecutar el runbook. Por ejemplo, si la cuenta de Automation solo es necesaria para iniciar o detener una VM de Azure, los permisos asignados a la cuenta de ejecución o a la identidad administrada solo deben ser para iniciar o detener la VM. De manera similar, si un runbook lee del almacenamiento de blobs, asigne permisos de solo lectura.

En este ejemplo se usa Azure PowerShell para mostrar cómo asignar el rol Colaborador en la suscripción al recurso de Azure de destino. El rol Colaborador se usa como ejemplo y puede ser necesario o no en su caso. Como alternativa, puede usar Azure Portal para asignar el rol al recurso de Azure de destino.

New-AzRoleAssignment `
    -ObjectId <automation-Identity-object-id> `
    -Scope "/subscriptions/<subscription-id>" `
    -RoleDefinitionName "Contributor"

Comprobación de la asignación de roles a una identidad administrada por el usuario

Para comprobar un rol en una identidad administrada asignada por el usuario de la cuenta de Automation, siga estos pasos:

  1. Inicie sesión en Azure Portal.

  2. Vaya a su cuenta de Automation.

  3. En Configuración de la cuenta, seleccione Identidad, Usuario asignado.

  4. Haga clic en Nombre de identidad asignado por el usuario.

    Assigning role in user-assigned identity in Azure portal.

    Si los roles ya están asignados a la identidad administrada asignada por el usuario seleccionada, puede ver una lista de asignaciones de roles. En esta lista se incluyen todas las asignaciones de roles que puede leer.

    View role-assignments that you have permission in Azure portal.

  5. Para cambiar la suscripción, haga clic en la lista desplegable Suscripción y seleccione la suscripción adecuada.

  6. Haga clic en Agregar asignación de roles (versión preliminar).

  7. En la lista desplegable, seleccione el conjunto de recursos al que se aplica la asignación de roles: Suscripción, Grupo de recursos, Rol y Ámbito.
    Si no tiene la asignación de roles, puede ver los permisos de escritura del ámbito seleccionado como mensaje insertado.

  8. En la lista desplegable Rol, seleccione un rol como Colaborador de máquina virtual.

  9. Haga clic en Save(Guardar).

    Add a role assignment in Azure portal.

Transcurridos unos minutos, se asigna el rol a la identidad administrada en el ámbito seleccionado.

Autenticación del acceso con una identidad administrada asignada por el usuario

Después de habilitar la identidad administrada asignada por el usuario para la cuenta de Automation y de conceder acceso a una identidad al recurso de destino, puede especificar esa identidad en los runbooks para los recursos que admiten la identidad administrada. Para ver la compatibilidad con las identidades, use el cmdlet Az Connect-AzAccount.

# Ensures you do not inherit an AzContext in your runbook
Disable-AzContextAutosave -Scope Process

# Connect to Azure with user-assigned managed identity
$AzureContext = (Connect-AzAccount -Identity -AccountId <user-assigned-identity-ClientId>).context

# set and store context
$AzureContext = Set-AzContext -SubscriptionName $AzureContext.Subscription -DefaultProfile $AzureContext

Generación de un token de acceso sin usar cmdlets de Azure

Para los puntos de conexión HTTP, asegúrese de lo siguiente.

  • El encabezado de metadatos debe estar presente y establecido en "true".
  • Se debe pasar un recurso junto con la solicitud, como parámetro de consulta para una solicitud GET y como datos de formulario para una solicitud POST.
  • Establezca el valor de la variable de entorno IDENTITY_HEADER en X-IDENTITY-HEADER.
  • El tipo de contenido de la solicitud Post debe ser application/x-www-form-urlencoded.

Obtención de un token de acceso para la identidad administrada asignada por el usuario mediante HTTP Get

$resource= "?resource=https://management.azure.com/"
$client_id="&client_id=<ClientId of USI>"
$url = $env:IDENTITY_ENDPOINT + $resource + $client_id 
$Headers = New-Object "System.Collections.Generic.Dictionary[[String],[String]]"  
$Headers.Add("Metadata", "True")
$headers.Add("X-IDENTITY-HEADER", $env:IDENTITY_HEADER) 
$accessToken = Invoke-RestMethod -Uri $url -Method 'GET' -Headers $Headers
Write-Output $accessToken.access_token

Obtención de un token de acceso para la identidad administrada asignada por el usuario mediante HTTP Post

$url = $env:IDENTITY_ENDPOINT
$headers = New-Object "System.Collections.Generic.Dictionary[[String],[String]]"
$headers.Add("Metadata", "True")
$headers.Add("X-IDENTITY-HEADER", $env:IDENTITY_HEADER) 
$body = @{'resource'='https://management.azure.com/' 
'client_id'='<ClientId of USI>'}
$accessToken = Invoke-RestMethod $url -Method 'POST' -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body $body
Write-Output $accessToken.access_token

Uso de una identidad administrada asignada por el usuario en Azure PowerShell

Write-Output "Connecting to azure via  Connect-AzAccount -Identity -AccountId <ClientId of USI>"  
Connect-AzAccount -Identity -AccountId <ClientId of USI> 
Write-Output "Successfully connected with Automation account's Managed Identity"  
Write-Output "Trying to fetch value from key vault using User Assigned Managed identity. Make sure you have given correct access to Managed Identity"  
$secret = Get-AzKeyVaultSecret -VaultName '<KVname>' -Name '<KeyName>'  
$ssPtr = [System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($secret.SecretValue)  
try {  
  $secretValueText = [System.Runtime.InteropServices.Marshal]::PtrToStringBSTR($ssPtr)  
    Write-Output $secretValueText  
} finally {  
    [System.Runtime.InteropServices.Marshal]::ZeroFreeBSTR($ssPtr)  
}

Uso de una identidad administrada asignada por el usuario en un runbook de Python

#!/usr/bin/env python3  
import os  
import requests   

resource = "?resource=https://management.azure.com/" 
client_id = "&client_id=<ClientId of USI>" 
endPoint = os.getenv('IDENTITY_ENDPOINT')+ resource +client_id 
identityHeader = os.getenv('IDENTITY_HEADER') 
payload={}  
headers = {  
  'X-IDENTITY-HEADER': identityHeader,
  'Metadata': 'True' 
}  
response = requests.request("GET", endPoint, headers=headers, data=payload)  
print(response.text)

Pasos siguientes