Guia de início rápido: como enviar um email usando os Serviços de Comunicação do Azure

Introdução aos Serviços de Comunicação do Azure usando os Serviços de Comunicação Tente Email para enviar mensagens de email.

Pré-requisitos

• Uma conta do Azure com uma subscrição ativa. Crie uma conta gratuitamente.
• A biblioteca de cliente .NET Core versão mais recente 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 Introdução à criação de recurso de comunicação por email
• Um recurso ativo dos Serviços de Comunicação conectado ao Domínio de E-mail. Comece conectando um recurso de email com um recurso de comunicação

A conclusão deste início rápido implica um pequeno custo de alguns cêntimos de USD ou menos na sua conta do Azure.

Enviar um e-mail usando Experimentar e-mail

Experimentar Email ajuda você a iniciar o envio de emails para os destinatários desejados usando os Serviços de Comunicação do Azure, além de verificar a configuração do seu aplicativo para enviar email. Ele também ajuda a iniciar seu desenvolvimento de notificação por e-mail com o trecho 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. Escreva o e-mail a enviar

   • Digite o endereço de e-mail do destinatário
   • Insira o assunto
   • Escreva o corpo do e-mail

   

4. Clique em Enviar

   

5. E-mail enviado com sucesso.

   

6. Agora você também pode copiar o trecho de código de exemplo para enviar um e-mail para usar em seu projeto de exemplo para enviar notificações.

   • Selecione o idioma de sua escolha

   • Clique em Inserir minha conexão

   • Clique em Copiar

     

7. O trecho de código de e-mail agora está pronto para uso em seu projeto de notificação.

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

A conclusão deste início rápido implica um pequeno custo de alguns cêntimos de USD ou menos na sua conta do Azure.

Pré-requisitos

• Uma conta do Azure com uma subscrição 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. Comece a criar um recurso de comunicação por e-mail.
• Um recurso ativo dos Serviços de Comunicação do Azure conectado a um Domínio de Email e sua cadeia de conexão. Comece conectando um Recurso de Comunicação por Email a um Recurso de Comunicação do Azure.
• A CLI do Azure mais recente.

Verificação de pré-requisitos

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

Configuração

Adicionar a extensão

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

az extension add --name communication

Iniciar sessão na CLI do Azure

Você precisa entrar na CLI do Azure. Você pode entrar executando o az login comando do terminal e fornecendo suas credenciais.

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

Você pode configurar a AZURE_COMMUNICATION_CONNECTION_STRING variável de ambiente para usar operações de chaves da CLI do Azure sem precisar usar --connection_string para passar na cadeia de conexão. Para configurar uma variável de ambiente, abra uma janela do console e selecione seu sistema operacional nas guias abaixo. 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 e-mail

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> pela cadeia de conexão.
• Substitua <emailalias@emaildomain.com> pelo endereço de e-mail para o qual você gostaria de enviar uma mensagem.
• Substitua <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> pelo endereço MailFrom do seu domínio verificado.

O comando acima também executa uma sondagem no messageId e retorna o status da entrega do e-mail. O status pode ser um dos seguintes:

Parâmetros opcionais

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

• --html pode ser usado em vez de para o corpo do --text e-mail html.

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

• --to Define a lista de destinatários de e-mail.

• --cc define endereços de e-mail de cópia de carbono.

• --bcc define endereços de e-mail de cópia oculta.

• --reply-to define o endereço de e-mail Responder-Para.

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

• --attachments Define a lista de anexos de e-mail.

• --attachment-types Define a lista de tipos de anexos de e-mail, na mesma ordem de anexos.

Além disso, você pode usar uma lista de destinatários com --cc e --bcc semelhante a --to. É necessário que haja pelo menos um destinatário em --to ou --cc --bcc.

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

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

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

EmailSendResult retorna o seguinte status na operação de email executada.

Pré-requisitos

• Uma conta do Azure com uma subscrição ativa. Crie uma conta gratuitamente.
• A biblioteca de cliente .NET Core versão mais recente 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 Introdução à criação de recurso de comunicação por email
• Um recurso ativo dos Serviços de Comunicação conectado ao Domínio de Email e a uma Cadeia de Conexão. Comece conectando um recurso de email com um recurso de comunicação

A conclusão deste início rápido implica um pequeno custo de alguns cêntimos de USD ou menos na sua conta do Azure.

Verificação de pré-requisitos

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

Criar um novo aplicativo C#

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

dotnet new console -o EmailQuickstart

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

cd EmailQuickstart
dotnet build

Instalar o pacote

Enquanto ainda estiver no diretório do aplicativo, instale a biblioteca de cliente de Email dos Serviços de Comunicação do Azure para o pacote .NET usando o dotnet add package comando.

dotnet add package Azure.Communication.Email

Criando o cliente de e-mail 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 seu 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 e-mail:

// 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 cliente de Email JS dos Serviços de Comunicação para enviar mensagens de email.

Noções básicas sobre o modelo de objeto de email

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

EmailSendResult retorna o seguinte status na operação de email executada.

Pré-requisitos

• Node.js (~14).
• Uma conta do Azure com uma subscrição 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. Comece a criar um recurso de comunicação por e-mail.
• Um recurso ativo dos Serviços de Comunicação do Azure conectado a um Domínio de Email e sua cadeia de conexão. Comece conectando um Recurso de Comunicação por Email a um Recurso de Comunicação do Azure.

A conclusão deste início rápido implica um pequeno custo de alguns cêntimos de USD ou menos na sua conta do Azure.

Verificação de pré-requisitos

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

Configurar o ambiente do aplicativo

Criar um novo aplicativo Node.js

Primeiro, abra o terminal ou a janela de comando, 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 para este início rápido ao arquivo recém-criado.

Instalar o pacote

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

npm install @azure/communication-email --save

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

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

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

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, esse guia de início rápido usa cadeias de conexão, mas em ambientes de produção, recomendamos o uso de entidades de serviço.

Envio básico de e-mail

Enviar uma mensagem de e-mail

Para enviar uma mensagem de e-mail, chame a beginSend função do EmailClient. Esse método retorna um poller que verifica o status da operação e recupera o resultado quando ele é concluído.

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 e-mail para o qual você gostaria de enviar uma mensagem.
• Substitua <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> pelo endereço MailFrom do seu domínio verificado.

Executar o código

Use o comando node para executar o código adicionado ao arquivo send-email.js.

node ./send-email.js

Código de exemplo

Você pode baixar o aplicativo de exemplo do GitHub

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

Noções básicas sobre 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 Python.

EmailSendResult retorna o seguinte status na operação de email executada.

Pré-requisitos

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

A conclusão deste início rápido incorre num pequeno custo de alguns cêntimos USD ou menos na 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 exibir os domínios verificados com seu recurso Serviços de Comunicação por Email, entre no portal do Azure. Localize o recurso Serviços de Comunicação por Email e abra a guia Provisionar domínios no painel de navegação esquerdo.

Configurar o ambiente do aplicativo

Para configurar um ambiente para enviar e-mails, siga as etapas nas seções a seguir.

Criar uma nova aplicação Java

Abra seu terminal ou janela de comando e navegue até o diretório onde você gostaria de criar sua aplicação Java. Execute o seguinte comando 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 generate meta cria um diretório com o mesmo nome do artifactId valor. Neste 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 Project Object Model (POM) do projeto.

Instalar o pacote

Abra o arquivo pom.xml no 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 a estrutura do aplicativo

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

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 e-mail.

// 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, esse guia de início rápido usa cadeias de conexão, mas em ambientes de produção, recomendamos o uso de entidades de serviço.

Envio básico de e-mail

Uma mensagem de email pode ser criada 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 e-mail para o qual você gostaria de enviar uma mensagem.
• Substitua <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> pelo endereço MailFrom do seu domínio verificado.

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

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();
        System.out.println("Email send poller status: " + pollResponse.getStatus());

        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());
}

PollerFlux<EmailSendResult, EmailSendResult> poller = emailAsyncClient.beginSend(emailMessage);
// 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)", response.getValue().getId());
            }
            else {
                System.out.println("Email send status: " + response.getStatus());
            }
        },
        error -> {
            System.out.println("Error occurred while sending email: " + error.getMessage());
        }
);

Executar o código

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

   mvn compile
   

2. Crie o pacote.

   mvn package
   

3. Execute o seguinte mvn comando para executar 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 do GitHub

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

Noções básicas sobre o modelo de objeto de email

O seguinte modelo de mensagem JSON & objeto de resposta 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 mais detalhadamente na tabela a seguir.

Pré-requisitos

• Uma conta do Azure com uma subscrição 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. Comece a criar um recurso de comunicação por e-mail.
• Um recurso ativo dos Serviços de Comunicação do Azure conectado a um Domínio de Email e sua cadeia de conexão. Comece conectando um Recurso de Comunicação por Email a um Recurso de Comunicação do Azure.

A conclusão deste início rápido implica um pequeno custo de alguns cêntimos de USD ou menos na sua conta do Azure.

Verificação de pré-requisitos

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

Configurar o ambiente do aplicativo

Para configurar um ambiente para enviar e-mails, siga as etapas nas seções a seguir.

Criar uma aplicação Python nova

1. Abra o terminal ou a janela de comando. Em seguida, use o seguinte comando para criar um ambiente virtual e ativá-lo. Este 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 seguintes comandos.

   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 adicionar a estrutura para o programa, incluindo o tratamento básico de exceções.

   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ê adiciona todo o código-fonte desse início rápido ao arquivo de send-email.py que você criou.

Instalar o pacote

Enquanto ainda estiver no diretório do aplicativo, instale o pacote 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 e-mail:

# 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, esse guia de início rápido usa cadeias de conexão, mas em ambientes de produção, recomendamos o uso de entidades de serviço.

Envio básico de e-mail

Enviar uma mensagem de e-mail

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 seu Recurso de Serviços de Comunicação por E-mail.
  • recipients: Um objeto com uma lista de destinatários de e-mail e, opcionalmente, listas de destinatários de e-mail CC ou BCC.
  • content: Um objeto que contém o assunto e, opcionalmente, o texto simples ou o conteúdo HTML de uma mensagem de e-mail.
• Chame o método begin_send, 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 e-mail para o qual você gostaria de enviar uma mensagem.
• Substitua <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> pelo endereço MailFrom do seu domínio verificado.

Obter o status da entrega do e-mail

Podemos pesquisar o status da entrega de e-mail definindo um loop no objeto de status da operação retornado do método EmailClient begin_send :

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 a partir do diretório do aplicativo com o python comando.

python send-email.py

Código de exemplo

Você pode baixar o aplicativo de exemplo do GitHub

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 de Aplicativos Lógicos do Azure (aplicativo lógico) e fluxo de trabalho, ou crie um novo recurso de aplicativo lógico e fluxo de trabalho com o gatilho que você deseja usar. Atualmente, o conector de Email dos Serviços de Comunicação do Azure fornece apenas 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 Consumo ou Padrão.

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

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

Enviar e-mail

Para adicionar uma nova etapa ao seu 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, digite Email de Comunicação do Azure.

   3. Na lista de ações, selecione Enviar e-mail.

      

   Standard

   1. Na etapa em que 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 Adicionar uma pesquisa de ação , selecione Premium na lista suspensa de tempo de execução. Na caixa de pesquisa, digite Email de Comunicação do Azure.

   3. Na lista de ações, selecione Enviar e-mail.

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

3. Insira a cadeia de conexão para seu recurso do Serviço de Comunicações do Azure. Para localizar esta cadeia de caracteres, siga estes passos:

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

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

      

4. Quando tiver terminado, selecione Criar.

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

   

6. Salve seu fluxo de trabalho. Na barra de ferramentas do estruturador, selecione Guardar.

Testar o fluxo de trabalho

Com base no fato de você ter um fluxo de trabalho Consumo ou Padrão, inicie manualmente seu fluxo de trabalho:

• Consumo: Na barra de ferramentas do designer, selecione Executar execução de gatilho>.
• Padrão: no menu do fluxo de trabalho, selecione Visão geral. Na barra de ferramentas, selecione Executar execução de gatilho>.

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 e-mail no endereço especificado. Além disso, você pode usar a ação Obter status da mensagem de email para verificar o status dos e-mails enviados por meio da ação Enviar e-mail . Para obter mais ações, consulte a documentação de referência do conector de Email dos Serviços de Comunicação do Azure.

Limpar recursos do fluxo de trabalho

Para limpar o recurso do aplicativo lógico, o fluxo de trabalho e os recursos relacionados, revise como limpar os recursos do aplicativo lógico de consumo ou como limpar os recursos do aplicativo lógico padrão.