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

Este artigo mostra como habilitar uma identidade gerenciada atribuída ao sistema 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.

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

Pré-requisitos

• Uma conta de Automatização do Azure. Para obter instruções, consulte Criar uma conta de Automação do Azure.

• A versão mais recente dos módulos Az PowerShell: Az.Accounts, Az.Resources, Az.Automation e Az.KeyVault.

• Um recurso do Azure que pretende aceder a partir do seu runbook de automatização. Este recurso precisa de ter uma função definida para a identidade gerida, o que ajuda o runbook de automação a autenticar o acesso ao recurso. Para adicionar funções, é necessário ser proprietário do recurso no locatário correspondente da Microsoft Entra.

• Não há um requisito de versão mínima para o Trabalhador de Runbook Híbrido baseado na extensão, e todas as versões funcionam. As versões mínimas necessárias para a Função de Trabalho Híbrida baseada em agente são:

  • Trabalhador Híbrido de Runbook do Windows: versão 7.3.1125.0
  • Trabalhador Híbrido de Runbook em Linux: versão 1.7.4.0

  Para verificar as versões:

  • Windows Hybrid Runbook Worker: Vá para o caminho de instalação - C:\ProgramFiles\Microsoft Monitoring Agent\Agent\AzureAutomation\. e a pasta Azure Automation contém uma subpasta com o número da versão como o nome da subpasta.
  • Linux Hybrid Runbook Worker: Vá para o caminho - vi/opt/microsoft/omsconfig/modules/nxOMSAutomationWorker/VERSION. e o arquivo VERSION tem o número da versão do Hybrid Worker.

• Para atribuir uma função do Azure, você deve ter Microsoft.Authorization/roleAssignments/write permissão, como Administrador de Acesso de Usuário ou Proprietário.

Habilitar uma identidade gerenciada atribuída ao sistema para uma conta de Automação do Azure

Uma vez habilitadas, as seguintes propriedades serão atribuídas à identidade gerenciada atribuída ao sistema.

Você pode habilitar uma identidade gerenciada atribuída ao sistema 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"

Habilitar 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. Defina a opção Sistema atribuído como Ativado e pressione Salvar. Quando lhe for pedido para confirmar, selecione Sim.

   

   Sua conta de automação agora pode usar a identidade atribuída ao sistema, que é registrada com a ID do Microsoft Entra e é representada por uma ID de objeto.

   

Ativar através do PowerShell

Utilize o cmdlet do PowerShell Set-AzAutomationAccount para ativar a identidade gerida atribuída ao sistema.

$output = Set-AzAutomationAccount `
    -ResourceGroupName $resourceGroup `
    -Name $automationAccount `
    -AssignSystemIdentity

$output

O resultado deve ser algo semelhante ao seguinte:

Para saída adicional, modifique o exemplo para especificar: $output.identity | ConvertTo-Json.

Habilitar o uso de uma API REST

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

Sintaxe

A sintaxe do corpo abaixo permite uma identidade gerenciada atribuída pelo sistema a uma conta de automação existente usando o método HTTP PATCH . No entanto, esta sintaxe removerá todas as identidades geridas atribuídas pelo utilizador associadas à conta de automação.

{ 
 "identity": { 
   "type": "SystemAssigned" 
  } 
}

Se estiverem definidas várias identidades atribuídas pelo utilizador, para mantê-las e remover apenas a identidade atribuída pelo sistema, será preciso especificar cada identidade atribuída pelo utilizador através de uma lista delimitada por vírgulas. O exemplo abaixo usa o método HTTP PATCH .

{ 
  "identity" : {
    "type": "SystemAssigned, UserAssigned",
    "userAssignedIdentities": {
        "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/resourceGroupName/providers/Microsoft.ManagedIdentity/userAssignedIdentities/cmkID": {},
        "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/resourceGroupName/providers/Microsoft.ManagedIdentity/userAssignedIdentities/cmkID2": {}
    }
  }
}

A sintaxe da API é a seguinte:

PATCH https://management.azure.com/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/resource-group-name/providers/Microsoft.Automation/automationAccounts/automation-account-name?api-version=2020-01-13-preview

Exemplo

Efetue os seguintes passos.

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

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

   $file = "path\body_sa.json"
   

3. Este exemplo utiliza o cmdlet Invoke-RestMethod do PowerShell para enviar a solicitação PATCH para a 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:

   {
       "PrincipalId":  "00a000aa-00a0-00aa-00aa-0a0aa000aa00",
       "TenantId":  "00a000aa-00a0-00aa-00aa-0a0aa000aa00",
       "Type":  0,
       "UserAssignedIdentities":  null
   }
   

Habilitar 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 permite uma identidade gerenciada atribuída pelo sistema à conta de automação existente. No entanto, esta sintaxe removerá todas as identidades geridas atribuídas pelo utilizador associadas à conta de automação.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "resources": [
    {
      "type": "Microsoft.Automation/automationAccounts",
      "apiVersion": "2020-01-13-preview",
      "name": "yourAutomationAccount",
      "location": "[resourceGroup().location]",
      "identity": {
        "type": "SystemAssigned"
        },
      "properties": {
        "sku": {
          "name": "Basic"
        }
      }
    }
  ]
}

Exemplo

Efetue os seguintes passos.

1. Revise a sintaxe do modelo acima para usar sua conta de automação e salve-a em um arquivo chamado template_sa.json.

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

   $templateFile = "path\template_sa.json"
   

3. Utilize o cmdlet do PowerShell New-AzResourceGroupDeployment para implantar o template.

   New-AzResourceGroupDeployment `
       -Name "SystemAssignedDeployment" `
       -ResourceGroupName $resourceGroup `
       -TemplateFile $templateFile
   

   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 a função a uma identidade gerida atribuída pelo sistema

Uma conta de Automatização pode utilizar a sua identidade gerida atribuída pelo sistema para obter tokens para aceder a 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 usar sua identidade gerenciada atribuída ao sistema para executar quaisquer ações no Azure, configure o acesso para essa identidade no recurso do Azure onde você planeja usar a identidade. Para concluir esta tarefa, atribua a função adequada a essa identidade no recurso do Azure de destino.

Siga o princípio de privilégios mínimos 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.

O exemplo seguinte utiliza o Azure PowerShell para mostrar como atribuir a função de Contribuidor na subscrição ao recurso do Azure de destino. A função de Contribuidor é utilizada como exemplo e pode ou não ser necessária no seu caso.

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 sistema

Para verificar um papel para uma identidade gerida pelo sistema atribuída à conta de Automatização, siga os seguintes passos:

1. Inicie sessão no portal do Azure.

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

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

   

4. Em Permissões, clique em Atribuições de funções do Azure.

   Se as funções já estiverem atribuídas à identidade gerida atribuída pelo sistema 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.

   

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 a que a atribuição de função se 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.

   

Após alguns minutos, a função é atribuída à identidade gerida no âmbito selecionado.

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

Depois de ativar a identidade gerida 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 suporte a identidades, use o cmdlet Az Connect-AzAccount. Veja Connect-AzAccount na referência do PowerShell.

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

# Connect to Azure with system-assigned managed identity
$AzureContext = (Connect-AzAccount -Identity).context

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

Gerar um token de acesso sem usar cmdlets do Azure

Para Endpoints HTTP, certifique-se do seguinte.

• O cabeçalho de 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 ao sistema usando HTTP Get

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

Obter token de acesso para identidade atribuída pelo sistema usando HTTP Post

$url = $env:IDENTITY_ENDPOINT  
$headers = New-Object "System.Collections.Generic.Dictionary[[String],[String]]" 
$headers.Add("X-IDENTITY-HEADER", $env:IDENTITY_HEADER) 
$headers.Add("Metadata", "True") 
$body = @{resource='https://management.azure.com/' } 
$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 sistema para acessar o Cofre da Chave do Azure no Azure PowerShell

Para obter mais informações, consulte Get-AzKeyVaultSecret.

Write-Output "Connecting to azure via  Connect-AzAccount -Identity" 
Connect-AzAccount -Identity 
Write-Output "Successfully connected with Automation account's Managed Identity" 
Write-Output "Trying to fetch value from key vault using MI. 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) 
}

Utilizar a identidade gerida atribuída pelo sistema no Python Runbook

#!/usr/bin/env python3 
import os 
import requests  
# printing environment variables 
endPoint = os.getenv('IDENTITY_ENDPOINT')+"?resource=https://management.azure.com/" 
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) 

Usando a identidade gerenciada atribuída pelo sistema ao Banco de Dados SQL do Access

Para obter detalhes sobre o provisionamento de acesso a um banco de dados SQL do Azure, consulte Provisionar o administrador do Microsoft Entra (Banco de Dados SQL).

$queryParameter = "?resource=https://database.windows.net/" 
$url = $env:IDENTITY_ENDPOINT + $queryParameter
$Headers = New-Object "System.Collections.Generic.Dictionary[[String],[String]]" 
$Headers.Add("X-IDENTITY-HEADER", $env:IDENTITY_HEADER) 
$Headers.Add("Metadata", "True") 
$content =[System.Text.Encoding]::Default.GetString((Invoke-WebRequest -UseBasicParsing -Uri $url -Method 'GET' -Headers $Headers).RawContentStream.ToArray()) | ConvertFrom-Json 
$Token = $content.access_token 
echo "The managed identities for Azure resources access token is $Token" 
$SQLServerName = "<ServerName>"    # Azure SQL logical server name  
$DatabaseName = "<DBname>"     # Azure SQL database name 
Write-Host "Create SQL connection string" 
$conn = New-Object System.Data.SqlClient.SQLConnection  
$conn.ConnectionString = "Data Source=$SQLServerName.database.windows.net;Initial Catalog=$DatabaseName;Connect Timeout=30" 
$conn.AccessToken = $Token 
Write-host "Connect to database and execute SQL script" 
$conn.Open()  
$ddlstmt = "CREATE TABLE Person( PersonId INT IDENTITY PRIMARY KEY, FirstName NVARCHAR(128) NOT NULL)" 
Write-host " " 
Write-host "SQL DDL command" 
$ddlstmt 
$command = New-Object -TypeName System.Data.SqlClient.SqlCommand($ddlstmt, $conn) 
Write-host "results" 
$command.ExecuteNonQuery() 
$conn.Close()

Migrar de contas Run As existentes para identidade gerenciada

A Automação do Azure forneceu autenticação para gerenciar recursos do Azure Resource Manager ou recursos implantados no modelo de implantação clássico com a conta Run As. Para mudar de uma conta Run As para uma identidade gerida para autenticação do runbook, siga as etapas abaixo.

1. Ative uma identidade gerida atribuída pelo sistema, atribuída pelo utilizador, ou ambos os tipos de identidades geridas.

2. Conceda à identidade gerenciada os mesmos privilégios aos recursos do Azure correspondentes ao que a conta Run As foi atribuída.

3. Atualize seus runbooks para autenticar usando a identidade gerenciada.

4. Modifique Runbooks para usar a identidade gerenciada. Para suporte a identidades, use o cmdlet Az Connect-AzAccount. Veja Connect-AzAccount na referência do PowerShell.

   • Se você estiver usando módulos do AzureRM, atualize AzureRM.Profile para a versão mais recente e substitua usando Add-AzureRMAccount o cmdlet pelo Connect-AzureRMAccount –Identity.
   • Se estiveres a usar módulos Az, atualiza para a versão mais recente seguindo as etapas no artigo Atualizar módulos Azure PowerShell.

Próximos passos

• Se os seus runbooks não forem concluídos com êxito, verifique Resolver problemas de identidade gerida no Azure Automation.

• 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.