Compartilhar via

Enviar um email de um runbook de Automação

  • Artigo

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

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

Pré-requisitos

Criar um Cofre de chaves do Azure

Crie um Azure Key Vault e uma política de acesso Key Vault que permita que a credencial obtenha e defina segredos do cofre de chaves no cofre de chaves especificado.

  1. Entre no Azure de modo interativo 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>

  2. 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>"

  3. Criar um Key Vault 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 ver outras maneiras de criar um Azure Key Vault e armazenar um segredo, confira os Guias de início rápido do Key Vault.

Atribuir permissões a identidades gerenciadas

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

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

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

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

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

  3. Para a identidade gerenciada atribuída pelo sistema, mostre ClientId e grave o valor para uso posterior.

    $UAMI.ClientId

Criar o runbook para enviar um email

Depois de criar um Key Vault e armazenar sua chave de API do SendGrid, é hora de criar o runbook que vai recuperar a chave de API e enviar um email. Vamos usar um runbook que usa a identidade gerenciada atribuída pelo sistema para autenticação com o Azure a fim de recuperar o segredo no Azure Key Vault. Vamos chamar o runbook de Send-GridMailMessage. Você pode modificar o script do PowerShell utilizado para diferentes cenários.

  1. Entre no portal do Azure e navegue até sua conta de Automação.

  2. Na página da sua conta de Automação aberta, em Automação de Processos, selecione Runbooks

  3. Selecione + Criar um runbook.

    1. Nomeie o runbook Send-GridMailMessage.
    2. Na lista suspensa Tipo de runbook, selecione PowerShell.
    3. Selecione Criar.

    Criar Runbook

  4. O runbook é criado e a página Editar Runbook do PowerShell é aberta. Editar o Runbook

  5. Copie o exemplo do PowerShell a seguir na página Editar. Verifique se o VaultName especifica o nome que você escolheu para o Key Vault.

    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

  6. Se você quiser que o runbook seja executado com a identidade gerenciada atribuída pelo sistema, deixe o código no estado em que se encontra. Se você preferir usar uma identidade gerenciada atribuída pelo usuário, então:

    1. Na linha 18, remova $AzureContext = (Connect-AzAccount -Identity).context,
    2. Substitua-o por $AzureContext = (Connect-AzAccount -Identity -AccountId <ClientId>).context e
    3. Insira a ID de cliente obtida anteriormente.

  7. Clique em Salvar, em Publicar e Sim quando solicitado.

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

Se você não vir inicialmente seu email de teste, verifique suas pastas de Lixo eletrônico e Spam.

Limpar os recursos

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

  2. Exclua o Key Vault usando o cmdlet Remove-AzKeyVault.

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

Próximas etapas