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

  • Artigo

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.

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

  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 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 gerenciadas

Atribua permissões à identidade gerenciada apropriada. O runbook pode usar a identidade gerenciada atribuída ao 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.

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

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

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

  2. Na página da 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.

    Create Runbook

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

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

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

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

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

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