Enviar e-mails a partir de um runbook da Automatização

Artigo
10/24/2023

Você pode enviar um email de um runbook com o SendGrid usando o PowerShell.

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

Pré-requisitos

Uma conta SendGrid.
Verificação do remetente do SendGrid. Domínio ou remetente único
Sua chave de API do SendGrid.
Uma conta da Automatização do Azure com, pelo menos, uma identidade gerida atribuída pelo utilizador. Para obter mais informações, consulte Habilitar identidades gerenciadas.
Módulos Az: Az.Accounts e Az.KeyVault importados para a conta de automação. Para mais informações, consulte Importar módulos Az.
O módulo Azure Az PowerShell instalado em sua máquina. Para instalar ou atualizar, consulte Como instalar o módulo Azure Az PowerShell.

Criar um Azure Key Vault

Crie uma política de acesso do Cofre da Chave do Azure e do Cofre da Chave que permita que a credencial obtenha e defina segredos do cofre da chave no cofre de chaves especificado.

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>

Forneça um valor apropriado para as variáveis abaixo e, em seguida, execute o script.

$resourceGroup = "<Resource group>"
$automationAccount = "<Automation account>"
$region = "<Region>"
$SendGridAPIKey = "<SendGrid API key>"
$VaultName = "<A universally unique vault name>"

$userAssignedManagedIdentity = "<User-assigned managed identity>"

Criar Cofre de Chaves e atribuir permissões

# Create the new key vault
$newKeyVault = New-AzKeyVault `
    -VaultName $VaultName `
    -ResourceGroupName $resourceGroup `
    -Location $region

$resourceId = $newKeyVault.ResourceId

# Convert the SendGrid API key into a SecureString
$Secret = ConvertTo-SecureString -String $SendGridAPIKey `
    -AsPlainText -Force

Set-AzKeyVaultSecret -VaultName $VaultName `
    -Name 'SendGridAPIKey' `
    -SecretValue $Secret

# Grant Key Vault access to the Automation account's system-assigned managed identity.
$SA_PrincipalId = (Get-AzAutomationAccount `
    -ResourceGroupName $resourceGroup `
    -Name $automationAccount).Identity.PrincipalId

Set-AzKeyVaultAccessPolicy `
    -VaultName $vaultName `
    -ObjectId $SA_PrincipalId `
    -PermissionsToSecrets Set, Get

# Grant Key Vault access to the user-assigned managed identity.
$UAMI = Get-AzUserAssignedIdentity `
    -ResourceGroupName $resourceGroup `
    -Name $userAssignedManagedIdentity

Set-AzKeyVaultAccessPolicy `
    -VaultName $vaultName `
    -ObjectId $UAMI.PrincipalId `
    -PermissionsToSecrets Set, Get

Para outras maneiras de criar um Cofre da Chave do Azure e armazenar um segredo, consulte Inícios rápidos do Cofre da Chave.

Atribuir permissões a identidades geridas

Atribua permissões à identidade gerenciada apropriada. O runbook pode usar a identidade gerenciada atribuída pelo sistema de conta de automação ou uma identidade gerenciada atribuída pelo usuário. São fornecidas etapas para atribuir permissões a cada identidade. As etapas abaixo usam o PowerShell. Se preferir usar o Portal, consulte Atribuir funções do Azure usando o portal do Azure.

Use o cmdlet do PowerShell New-AzRoleAssignment para atribuir uma função à identidade gerenciada atribuída ao sistema.

New-AzRoleAssignment `
    -ObjectId $SA_PrincipalId `
    -ResourceGroupName $resourceGroup `
    -RoleDefinitionName "Reader"

Atribua uma função a uma identidade gerenciada atribuída pelo usuário.

New-AzRoleAssignment `
    -ObjectId $UAMI.PrincipalId`
    -ResourceGroupName $resourceGroup `
    -RoleDefinitionName "Reader"

Para a identidade gerenciada atribuída ao sistema, mostre ClientId e registre o valor para uso posterior.
```
$UAMI.ClientId
```

Crie o runbook para enviar um e-mail

Depois de criar um Cofre de Chaves e armazenar sua SendGrid chave de API, é hora de criar o runbook que recupera a chave de API e envia um e-mail. Vamos usar um runbook que usa a identidade gerenciada atribuída ao sistema para autenticar com o Azure para recuperar o segredo do Cofre de Chaves do Azure. Vamos chamar o runbook de Send-GridMailMessage. Você pode modificar o script do PowerShell usado para diferentes cenários.

Inicie sessão no portal do Azure e navegue até à sua conta do Automatização.
Na página da conta de automação aberta, em Automação de processos, selecione Runbooks
Selecione + Criar um runbook.
1. Nomeie o runbook Send-GridMailMessage.
2. Na lista suspensa Tipo de runbook, selecione PowerShell.
3. Selecione Criar.
O runbook é criado e a página Editar Runbook do PowerShell é aberta.

Copie o exemplo do PowerShell a seguir para a página Editar. Certifique-se de que especifica VaultName o nome que escolheu para o Cofre da Chave.

Param(
  [Parameter(Mandatory=$True)]
  [String] $destEmailAddress,
  [Parameter(Mandatory=$True)]
  [String] $fromEmailAddress,
  [Parameter(Mandatory=$True)]
  [String] $subject,
  [Parameter(Mandatory=$True)]
  [String] $content,
  [Parameter(Mandatory=$True)]
  [String] $ResourceGroupName
)

# 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 

$VaultName = "<Enter your vault name>"

$SENDGRID_API_KEY = Get-AzKeyVaultSecret `
    -VaultName $VaultName `
    -Name "SendGridAPIKey" `
    -AsPlainText -DefaultProfile $AzureContext

$headers = New-Object "System.Collections.Generic.Dictionary[[String],[String]]"
$headers.Add("Authorization", "Bearer " + $SENDGRID_API_KEY)
$headers.Add("Content-Type", "application/json")

$body = @{
personalizations = @(
    @{
        to = @(
                @{
                    email = $destEmailAddress
                }
        )
    }
)
from = @{
    email = $fromEmailAddress
}
subject = $subject
content = @(
    @{
        type = "text/plain"
        value = $content
    }
)
}

$bodyJson = $body | ConvertTo-Json -Depth 4

$response = Invoke-RestMethod -Uri https://api.sendgrid.com/v3/mail/send -Method Post -Headers $headers -Body $bodyJson

Se você quiser que o runbook seja executado com a identidade gerenciada atribuída ao sistema, deixe o código como está. Se preferir usar uma identidade gerenciada atribuída pelo usuário, então:
1. Da linha 18, retire,$AzureContext = (Connect-AzAccount -Identity).context
2. Substitua-o por $AzureContext = (Connect-AzAccount -Identity -AccountId <ClientId>).context, e
3. Introduza o ID de Cliente obtido anteriormente.
Selecione Salvar, Publicar e, em seguida, Sim quando solicitado.

Para verificar se o runbook é executado com êxito, você pode seguir as etapas em Testar um runbook ou Iniciar um runbook.

Se você não vir inicialmente seu e-mail de teste, verifique suas pastas de Lixo e Spam .

Clean up resources (Limpar recursos)

Quando o runbook não for mais necessário, selecione-o na lista runbook e selecione Excluir.

Exclua o Cofre da Chave usando o cmdlet Remove-AzKeyVault .

$VaultName = "<your KeyVault name>"
$resourceGroup = "<your ResourceGroup name>"
Remove-AzKeyVault -VaultName $VaultName -ResourceGroupName $resourceGroup

Próximos passos

Para enviar dados de trabalho de runbook para seu espaço de trabalho do Log Analytics, consulte Encaminhar dados de trabalho de Automação do Azure para logs do Azure Monitor.
Para monitorar métricas e logs de nível básico, consulte Usar um alerta para disparar um runbook de Automação do Azure.

Partilhar via