Utilizar a identidade gerida atribuída pelo utilizador para uma conta de Automatização do Azure

  • Artigo

Este artigo mostra como adicionar uma identidade gerenciada atribuída pelo usuário para uma conta de Automação do Azure e como usá-la para acessar outros recursos. Para obter mais informações sobre como as identidades gerenciadas funcionam com a Automação do Azure, consulte Identidades gerenciadas.

Nota

Não é possível usar uma Identidade Gerenciada Atribuída ao Usuário em um Runbook Worker Híbrido quando uma Identidade Gerenciada (Sistema ou Usuário atribuído) foi criada para a Conta de Automação. Se a Identidade Gerenciada não tiver sido atribuída à Conta de Automação, será possível usar o Sistema da VM ou a Identidade Gerenciada Atribuída pelo Usuário em um Operador de Runbook Híbrido que seja uma VM do Azure com as identidades gerenciadas atribuídas.

Se não tiver uma subscrição do Azure, crie uma conta gratuita antes de começar.

Pré-requisitos

Adicionar identidade gerenciada atribuída pelo usuário para a conta de Automação do Azure

Você pode adicionar uma identidade gerenciada atribuída pelo usuário para uma conta de Automação do Azure usando o portal do Azure, o PowerShell, a API REST do Azure ou o modelo ARM. Para obter os exemplos que envolvem o PowerShell, primeiro entre no Azure interativamente usando o cmdlet Connect-AzAccount e siga as instruções.

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

Em seguida, inicialize um conjunto de variáveis que serão usadas em todos os exemplos. Revise os valores abaixo e execute"

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

Adicionar usando o portal do Azure

Efetue os seguintes passos:

  1. Inicie sessão no portal do Azure.

  2. No portal do Azure, navegue até sua conta de automação.

  3. Em Definições da Conta, selecione Identidade.

  4. Selecione a guia Usuário atribuído e, em seguida, selecione Adicionar.

  5. Selecione sua identidade gerenciada atribuída pelo usuário existente e, em seguida, selecione Adicionar. Em seguida, você retornará à guia Atribuído ao usuário.

    Output from Portal.

Adicionar usando o PowerShell

Use o cmdlet do PowerShell Set-AzAutomationAccount para adicionar as identidades gerenciadas atribuídas pelo usuário. Primeiro, você deve considerar se há uma identidade gerenciada atribuída ao sistema existente. O exemplo abaixo adiciona duas identidades gerenciadas atribuídas pelo usuário a uma conta de automação existente e desabilitará uma identidade gerenciada atribuída ao sistema, se existir.

$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 manter uma identidade gerenciada atribuída ao sistema existente, use o seguinte:

$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

O resultado deve ser algo semelhante ao seguinte:

Output from Set-AzAutomationAccount command.

Para saída adicional, execute: $output.identity | ConvertTo-Json.

Adicionar usando uma API REST

A sintaxe e as etapas de exemplo são fornecidas abaixo.

Sintaxe

A sintaxe do corpo de exemplo abaixo habilita uma identidade gerenciada atribuída ao sistema, se ainda não estiver habilitada, e atribui duas identidades gerenciadas atribuídas pelo usuário à conta de automação 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": {}
    }
  }
}

A sintaxe da API é a seguinte:

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

Exemplo

Efetue os seguintes passos.

  1. Revise a sintaxe do corpo acima em um arquivo chamado body_ua.json. Salve o arquivo em sua máquina local ou em uma conta de armazenamento do Azure.

  2. Revise o valor da variável abaixo e execute.

    $file = "path\body_ua.json"

  3. Este exemplo usa o cmdlet do PowerShell Invoke-RestMethod para enviar a solicitação PATCH para sua conta de automação.

    # 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

    O resultado deve ser algo semelhante ao seguinte:

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

Adicionar usando um modelo ARM

A sintaxe e as etapas de exemplo são fornecidas abaixo.

Sintaxe do modelo

A sintaxe de modelo de exemplo abaixo habilita uma identidade gerenciada atribuída ao sistema, se ainda não estiver habilitada, e atribui duas identidades gerenciadas atribuídas pelo usuário existentes à conta de automação 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": {}
        }
      }
    }
  ]
}

Exemplo

Efetue os seguintes passos.

  1. Copie e cole o modelo em um arquivo chamado template_ua.json. Salve o arquivo em sua máquina local ou em uma conta de armazenamento do Azure.

  2. Revise o valor da variável abaixo e execute.

    $templateFile = "path\template_ua.json"

  3. Use o cmdlet do PowerShell New-AzResourceGroupDeployment para implantar o modelo.

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

    O comando não produzirá uma saída; no entanto, você pode usar o código abaixo para verificar:

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

    A saída será semelhante à saída mostrada para o exemplo da API REST, acima.

Atribuir uma função a uma identidade gerida atribuída pelo utilizador

Uma conta de automação pode usar sua identidade gerenciada atribuída pelo usuário para obter tokens para acessar outros recursos protegidos pelo Microsoft Entra ID, como o Azure Key Vault. Estes tokens não representam nenhum utilizador específico da aplicação. Em vez disso, representam a aplicação que está a aceder ao recurso. Neste caso, por exemplo, o token representa uma conta de Automatização.

Antes de poder utilizar a identidade gerida atribuída pelo utilizador para autenticação, configure o acesso a essa identidade no recurso do Azure onde planeia utilizar a identidade. Para concluir esta tarefa, atribua a função adequada a essa identidade no recurso do Azure de destino.

Siga o principal com menos privilégios e atribua cuidadosamente as permissões necessárias apenas para executar o runbook. Por exemplo, se a conta de Automatização for necessária apenas para iniciar ou parar uma VM do Azure, as permissões atribuídas à conta Run As ou à identidade gerida têm de ser apenas para iniciar ou parar a VM. Da mesma forma, se um runbook estiver a ler a partir do armazenamento de blobs, atribua permissões só de leitura.

Este exemplo usa o Azure PowerShell para mostrar como atribuir a função de Colaborador na assinatura ao recurso do Azure de destino. A função de Colaborador é usada como exemplo e pode ou não ser necessária no seu caso. Como alternativa, você também pode atribuir a função ao recurso do Azure de destino no portal do Azure.

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

Verificar a atribuição de função a uma identidade gerenciada pelo usuário

Para verificar uma função para uma identidade gerida atribuída pelo utilizador da conta de Automatização, siga estes passos:

  1. Inicie sessão no portal do Azure.

  2. Aceda à sua conta de Automatização.

  3. Em Configurações da conta, selecione Identidade, Usuário atribuído.

  4. Clique em Nome de identidade atribuído ao usuário.

    Assigning role in user-assigned identity in Azure portal.

    Se as funções já estiverem atribuídas à identidade gerida atribuída pelo utilizador selecionada, pode ver uma lista de atribuições de funções. Esta lista inclui todas as atribuições de funções que tem permissão para ler.

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

  5. Para alterar a assinatura, clique na lista suspensa Assinatura e selecione a assinatura apropriada.

  6. Clique em Adicionar atribuição de função (Pré-visualização)

  7. Na lista suspensa, selecione o conjunto de recursos que a atribuição de função aplica - Assinatura, Grupo de recursos, Função e Escopo.
    Se você não tiver a atribuição de função, poderá exibir as permissões de gravação para o escopo selecionado como uma mensagem embutida.

  8. Na lista suspensa Função, selecione uma função como Colaborador de Máquina Virtual.

  9. Clique em Guardar.

    Add a role assignment in Azure portal.

Após alguns minutos, a identidade gerenciada recebe a função no escopo selecionado.

Autenticar o acesso com a identidade gerida atribuída pelo utilizador

Depois de ativar a identidade gerida atribuída pelo utilizador para a sua conta de Automatização e conceder acesso de identidade ao recurso de destino, pode especificar essa identidade nos runbooks em relação aos recursos que suportam a identidade gerida. Para obter o suporte de identidades, utilize o 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

Gerar um token de acesso sem usar cmdlets do Azure

Para Pontos de extremidade HTTP, certifique-se do seguinte.

  • O cabeçalho dos metadados deve estar presente e deve ser definido como "true".
  • Um recurso deve ser passado junto com a solicitação, como um parâmetro de consulta para uma solicitação GET e como dados de formulário para uma solicitação POST.
  • Defina o valor da variável de ambiente IDENTITY_HEADER como X-IDENTITY-HEADER.
  • O tipo de conteúdo para a solicitação Post deve ser application/x-www-form-urlencoded.

Obter token de acesso para identidade gerenciada atribuída pelo usuário usando 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

Obter token de acesso para identidade gerenciada atribuída pelo usuário usando 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

Usando a identidade gerenciada atribuída pelo usuário no 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)  
}

Usando a identidade gerenciada atribuída pelo usuário no Python Runbook

#!/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)

Próximos passos

  • Se seus runbooks não forem concluídos com êxito, consulte Solucionar problemas de identidade gerenciada da Automação do Azure.

  • Se você precisar desabilitar uma identidade gerenciada, consulte Desabilitar sua identidade gerenciada de conta de Automação do Azure.

  • Para obter uma visão geral da segurança da conta de Automação do Azure, consulte Visão geral da autenticação de conta de automação.