Enviar um email usando os Serviços de Comunicação do Azure

Comece a usar os Serviços de Comunicação do Azure com o recurso "Try Email" para enviar mensagens de email.

Pré-requisitos

• Uma conta do Azure com uma assinatura ativa. Crie uma conta gratuitamente.
• A versão mais recente da biblioteca de clientes do .NET Core para o seu sistema operacional.
• Um recurso dos Serviços de Comunicação por Email do Azure criado e pronto com um domínio provisionado Introdução à criação do recurso de comunicação por email
• Um recurso ativo dos Serviços de Comunicação conectado ao Domínio de Email. Conecte um domínio de email verificado para enviar email.

A conclusão deste artigo gera um pequeno custo de alguns centavos de USD ou menos em sua conta do Azure.

Enviar um email usando o Try Email

Experimentar o Email ajuda você a iniciar o envio de emails para os destinatários desejados usando os Serviços de Comunicação do Azure e a verificar a configuração do aplicativo para enviar emails. Ele também ajuda a iniciar o desenvolvimento de notificação por email com o snippet de código em sua escolha preferida de idioma.

Para enviar uma mensagem a um destinatário e especificar o assunto e o corpo da mensagem:

1. Na página de visão geral de um recurso provisionado do Serviço de Comunicação do Azure, clique em Experimentar Email no painel de navegação esquerdo em Email.

   

2. Selecione um dos domínios verificados na lista suspensa.

   

3. Redigir o email a ser enviado.

   • Insira o endereço de email do destinatário
   • Inserir Assunto
   • Gravar o corpo do email

   

4. Clique em Enviar.

   

5. Email enviado com êxito.

   

6. Você também pode copiar a amostra de snippet de código para enviar um email e usá-lo no seu projeto de exemplo a fim de enviar notificações.

   • Selecione Idioma de sua escolha

   • Clique em Inserir minha Conexão

   • Clique em Copiar

     

7. O Snippet de Código de Email agora está pronto para ser usado em seu projeto de notificação.

Comece a usar os Serviços de Comunicação do Azure por meio da extensão de comunicação da CLI do Azure para enviar mensagens de email.

A conclusão deste artigo gera um pequeno custo de alguns centavos de USD ou menos em sua conta do Azure.

Pré-requisitos

• Uma conta do Azure com uma assinatura ativa. Crie uma conta gratuitamente.
• Um recurso dos Serviços de Comunicação por Email do Azure criado e pronto com um domínio provisionado. Criar um recurso de comunicação por email.
• Um recurso ativo dos Serviços de Comunicação do Azure conectado a um domínio de email e á respectiva cadeia de conexão. Conecte um domínio de email verificado para enviar email.
• A CLI do Azure mais recente.

Verificação de pré-requisitos

• Em um terminal ou janela de comando, execute o comando az --version para verificar se a CLI do Azure e a extensão de comunicação estão instaladas.
• Para ver os domínios verificados com o recurso dos Serviços de Comunicação por Email, entre no portal do Azure. Localize o recurso dos Serviços de Comunicação por Email e abra a guia Provisionar domínios no painel de navegação à esquerda.

Configurando

Adicionar a extensão

Adicione a extensão dos Serviços de Comunicação do Azure para a CLI do Azure usando o comando az extension.

az extension add --name communication

Entrar na CLI do Azure

Será necessário entrar na CLI do Azure. Para se conectar, execute o comando az login no terminal e forneça suas credenciais.

Armazenar a sua cadeia de conexão em uma variável de ambiente

Você pode configurar a variável de ambiente AZURE_COMMUNICATION_CONNECTION_STRING para usar operações de chaves da CLI do Azure sem precisar usar --connection_string para passar a cadeia de conexão. Para configurar uma variável de ambiente, abra uma janela de console e selecione seu sistema operacional nas seguintes guias. Substitua <connectionString> pela cadeia de conexão real.

setx AZURE_COMMUNICATION_CONNECTION_STRING "<yourConnectionString>"

export AZURE_COMMUNICATION_CONNECTION_STRING="<connectionString>"

export AZURE_COMMUNICATION_CONNECTION_STRING="<connectionString>"

Enviar uma mensagem de email

az communication email send
	--connection-string "yourConnectionString"
	--sender "<donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net>"
	--to "<emailalias@emaildomain.com>"
	--subject "Welcome to Azure Communication Services Email" --text "This email message is sent from Azure Communication Services Email using Azure CLI." 

Faça estas substituições no código:

• Substitua <yourConnectionString> por sua cadeia de conexão.
• Substitua <emailalias@emaildomain.com> pelo endereço de email para o qual deseja enviar uma mensagem.
• Substitua <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> pelo endereço MailFrom do domínio verificado.

Este comando também realiza uma consulta no messageId e retorna o status da entrega de email. O status pode ser um dos seguintes valores:

Parâmetros opcionais

Os parâmetros opcionais a seguir estão disponíveis na CLI do Azure.

• O --html pode ser usado em vez do --text para o corpo do email HTML.

• O --importance define o tipo de importância do email. Os valores conhecidos são: alto, normal e baixo. O padrão é o normal.

• --to define a lista de destinatários de email.

• O --cc define os endereços de email de cópia carbono.

• O --bcc define os endereços de email de cópia oculta.

• O --reply-to define o endereço de email de resposta.

• --disable-tracking indica se o acompanhamento de envolvimento do usuário deve ser desabilitado para essa solicitação.

• O --attachments define a lista de anexos de email.

• O --attachment-types define a lista de tipos de anexos de email, na mesma ordem dos anexos.

Você também pode usar uma lista de destinatários com --cc e --bcc semelhante a --to. Precisa haver pelo menos um destinatário dentro --to, --cc ou --bcc.

Comece a usar os Serviços de Comunicação do Azure usando a biblioteca de clientes de email do C# dos Serviços de Comunicação para enviar mensagens por email.

Noções básicas sobre o modelo de Objeto de E-mail

As classes e as interfaces a seguir lidam com alguns dos principais recursos da biblioteca de clientes de Email dos Serviços de Comunicação do Azure para C#.

EmailSendResult retorna o seguinte status na operação de e-mail executada.

Pré-requisitos

• Uma conta do Azure com uma assinatura ativa. Crie uma conta gratuitamente.
• A versão mais recente da biblioteca de clientes do .NET Core para o seu sistema operacional.
• Um recurso dos Serviços de Comunicação de Email do Azure criado e pronto com um domínio provisionado Criar Recurso de Comunicação de Email.
• Um recurso ativo dos Serviços de Comunicação conectado com o Domínio de Email e uma Cadeia de Conexão. Criar e gerenciar recursos do Serviço de Comunicação de Email.

A conclusão deste artigo gera um pequeno custo de alguns centavos de USD ou menos em sua conta do Azure.

Verificação de pré-requisitos

• Em um terminal ou janela de comando, execute o comando dotnet para verificar se a biblioteca de clientes do .NET está instalada.
• Para exibir os subdomínios associados ao seu recurso dos Serviços de Comunicação por Email, entre no portal do Azure, localize o recurso em questão e abra a guia Provisionar domínios no painel de navegação esquerdo.

Criar um aplicativo em C#

Em uma janela de console (como cmd, PowerShell ou Bash), use o comando dotnet new para criar um novo aplicativo do console com o nome EmailQuickstart. Esse comando cria um projeto simples em C# do tipo "Olá, Mundo" com um arquivo de origem único: Program.cs.

dotnet new console -o EmailQuickstart

Altere o seu diretório para a pasta de aplicativo recém-criada e use o comando dotnet build para compilar o seu aplicativo.

cd EmailQuickstart
dotnet build

Instalar o pacote

Ainda no diretório do aplicativo, instale o pacote da biblioteca de clientes de Email dos Serviços de Comunicação do Azure para .NET usando o comando dotnet add package.

dotnet add package Azure.Communication.Email

Criar o cliente de email com autenticação

Abra Program.cs e substitua o código existente pelo seguinte para adicionar using diretivas para incluir o Azure.Communication.Email namespace e um ponto de partida para execução do programa.

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

using Azure;
using Azure.Communication.Email;

namespace SendEmail
{
  internal class Program
  {
    static async Task Main(string[] args)
    {

    }
  }
}

Existem algumas opções diferentes disponíveis para autenticar um cliente de email:

// This code demonstrates how to fetch your connection string
// from an environment variable.
string connectionString = Environment.GetEnvironmentVariable("COMMUNICATION_SERVICES_CONNECTION_STRING");
EmailClient emailClient = new EmailClient(connectionString);

dotnet add package Azure.Identity

// This code demonstrates how to authenticate to your Communication Service resource using
// DefaultAzureCredential and the environment variables AZURE_CLIENT_ID, AZURE_TENANT_ID,
// and AZURE_CLIENT_SECRET.
string resourceEndpoint = "<ACS_RESOURCE_ENDPOINT>";
EmailClient emailClient = new EmailClient(new Uri(resourceEndpoint), new DefaultAzureCredential());

var key = new AzureKeyCredential("<your-key-credential>");
var endpoint = new Uri("<your-endpoint-uri>");

var emailClient = new EmailClient(endpoint, key);

//Replace with your ___domain and modify the content, recipient details as required

var subject = "Welcome to Azure Communication Service Email APIs.";
var htmlContent = "<html><body><h1>Quick send email test</h1><br/><h4>This email message is sent from Azure Communication Service Email.</h4><p>This mail was sent using .NET SDK!!</p></body></html>";
var sender = "donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net";
var recipient = "emailalias@contoso.com";

/// Send the email message with WaitUntil.Started
EmailSendOperation emailSendOperation = await emailClient.SendAsync(
    Azure.WaitUntil.Started,
    sender,
    recipient,
    subject,
    htmlContent);

/// Call UpdateStatus on the email send operation to poll for the status
/// manually.
try
{
    while (true)
    {
        await emailSendOperation.UpdateStatusAsync();
        if (emailSendOperation.HasCompleted)
        {
            break;
        }
        await Task.Delay(100);
    }

    if (emailSendOperation.HasValue)
    {
        Console.WriteLine($"Email queued for delivery. Status = {emailSendOperation.Value.Status}");
    }
}
catch (RequestFailedException ex)
{
    Console.WriteLine($"Email send failed with Code = {ex.ErrorCode} and Message = {ex.Message}");
}

/// Get the OperationId so that it can be used for tracking the message for troubleshooting
string operationId = emailSendOperation.Id;
Console.WriteLine($"Email operation id = {operationId}");

dotnet run

//Replace with your ___domain and modify the content, recipient details as required

var subject = "Welcome to Azure Communication Service Email APIs.";
var htmlContent = "<html><body><h1>Quick send email test</h1><br/><h4>This email message is sent from Azure Communication Service Email.</h4><p>This mail was sent using .NET SDK!!</p></body></html>";
var sender = "donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net";
var recipient = "emailalias@contoso.com";

try
{
    Console.WriteLine("Sending email...");
    EmailSendOperation emailSendOperation = await emailClient.SendAsync(
        Azure.WaitUntil.Completed,
        sender,
        recipient,
        subject,
        htmlContent);
    EmailSendResult statusMonitor = emailSendOperation.Value;

    Console.WriteLine($"Email Sent. Status = {emailSendOperation.Value.Status}");

    /// Get the OperationId so that it can be used for tracking the message for troubleshooting
    string operationId = emailSendOperation.Id;
    Console.WriteLine($"Email operation id = {operationId}");
}
catch (RequestFailedException ex)
{
    /// OperationID is contained in the exception message and can be used for troubleshooting purposes
    Console.WriteLine($"Email send operation failed with error code: {ex.ErrorCode}, message: {ex.Message}");
}

dotnet run

Comece a usar os Serviços de Comunicação do Azure usando a biblioteca de clientes de Email JavaScript dos Serviços de Comunicação para enviar mensagens de email.

Entender o modelo de objeto de email

As classes e interfaces a seguir lidam com alguns recursos da biblioteca cliente de email dos Serviços de Comunicação do Azure para JavaScript.

EmailSendResult retorna o seguinte status na operação de e-mail executada.

Pré-requisitos

• Node.js (~14).
• Uma conta do Azure com uma assinatura ativa. Crie uma conta gratuitamente.
• Um recurso dos Serviços de Comunicação por Email do Azure criado e pronto com um domínio provisionado. Criar um recurso de comunicação por email.
• Um recurso ativo dos Serviços de Comunicação do Azure conectado a um domínio de email e á respectiva cadeia de conexão. Criar e gerenciar recursos do Serviço de Comunicação de Email.

A conclusão deste artigo gera um pequeno custo de alguns centavos de USD ou menos em sua conta do Azure.

Verificação de pré-requisitos

• Em uma janela de terminal ou de comando, execute node --version para verificar se o Node.js está instalado.
• Para exibir os domínios verificados com seu recurso dos Serviços de Comunicação por Email, entre no portal do Azure, localize o recurso em questão e abra a guia Provisionar domínios no painel de navegação esquerdo.

Configurar o ambiente do aplicativo

Criar um aplicativo Node.js

Primeiro, abra o terminal ou a janela de comando. Em seguida, crie um novo diretório para seu aplicativo e navegue até ele.

mkdir email-quickstart && cd email-quickstart

Execute npm init -y para criar um arquivo package.json com as configurações padrão.

npm init -y

Use um editor de texto para criar um arquivo chamado send-email.js no diretório raiz do projeto. Altere a propriedade main em package.json para send-email.js. A seção a seguir demonstra como adicionar o código-fonte deste artigo ao arquivo recém-criado.

Instalar o pacote

Use o comando npm install para instalar a biblioteca de clientes de Email dos Serviços de Comunicação do Azure para JavaScript.

npm install @azure/communication-email --save

A opção --save lista a biblioteca como uma dependência no arquivo package.json.

Criar o cliente de email com autenticação

Existem algumas opções diferentes disponíveis para autenticar um cliente de email:

npm install dotenv

const { EmailClient } = require("@azure/communication-email");
require("dotenv").config();

// This code demonstrates how to fetch your connection string
// from an environment variable.
const connectionString = process.env['COMMUNICATION_SERVICES_CONNECTION_STRING'];
const emailClient = new EmailClient(connectionString);

npm install @azure/identity

import { DefaultAzureCredential } from "@azure/identity";
import { EmailClient } from "@azure/communication-email";

const endpoint = "https://<resource-name>.communication.azure.com";
let credential = new DefaultAzureCredential();

const emailClient = new EmailClient(endpoint, credential);

const { EmailClient, KnownEmailSendStatus } = require("@azure/communication-email");
const { AzureKeyCredential } = require("@azure/core-auth");
require("dotenv").config();

var key = new AzureKeyCredential("<your-key-credential>");
var endpoint = "<your-endpoint-uri>";

const emailClient = new EmailClient(endpoint, key);

Para simplificar, este artigo usa cadeias de conexão, mas em ambientes de produção, recomendamos usar principais de serviço.

Envio de e-mail básico

Enviar uma mensagem de email

Para enviar uma mensagem de email, chame a função beginSend do EmailClient. Esse método retorna um sondador que verifica o status da operação e recupera o resultado após a conclusão.

async function main() {
  const POLLER_WAIT_TIME = 10
  try {
    const message = {
      senderAddress: "<donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net>",
      content: {
        subject: "Welcome to Azure Communication Services Email",
        plainText: "This email message is sent from Azure Communication Services Email using the JavaScript SDK.",
      },
      recipients: {
        to: [
          {
            address: "<emailalias@emaildomain.com>",
            displayName: "Customer Name",
          },
        ],
      },
    };

    const poller = await emailClient.beginSend(message);

    if (!poller.getOperationState().isStarted) {
      throw "Poller was not started."
    }

    let timeElapsed = 0;
    while(!poller.isDone()) {
      poller.poll();
      console.log("Email send polling in progress");

      await new Promise(resolve => setTimeout(resolve, POLLER_WAIT_TIME * 1000));
      timeElapsed += 10;

      if(timeElapsed > 18 * POLLER_WAIT_TIME) {
        throw "Polling timed out.";
      }
    }

    if(poller.getResult().status === KnownEmailSendStatus.Succeeded) {
      console.log(`Successfully sent the email (operation id: ${poller.getResult().id})`);
    }
    else {
      throw poller.getResult().error;
    }
  } catch (e) {
    console.log(e);
  }
}

main();

Faça estas substituições no código:

• Substitua <emailalias@emaildomain.com> pelo endereço de email para o qual deseja enviar uma mensagem.
• Substitua <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> pelo endereço MailFrom do domínio verificado.

Executar o código

Use o comando 'node' para executar o código que você adicionou ao arquivo send-email.js.

node ./send-email.js

Código de exemplo

Você pode baixar o aplicativo de exemplo no GitHub Azure Samples Send Email for JavaScript.

Comece a usar os Serviços de Comunicação do Azure usando o SDK de Email dos Serviços de Comunicação para Java a fim de enviar mensagens de email.

Entender o modelo de objeto de email

As classes e interfaces a seguir lidam com alguns dos principais recursos do SDK de Email dos Serviços de Comunicação do Azure para Java.

EmailSendResult retorna o seguinte status na operação de e-mail executada.

Pré-requisitos

• Uma conta do Azure com uma assinatura ativa. Crie uma conta gratuitamente.
• JDK (Java Development Kit) versão 8 ou superior.
• Apache Maven.
• Um recurso e uma cadeia de conexão dos Serviços de Comunicação implantados. Para mais detalhes, acesse Criar um recurso dos Serviços de Comunicação do Azure.
• Para começar a enviar emails, crie um recurso dos Serviços de Comunicação de Email do Azure.
• Uma identidade gerenciada de configuração para um ambiente de desenvolvimento, acesse Autorizar o acesso com identidade gerenciada.

A conclusão deste artigo gera um pequeno custo de alguns centavos de USD ou menos em sua conta do Azure.

Verificação de pré-requisitos

• Em um terminal ou janela de comando, execute mvn -v para verificar se o Maven está instalado.
• Para ver os domínios verificados com o recurso dos Serviços de Comunicação por Email, entre no portal do Azure. Localize o recurso dos Serviços de Comunicação de email e abra a guia Provisionar domínios no painel de navegação esquerdo.

Configurar o ambiente do aplicativo

Para configurar um ambiente para o envio de emails, siga as etapas das seções a seguir.

Criar um aplicativo Java

Abra o terminal ou a janela de comando e navegue até o diretório no qual você deseja criar o seu aplicativo Java. Execute o comando abaixo para gerar o projeto Java a partir do modelo maven-archetype-quickstart.

mvn archetype:generate -DarchetypeArtifactId="maven-archetype-quickstart" -DarchetypeGroupId="org.apache.maven.archetypes" -DarchetypeVersion="1.4" -DgroupId="com.communication.quickstart" -DartifactId="communication-quickstart"

A meta generate cria um diretório com o mesmo nome do valor artifactId. Nesse diretório, o diretório src/main/java contém o código-fonte do projeto, o diretório src/test/java contém a fonte de teste e o arquivo pom.xml é o POM (Modelo de Objeto do Projeto) do projeto.

Instalar o pacote

Abra o arquivo pom.xml no seu editor de texto. Adicione o seguinte elemento de dependência ao grupo de dependências.

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-communication-email</artifactId>
    <version>1.0.0-beta.2</version>
</dependency>

Configurar o framework de aplicativos

Abra /src/main/java/com/communication/quickstart/App.java em um editor de texto, adicione diretivas de importação e remova a instrução System.out.println("Hello world!");:

package com.communication.quickstart;

import com.azure.communication.email.models.*;
import com.azure.communication.email.*;
import com.azure.core.util.polling.*;

public class App
{
    public static void main( String[] args )
    {
        // Quickstart code goes here.
    }
}

Criando o cliente de e-mail com autenticação

Existem algumas opções diferentes disponíveis para autenticar um cliente de email.

// You can get your connection string from your resource in the Azure portal.
String connectionString = "endpoint=https://<resource-name>.communication.azure.com/;accesskey=<access-key>";

EmailClient emailClient = new EmailClientBuilder()
    .connectionString(connectionString)
    .buildClient();

// You can get your connection string from your resource in the Azure portal.
String connectionString = "endpoint=https://<resource-name>.communication.azure.com/;accesskey=<access-key>";

EmailAsyncClient emailClient = new EmailClientBuilder()
    .connectionString(connectionString)
    .buildAsyncClient();

// You can find your endpoint and access key from your resource in the Azure portal
String endpoint = "https://<resource-name>.communication.azure.com/";
EmailClient emailClient = new EmailClientBuilder()
    .endpoint(endpoint)
    .credential(new DefaultAzureCredentialBuilder().build())
    .buildClient();

// You can find your endpoint and access key from your resource in the Azure portal
String endpoint = "https://<resource-name>.communication.azure.com/";
EmailAsyncClient emailClient = new EmailClientBuilder()
    .endpoint(endpoint)
    .credential(new DefaultAzureCredentialBuilder().build())
    .buildAsyncClient();

String endpoint = "https://<resource-name>.communication.azure.com";
AzureKeyCredential azureKeyCredential = new AzureKeyCredential("<access-key>");
EmailClient emailClient = new EmailClientBuilder()
    .endpoint(endpoint)
    .credential(azureKeyCredential)
    .buildClient();

String endpoint = "https://<resource-name>.communication.azure.com";
AzureKeyCredential azureKeyCredential = new AzureKeyCredential("<access-key>");
EmailClient emailClient = new EmailClientBuilder()
    .endpoint(endpoint)
    .credential(azureKeyCredential)
    .buildClient();

Para simplificar, este artigo usa cadeias de conexão, mas em ambientes de produção, recomendamos usar principais de serviço.

Envio de e-mail básico

Você pode redigir uma mensagem de email usando o EmailMessage objeto no SDK.

EmailMessage message = new EmailMessage()
    .setSenderAddress("<donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net>")
    .setToRecipients("<emailalias@emaildomain.com>")
    .setSubject("Welcome to Azure Communication Services Email")
    .setBodyPlainText("This email message is sent from Azure Communication Services Email using the Java SDK.");

Faça estas substituições no código:

• Substitua <emailalias@emaildomain.com> pelo endereço de email para o qual deseja enviar uma mensagem.
• Substitua <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> pelo endereço MailFrom do domínio verificado.

Para enviar um e-mail, chame a função beginSend do EmailClient.

Duration MAIN_THREAD_WAIT_TIME = Duration.ofSeconds(30);

// ExecutorService to run the polling in a separate thread
ExecutorService executorService = Executors.newSingleThreadExecutor();

PollerFlux<EmailSendResult, EmailSendResult> poller = emailAsyncClient.beginSend(emailMessage);

executorService.submit(() -> {
    // The initial request is sent out as soon as we subscribe the to PollerFlux object
    poller.subscribe(
        response -> {
            if (response.getStatus() == LongRunningOperationStatus.SUCCESSFULLY_COMPLETED) {
                System.out.printf("Successfully sent the email (operation id: %s)\n", response.getValue().getId());
            }
            else {
                // The operation ID can be retrieved as soon as the first response is received from the PollerFlux.
                System.out.println("Email send status: " + response.getStatus() + ", operation id: " + response.getValue().getId());
            }
        },
        error -> {
            System.out.println("Error occurred while sending email: " + error.getMessage());
        }
    );
});

// In a real application, you might have a mechanism to keep the main thread alive.
// For this sample we will keep the main thread alive for 30 seconds to make sure the child thread has time to receive the SUCCESSFULLY_COMPLETED status.
try {
    Thread.sleep(MAIN_THREAD_WAIT_TIME.toMillis());
} catch (InterruptedException e) {
    e.printStackTrace();
}

executorService.shutdown();
System.out.println("Main thread ends.");

try
{
    SyncPoller<EmailSendResult, EmailSendResult> poller = emailClient.beginSend(message, null); // This will send out the initial request to send an email

    PollResponse<EmailSendResult> pollResponse = null;

    Duration timeElapsed = Duration.ofSeconds(0);
    Duration POLLER_WAIT_TIME = Duration.ofSeconds(10);

    // Polling is done manually to avoid blocking the application in case of an error
    while (pollResponse == null
            || pollResponse.getStatus() == LongRunningOperationStatus.NOT_STARTED
            || pollResponse.getStatus() == LongRunningOperationStatus.IN_PROGRESS)
    {
        pollResponse = poller.poll();
        // The operation ID can be retrieved as soon as .poll() is called on the poller
        System.out.println("Email send poller status: " + pollResponse.getStatus() + ", operation id: " + pollResponse.getValue().getId());

        Thread.sleep(POLLER_WAIT_TIME.toMillis());
        timeElapsed = timeElapsed.plus(POLLER_WAIT_TIME);

        if (timeElapsed.compareTo(POLLER_WAIT_TIME.multipliedBy(18)) >= 0)
        {
            throw new RuntimeException("Polling timed out.");
        }
    }

    if (poller.getFinalResult().getStatus() == EmailSendStatus.SUCCEEDED)
    {
        System.out.printf("Successfully sent the email (operation id: %s)", poller.getFinalResult().getId());
    }
    else
    {
        throw new RuntimeException(poller.getFinalResult().getError().getMessage());
    }
}
catch (Exception exception)
{
    System.out.println(exception.getMessage());
}

Executar o código

1. Navegue até o diretório que contém o pom.xml arquivo e compile o projeto usando o mvn comando.

   mvn compile
   

2. Compile o pacote.

   mvn package
   

3. Execute o comando a seguir mvn para iniciar o aplicativo.

   mvn exec:java -D"exec.mainClass"="com.communication.quickstart.App" -D"exec.cleanupDaemonThreads"="false"
   

Código de exemplo

Você pode baixar o aplicativo de exemplo no GitHub Azure Samples Send Email for Java

Comece a usar os Serviços de Comunicação do Azure usando o SDK de Email dos Serviços de Comunicação para Python a fim de enviar mensagens de email.

Noções básicas sobre o modelo de objeto de e-mail

O objeto de resposta e modelo de mensagem JSON a seguir demonstra alguns dos principais recursos do SDK de Email dos Serviços de Comunicação do Azure para Python.

message = {
    "content": {
        "subject": "str",  # Subject of the email message. Required.
        "html": "str",  # Optional. Html version of the email message.
        "plainText": "str"  # Optional. Plain text version of the email
            message.
    },
    "recipients": {
        "to": [
            {
                "address": "str",  # Email address. Required.
                "displayName": "str"  # Optional. Email display name.
            }
        ],
        "bcc": [
            {
                "address": "str",  # Email address. Required.
                "displayName": "str"  # Optional. Email display name.
            }
        ],
        "cc": [
            {
                "address": "str",  # Email address. Required.
                "displayName": "str"  # Optional. Email display name.
            }
        ]
    },
    "senderAddress": "str",  # Sender email address from a verified ___domain. Required.
    "attachments": [
        {
            "contentInBase64": "str",  # Base64 encoded contents of the attachment. Required.
            "contentType": "str",  # MIME type of the content being attached. Required.
            "name": "str"  # Name of the attachment. Required.
        }
    ],
    "userEngagementTrackingDisabled": bool,  # Optional. Indicates whether user engagement tracking should be disabled for this request if the resource-level user engagement tracking setting was already enabled in the control plane.
    "headers": {
        "str": "str"  # Optional. Custom email headers to be passed.
    },
    "replyTo": [
        {
            "address": "str",  # Email address. Required.
            "displayName": "str"  # Optional. Email display name.
        }
    ]
}

response = {
    "id": "str",  # The unique id of the operation. Uses a UUID. Required.
    "status": "str",  # Status of operation. Required. Known values are:
        "NotStarted", "Running", "Succeeded", and "Failed".
    "error": {
        "additionalInfo": [
            {
                "info": {},  # Optional. The additional info.
                "type": "str"  # Optional. The additional info type.
            }
        ],
        "code": "str",  # Optional. The error code.
        "details": [
            ...
        ],
        "message": "str",  # Optional. The error message.
        "target": "str"  # Optional. The error target.
    }
}

Os response.status valores são explicados ainda mais na tabela a seguir.

Pré-requisitos

• Uma conta do Azure com uma assinatura ativa. Crie uma conta gratuitamente.
• Python 3.7+.
• Um recurso dos Serviços de Comunicação por Email do Azure criado e pronto com um domínio provisionado. Criar um recurso de comunicação por email.
• Um recurso ativo dos Serviços de Comunicação do Azure conectado a um domínio de email e á respectiva cadeia de conexão. Conecte um domínio de email verificado para enviar email.

A conclusão deste artigo gera um pequeno custo de alguns centavos de USD ou menos em sua conta do Azure.

Verificação de pré-requisitos

• Em um terminal ou em uma janela de comando, execute o comando python --version para verificar se o Python está instalado.
• Para ver os domínios verificados com o recurso dos Serviços de Comunicação por Email, entre no portal do Azure. Localize o recurso dos Serviços de Comunicação por Email e abra a guia Provisionar domínios no painel de navegação à esquerda.

Configurar o ambiente do aplicativo

Para configurar um ambiente para o envio de emails, siga as etapas das seções a seguir.

Criar um novo aplicativo Python

1. Abra o terminal ou a janela Comando. Em seguida, use o comando a seguir para criar um ambiente virtual e ativá-lo. Esse comando cria um novo diretório para seu aplicativo.

   python -m venv email-quickstart
   

2. Navegue até o diretório raiz do ambiente virtual e ative-o usando os comandos a seguir.

   cd email-quickstart
   .\Scripts\activate
   

3. Use um editor de texto para criar um arquivo chamado send-email.py no diretório raiz do projeto e adicione a estrutura do programa, incluindo o tratamento de exceção básico.

   import os
   from azure.communication.email import EmailClient
   
   try:
       # Quickstart code goes here.
   except Exception as ex:
       print('Exception:')
       print(ex)
   

Nas seções a seguir, você adicionará todo o código-fonte deste guia de início rápido ao arquivo send-email.py que acabou de criar.

Instalar o pacote

Ainda no diretório do aplicativo, instale o pacote do SDK de Email dos Serviços de Comunicação do Azure para Python usando o comando a seguir.

pip install azure-communication-email

Criando o cliente de e-mail com autenticação

Existem algumas opções diferentes disponíveis para autenticar um cliente de email:

# Create the EmailClient object that you use to send Email messages.
email_client = EmailClient.from_connection_string(<connection_string>)

from azure.communication.email import EmailClient
from azure.identity import DefaultAzureCredential

# To use Azure Active Directory Authentication (DefaultAzureCredential) make sure to have AZURE_TENANT_ID, AZURE_CLIENT_ID and AZURE_CLIENT_SECRET as env variables.
endpoint = "https://<resource-name>.communication.azure.com"
email_client = EmailClient(endpoint, DefaultAzureCredential())

from azure.communication.email import EmailClient
from azure.core.credentials import AzureKeyCredential

key = AzureKeyCredential("<your-key-credential>");
endpoint = "<your-endpoint-uri>";

email_client = EmailClient(endpoint, key);

Para simplificar, este artigo usa cadeias de conexão, mas em ambientes de produção, recomendamos usar principais de serviço.

Envio de e-mail básico

Enviar uma mensagem de email

Para enviar uma mensagem de e-mail, você precisa:

• Construa a mensagem com os seguintes valores:
  • senderAddress: Um endereço de e-mail de remetente válido, encontrado no campo MailFrom no painel de visão geral do domínio vinculado ao recurso dos Serviços de Comunicação E-mail.
  • recipients: um objeto com uma lista de destinatários de email e, opcionalmente, listas de destinatários de email em CC e CCO.
  • content: Um objeto que contém o assunto e, opcionalmente, o texto sem formatação ou conteúdo HTML de uma mensagem de e-mail.
• Chame o begin_send método, que retorna o resultado da operação.

message = {
    "content": {
        "subject": "This is the subject",
        "plainText": "This is the body",
        "html": "<html><h1>This is the body</h1></html>"
    },
    "recipients": {
        "to": [
            {
                "address": "<emailalias@emaildomain.com>",
                "displayName": "Customer Name"
            }
        ]
    },
    "senderAddress": "<donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net>"
}

poller = email_client.begin_send(message)
print("Result: " + poller.result())

Faça estas substituições no código:

• Substitua <emailalias@emaildomain.com> pelo endereço de email para o qual deseja enviar uma mensagem.
• Substitua <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> pelo endereço MailFrom do domínio verificado.

Obter o status da entrega de email

Podemos sondar o status da entrega de email definindo um loop no objeto de status da operação retornado do método begin_send de EmailClient:

POLLER_WAIT_TIME = 10

try:
    email_client = EmailClient.from_connection_string(connection_string)

    poller = email_client.begin_send(message);

    time_elapsed = 0
    while not poller.done():
        print("Email send poller status: " + poller.status())

        poller.wait(POLLER_WAIT_TIME)
        time_elapsed += POLLER_WAIT_TIME

        if time_elapsed > 18 * POLLER_WAIT_TIME:
            raise RuntimeError("Polling timed out.")

    if poller.result()["status"] == "Succeeded":
        print(f"Successfully sent the email (operation id: {poller.result()['id']})")
    else:
        raise RuntimeError(str(poller.result()["error"]))

except Exception as ex:
    print(ex)

Executar o código

Execute o aplicativo do seu diretório de aplicativo com o comando python.

python send-email.py

Código de exemplo

Você pode baixar o aplicativo de exemplo "Enviar email para Python" do GitHub Azure Samples

Pré-requisitos

• Uma conta do Azure com uma assinatura ativa ou crie uma conta do Azure gratuitamente.

• Um recurso ativo dos Serviços de Comunicação do Azure ou crie um recurso dos Serviços de Comunicação.

• Um recurso ativo dos Aplicativos Lógicos do Azure (aplicativo lógico) e fluxo de trabalho, ou crie um novo recurso e fluxo de trabalho de aplicativo lógico com o gatilho que você quiser usar. No momento, o conector de SMS dos Serviços de Comunicação do Azure oferece somente ações, portanto o fluxo de trabalho do aplicativo lógico requer um gatilho, no mínimo. Você pode criar um recurso de aplicativo lógico de Consumo ou Standard.

• Um recurso de Email dos Serviços de Comunicação do Azure com um domínio configurado ou um domínio personalizado.

• Um recurso dos Serviços de Comunicação do Azure conectado a um domínio de Email do Azure.

Enviar email

Para adicionar uma nova etapa ao fluxo de trabalho usando o conector de email dos Serviços de Comunicação do Azure, siga estas etapas:

1. No designer, abra o fluxo de trabalho do aplicativo lógico.

   Consumo

   1. Na etapa em que você deseja adicionar a nova ação, selecione Nova etapa. Como alternativa, para adicionar a nova ação entre as etapas, mova o ponteiro sobre a seta entre essas etapas, selecione o sinal de adição (+) e selecione Adicionar uma ação.

   2. Na caixa de pesquisa Escolha uma operação, selecione Premium. Na caixa de pesquisa, insira Email de Comunicação do Azure.

   3. Na lista de ações, selecione Enviar email.

      

   Standard

   1. Na tapa em que você deseja adicionar a nova ação, selecione o sinal de adição (+). Como alternativa, para adicionar a nova ação entre as etapas, mova o ponteiro sobre a seta entre essas etapas, selecione o sinal de adição (+) e selecione Adicionar uma ação.

   2. Na caixa de pesquisa Adicionar uma ação, selecione Premium na lista de seleção do runtime. Na caixa de pesquisa, insira Email de Comunicação do Azure.

   3. Na lista de ações, selecione Enviar email.

2. Forneça um nome para a conexão.

3. Insira a cadeia de conexão para o recurso do Serviço de Comunicações do Azure. Para localizar essa cadeia de caracteres, siga estas etapas:

   1. No portal do Azure, abra o recurso do Serviço de Comunicação do Azure.

   2. No menu de recursos, em Configurações, selecione Chaves e copie a cadeia de conexão.

      

4. Quando terminar, selecione Criar.

5. No campo De, use o endereço de email que você configurou nos pré-requisitos. Insira os valores dos campos Para Email, Assunto e Corpo, por exemplo:

   

6. Salve seu fluxo de trabalho. Selecione Salvar na barra de ferramentas do designer.

Testar seu fluxo de trabalho

Com base no consumo ou no fluxo de trabalho Standard, inicie manualmente o fluxo de trabalho:

• Consumo: Na barra de ferramentas do designer, escolha Executar gatilho>Executar.
• Standard: No menu de fluxo de trabalho, selecione Visão geral. Na barra de ferramentas, escolha Executar gatilho>Executar.

O fluxo de trabalho cria um usuário, emite um token de acesso para esse usuário e, em seguida, remove e exclui o usuário. Você pode verificar as saídas dessas ações, depois que o fluxo de trabalho for executado com êxito.

Você deve receber um email no endereço especificado. Além disso, você pode usar a ação Obter status da mensagem de email para verificar o status dos emails enviados por meio da ação Enviar email. Para ver mais ações, revise a documentação do conector de email dos Serviços de Comunicação do Azure.

Limpar os recursos do fluxo de trabalho

Para limpar o recurso do aplicativo lógico, o fluxo de trabalho e os recursos relacionados, examine como limpar recursos do aplicativo lógico de Consumo ou como limpar recursos do aplicativo lógico Standard.

Introdução aos Serviços de Comunicação do Azure usando o módulo de comunicação do Azure PowerShell para enviar mensagens de email.

A conclusão deste artigo gera um pequeno custo de alguns centavos de USD ou menos em sua conta do Azure.

Pré-requisitos

• Uma conta do Azure com uma assinatura ativa. Crie uma conta gratuitamente.
• Um recurso dos Serviços de Comunicação por Email do Azure criado e pronto com um domínio provisionado. Criar um recurso de comunicação por email.
• Um recurso ativo dos Serviços de Comunicação do Azure conectado a um domínio de email e á respectiva cadeia de conexão. Conecte um domínio de email verificado para enviar email.
• O Azure PowerShell mais recente.

Verificação de pré-requisitos

• Em um Windows PowerShell, execute o Get-Module -ListAvailable -Name Az.Communication comando para verificar se o módulo de comunicação está instalado.
• Para ver os domínios verificados com o recurso dos Serviços de Comunicação por Email, entre no portal do Azure. Localize o recurso dos Serviços de Comunicação de email e abra a guia Provisionar domínios no painel de navegação esquerdo.

Configuração

Instalar o módulo de comunicação

Instale o módulo dos Serviços de Comunicação do Azure para o Azure PowerShell usando o Install-Module -Name Az.Communication comando.

Install-Module -Name Az.Communication

Após instalar o módulo de comunicação, execute o comando Get-Command -Module Az.Communication para obter todos os módulos de comunicação.

Get-Command -Module Az.Communication

Enviar uma mensagem de email

Enfileirar uma mensagem de email para ser enviada a um ou mais destinatários com apenas campos necessários.

$emailRecipientTo = @(
   @{
        Address = "<emailalias@emaildomain.com>"
        DisplayName = "Email DisplayName"
    }
)

$message = @{
    ContentSubject = "Test Email"
    RecipientTo = @($emailRecipientTo)  # Array of email address objects
    SenderAddress = '<donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net>'   
    ContentPlainText = "This is the first email from ACS - Azure PowerShell"    
}

Send-AzEmailServicedataEmail -Message $Message -endpoint "<yourEndpoint>"

Faça estas substituições no código:

• Substitua <yourEndpoint> pelo seu ponto de extremidade.
• Substitua <emailalias@emaildomain.com> pelo endereço de email para o qual deseja enviar uma mensagem.
• Substitua <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> pelo endereço MailFrom do domínio verificado.

Enfileirar uma mensagem de email para ser enviada a um ou mais destinatários com todos os campos.

$emailRecipientTo = @(
   @{
        Address = "<emailalias@emaildomain.com>"
        DisplayName = "Email DisplayName"
    },
   @{
        Address = "<emailalias1@emaildomain.com>"
        DisplayName = "Email DisplayName"
    }
)

$fileBytes1 = [System.IO.File]::ReadAllBytes("<file path>")

$fileBytes2 = [System.IO.File]::ReadAllBytes("<image file path>")

$emailAttachment = @(
    @{
        ContentInBase64 = $fileBytes1
        ContentType = "<text/plain>"
        Name = "<test.txt>"
    },
    @{
        ContentInBase64 = $fileBytes2
        ContentType = "<image/png>"
        Name = "<inline-attachment.png>"
        contentId = "<inline-attachment>"
    }
)

$headers = @{
    "Key1" = "Value1"
    "Key2" = "Value2"
    "Importance" = "high"
}

$emailRecipientBcc = @(
   @{
        Address = "<emailbccalias@emaildomain.com>"
        DisplayName = "Email DisplayName"
    }
)

$emailRecipientCc = @(
   @{
        Address = "<emailccalias@emaildomain.com>"
        DisplayName = "Email DisplayName"
    }
)

$emailRecipientReplyTo = @(
   @{
        Address = "<emailreplytoalias@emaildomain.com>"
        DisplayName = "Email DisplayName"
    }
)

$message = @{
    ContentSubject = "Test Email"
    RecipientTo = @($emailRecipientTo)  # Array of email address objects
    SenderAddress = '<donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net>'
    Attachment = @($emailAttachment) # Array of attachments
    ContentHtml = "<html><head><title>Enter title</title></head><body><img src='cid:inline-attachment' alt='Company Logo'/><h1>This is the first email from ACS - Azure PowerShell</h1></body></html>"
    ContentPlainText = "This is the first email from ACS - Azure PowerShell"
    Header = $headers  # Importance = high/medium/low or X-Priority = 2/3/4  
    RecipientBcc = @($emailRecipientBcc) # Array of email address objects
    RecipientCc = @($emailRecipientCc) # Array of email address objects
    ReplyTo = @($emailRecipientReplyTo) # Array of email address objects
    UserEngagementTrackingDisabled = $true
}

Send-AzEmailServicedataEmail -Message $Message -endpoint "<yourEndpoint>"

Faça estas substituições no código:

• Substitua <yourEndpoint> pelo seu ponto de extremidade.
• Substitua <emailalias@emaildomain.com> and <emailalias1@emaildomain.com> pelos endereços de email para os quais você deseja enviar uma mensagem.
• Substitua <file path> and <image file path> pelos caminhos reais dos arquivos dos anexos que você deseja enviar.
• Substitua <text/plain> and <image/png> pelos tipos de conteúdo apropriados para seus anexos.
• Substitua <test.txt> and <inline-attachment.png> pelos nomes dos arquivos dos seus anexos.
• Substitua <inline-attachment> pela ID de conteúdo do seu anexo embutido.
• Substitua <emailbccalias@emaildomain.com> pelo endereço de email para o qual você deseja enviar a mensagem como BCC.
• Substitua <emailccalias@emaildomain.com> pelo endereço de email para o qual você deseja enviar a mensagem como CC.
• Substitua <emailreplytoalias@emaildomain.com> pelo endereço de email para o qual você deseja que as respostas sejam enviadas.
• Substitua <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> pelo endereço MailFrom do domínio verificado.

Parâmetros opcionais

Os seguintes parâmetros opcionais estão disponíveis no Azure PowerShell.

• ContentHtml pode ser usado para especificar o corpo HTML do email.

• ContentPlainText usado para especificar o corpo do email em texto sem formatação.

• O Attachment define a lista de anexos de email. Esse parâmetro aceita uma matriz de caminhos de arquivo ou objetos de anexo. Limitamos o tamanho total de uma solicitação de email, incluindo anexos regulares e embutidos, a 10 MB.

• Header cabeçalhos de email personalizados a serem aprovados e define o nível de importância do email (alta, normal ou baixa).

• Matriz de RecipientBcc destinatários para o campo CCO.

• Matriz de RecipientCc destinatários para o campo CC.

• ReplyTo matriz de endereços de email para onde as respostas dos destinatários são enviadas.

• UserEngagementTrackingDisabled indica se o controle de envolvimento do usuário precisa ser desabilitado para essa solicitação se a configuração de acompanhamento de envolvimento do usuário no nível do recurso já estiver habilitada no plano de controle.

Você também pode usar uma lista de destinatários com RecipientCc e RecipientBcc semelhante a RecipientTo. Precisa haver pelo menos um destinatário dentro RecipientTo, RecipientCc ou RecipientBcc.