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, Az.KeyVault.
Um recurso do Azure que você deseja acessar a partir do seu runbook de automação. Esse recurso precisa ter uma função definida para a identidade gerenciada, o que ajuda o runbook de automação a autenticar o acesso ao recurso. Para adicionar funções, você precisa ser um proprietário para o recurso no locatário correspondente do Microsoft Entra.
Se você quiser executar trabalhos híbridos usando uma identidade gerenciada, atualize o Hybrid Runbook Worker baseado em agente para a versão mais recente. Não há nenhum requisito de versão mínima para o Hybrid Runbook Worker baseado em extensão, e todas as versões funcionariam. As versões mínimas necessárias para o Trabalhador Híbrido baseado em agente são:
- Windows Hybrid Runbook Worker: versão 7.3.1125.0
- Linux Hybrid Runbook Worker: 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/writepermissã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.
| Propriedade (JSON) | Valor | Descrição |
|---|---|---|
| principalid | <ID principal> | O GUID (Identificador Globalmente Exclusivo) do objeto principal de serviço para a identidade gerenciada atribuída ao sistema que representa sua conta de automação no locatário do Microsoft Entra. Esse GUID às vezes aparece como um "object ID" ou objectID. |
| tenantid | <Azure-AD-tenant-ID> | O GUID (Identificador Globalmente Exclusivo) que representa o locatário do Microsoft Entra no qual a conta de Automação agora é membro. Dentro do locatário do Microsoft Entra, a entidade de serviço tem o mesmo nome que a conta de automação. |
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"
Importante
A nova identidade de nível de conta de automação substitui quaisquer identidades anteriores atribuídas ao sistema no nível de VM descritas em Usar autenticação de runbook com identidades gerenciadas. Se você estiver executando trabalhos híbridos em VMs do Azure que usam a identidade atribuída pelo sistema de uma VM para acessar recursos de runbook, a identidade da conta de Automação será usada para os trabalhos híbridos. Isso significa que sua execução de trabalho existente pode ser afetada se você estiver usando o recurso Chaves gerenciadas pelo cliente (CMK) de sua conta de automação.
Se desejar continuar usando a identidade gerenciada da VM, não habilite a identidade no nível da conta de automação. Se já o tiver ativado, pode desativar a identidade gerida atribuída pelo sistema à conta de automação. Consulte Desabilitar sua identidade gerenciada de conta de Automação do Azure.
Habilitar usando o portal do Azure
Efetue os seguintes passos:
Inicie sessão no portal do Azure.
No portal do Azure, navegue até sua conta de automação.
Em Definições da Conta, selecione Identidade.
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
Use o cmdlet do PowerShell Set-AzAutomationAccount para habilitar a identidade gerenciada 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, essa sintaxe removerá todas as identidades gerenciadas atribuídas pelo usuário associadas à conta de automação.
{
"identity": {
"type": "SystemAssigned"
}
}
Se houver várias identidades atribuídas pelo usuário definidas, para mantê-las e remover apenas a identidade atribuída pelo sistema, você precisará especificar cada identidade atribuída pelo usuário usando a lista delimitada por vírgula. O exemplo abaixo usa o método HTTP PATCH .
{
"identity" : {
"type": "SystemAssigned, UserAssigned",
"userAssignedIdentities": {
"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroupName/providers/Microsoft.ManagedIdentity/userAssignedIdentities/cmkID": {},
"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroupName/providers/Microsoft.ManagedIdentity/userAssignedIdentities/cmkID2": {}
}
}
}
A sintaxe da API é a seguinte:
PATCH 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.
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.Atualize o valor da variável abaixo e execute.
$file = "path\body_sa.json"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-JsonO resultado deve ser algo semelhante ao seguinte:
{ "PrincipalId": "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", "TenantId": "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb", "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, essa sintaxe removerá todas as identidades gerenciadas atribuídas pelo usuário 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.
Revise a sintaxe do modelo acima para usar sua conta de automação e salve-a em um arquivo chamado
template_sa.json.Atualize o valor da variável abaixo e execute.
$templateFile = "path\template_sa.json"Use o cmdlet do PowerShell New-AzResourceGroupDeployment para implantar o modelo.
New-AzResourceGroupDeployment ` -Name "SystemAssignedDeployment" ` -ResourceGroupName $resourceGroup ` -TemplateFile $templateFileO 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-JsonA 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 automação pode usar sua identidade gerenciada atribuída ao sistema 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 sistema 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.
O exemplo a seguir 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.
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 uma função para uma identidade gerida atribuída pelo sistema da conta de Automatização, siga estes passos:
Inicie sessão no portal do Azure.
Aceda à sua conta de Automatização.
Em Definições da Conta, selecione Identidade.
Em Permissões, clique em Atribuições de função 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.
Para alterar a assinatura, clique na lista suspensa Assinatura e selecione a assinatura apropriada.
Clique em Adicionar atribuição de função (Pré-visualização)
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.Na lista suspensa Função, selecione uma função como Colaborador de Máquina Virtual.
Clique em Guardar.
Após alguns minutos, a identidade gerenciada recebe a função no escopo 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 Connect-AzAccount Az. 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
Nota
Se sua organização ainda estiver usando os cmdlets AzureRM preteridos, você poderá usar Connect-AzureRMAccount -Identityo .
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 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)
}
Usando a identidade gerenciada atribuída ao 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 Microsoft Entra admin (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 gerenciada para sua autenticação de runbook, siga as etapas abaixo.
Habilite um sistema atribuído, atribuído pelo usuário ou ambos os tipos de identidades gerenciadas.
Conceda à identidade gerenciada os mesmos privilégios aos recursos do Azure correspondentes ao que a conta Run As foi atribuída.
Atualize seus runbooks para autenticar usando a identidade gerenciada.
Modifique Runbooks para usar a identidade gerenciada. Para suporte a identidades, use o cmdlet
Connect-AzAccountAz. Veja Connect-AzAccount na referência do PowerShell.- Se você estiver usando módulos do AzureRM, atualize
AzureRM.Profilepara a versão mais recente e substitua usandoAdd-AzureRMAccounto cmdlet peloConnect-AzureRMAccount –Identity. - Se você estiver usando módulos Az, atualize para a versão mais recente seguindo as etapas no artigo Atualizar módulos do Azure PowerShell.
- Se você estiver usando módulos do AzureRM, atualize
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.