Compartilhar via

Enviar email com anexos embutidos

Este artigo descreve como enviar e-mails com anexos embutidos usando nossos SDKs de e-mail.

Enviar uma mensagem de email com anexos embutidos

Use a extensão de comunicação da CLI do Azure para enviar mensagens de email com anexos embutidos.

Concluir esse artigo gera um pequeno custo de alguns centavos de USD ou menos na sua conta do Azure.

Pré-requisitos

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 do console e selecione o sistema operacional nas guias abaixo. Substitua <connectionString> pela cadeia de conexão real.

Observação

Não armazene sua cadeia de conexão como uma variável de ambiente não criptografada para ambientes de produção. Este exemplo é apenas para fins de teste. Para ambientes de produção, gere novas cadeias de conexão. Incentivamos você a criptografar cadeias de conexão e alterá-las regularmente.

setx AZURE_COMMUNICATION_CONNECTION_STRING "<yourConnectionString>"

Depois de adicionar a variável de ambiente, talvez seja necessário reiniciar todos os programas em execução que precisarem ler a variável de ambiente, incluindo a janela do console. Por exemplo, se estiver usando o Visual Studio como seu editor, reinicie-o antes de executar o exemplo.

Enviar uma mensagem de e-mail com anexo embutido

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"
	--attachment-types "<inlineattachmenttype1>" # MIME type of the content being attached. Example: "png"
	--inline-attachments "<filepath>/<contentid>" # Example: "MicrosoftLogo.png/MSLogo"
	--html "<html><head><title>Welcome to Azure Communication Services Email</title></head><body><h1>This email message is sent from Azure Communication Services Email using Azure CLI.</h1><img src='cid:<contentid>' alt='<alternatetext>'/></body></html>"

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.
  • Substitua <inlineattachmenttype1> pelo tipo de anexo real do arquivo.
  • Substitua <filepath>/<contentid> pelo caminho do arquivo para o anexo e o nome ou id cid do anexo embutido.
  • Substitua <contentid> pelo CID do anexo embutido, que é mencionado na parte img src do HTML.
  • Substitua <alternatetext> por um texto descritivo da imagem para ajudar na acessibilidade.

Enviar uma mensagem de e-mail com anexo e anexo embutido

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"
	--attachment-types "<attachmenttype1>" "<inlineattachmenttype1>" # MIME type of the content being attached. Example1: "jpg" "png" & Example2: "png" "png"
	--attachments "<filepath>" # Example: "MSLogo.jpg"
	--inline-attachments "<filepath>/<contentid>" # Example: "MicrosoftLogo.png/MSLogo"
	--html "<html><head><title>Welcome to Azure Communication Services Email</title></head><body><h1>This email message is sent from Azure Communication Services Email using Azure CLI.</h1><img src='cid:<contentid>' alt='<alternatetext>'/></body></html>"

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.
  • Substitua <attachmenttype1><inlineattachmenttype1> pelo tipo de anexo real do arquivo.
  • Substitua <filepath> pelo caminho do arquivo para o anexo.
  • Substitua <filepath>/<contentid> pelo caminho do arquivo para o anexo e o nome ou id cid do anexo embutido.
  • Substitua <contentid> pelo CID do anexo embutido, que é mencionado na parte img src do HTML.
  • Substitua <alternatetext> por um texto descritivo da imagem para ajudar na acessibilidade.

Enviar uma mensagem de email com vários anexos e anexos embutidos

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"
	--attachment-types "<attachmenttype1>" "<attachmenttype2>" "<inlineattachmenttype1>" "<inlineattachmenttype2>" "<inlineattachmenttype3>" # MIME type of the content being attached. Example: "png" "jpg" "png" "jpg" "bmp"
	--attachments "<filepath1>" "<filepath2>"
	--inline-attachments "<filepath1>/<contentid1>" "<filepath2>/<contentid2>" "<filepath3>/<contentid3>"
	--html "<html><head><title>Welcome to Azure Communication Services Email</title></head><body><h1>This email message is sent from Azure Communication Services Email using Azure CLI.</h1><img src='cid:<contentid1>' alt='<alternatetext>'/><img src='cid:<contentid2>' alt='<alternatetext>'/><img src='cid:<contentid3>' alt='<alternatetext>'/></body></html>"

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.
  • Substitua <attachmenttype1><inlineattachmenttype2><attachmenttype2><inlineattachmenttype1><inlineattachmenttype3> pelos tipos de anexo reais do arquivo.
  • Substitua <filepath1><filepath2> pelos caminhos de arquivo para o anexo.
  • Substitua <filepath1>/<contentid1><filepath2>/<contentid2><filepath3>/<contentid3> pelos caminhos de arquivo para o anexo e o nome ou id cid do anexo embutido.
  • Substitua <contentid1><contentid2><contentid3> pelo CID do anexo embutido, que é mencionado na parte img src do HTML.
  • Substitua <alternatetext> por um texto descritivo da imagem para ajudar na acessibilidade.

O comando anterior também executa uma sondagem no messageId e retorna o status do delivery de email. O status pode ser um dos seguintes valores:

Nome do Status Descrição
Não começou Não estamos enviando esse status de nosso serviço no momento.
Executando A operação de envio de e-mail está em andamento e está sendo processada.
Com sucesso A operação de envio de email foi concluída sem erros e o email está fora para entrega. Qualquer status detalhado sobre a entrega de e-mail além desse estágio pode ser obtido por meio do Azure Monitor ou de Grade de Eventos do Azure. Saiba como assinar eventos de email.
Com falha A operação de envio de email não teve êxito e encontrou um erro. O email não foi enviado. O resultado contém um objeto de erro com mais detalhes sobre o motivo da falha.

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.

  • O --disable-tracking indica se o rastreamento da participação do usuário deve ser desabilitado para esta solicitação.

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

Observação

Limitamos o tamanho total de uma solicitação de e-mail (que inclui anexos regulares e embutidos) a 10 MB.

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

  • --inline-attachments incorpora um anexo diretamente no corpo do e-mail, em vez de como um arquivo separado para download. Os anexos embutidos são comumente usados para imagens ou arquivos de mídia que devem aparecer embutidos no conteúdo do e-mail.

Observação

Precisa haver pelo menos um destinatário dentro --to, --cc ou --bcc.

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 realização deste início rápido gera um pequeno custo de alguns centavos de dólar ou menos em sua conta do Azure.

Pré-requisitos

Verificação de pré-requisitos

  • Em um Windows PowerShell, execute o comando Get-Module -ListAvailable -Name Az.Communication para verificar se o módulo de comunicação está instalado ou não.
  • 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

Instalar o módulo de comunicação

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

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 e-mail com anexo embutido

Coloca na fila uma mensagem de email a ser enviada a um ou mais destinatários com apenas os campos obrigatórios.

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

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

$emailAttachment = @(
    @{
        ContentInBase64 = $fileBytes
        ContentType = "<image/png>"
        Name = "<inline-attachment.png>"
        contentId = "<contentId>"
    }
)

$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:<contentId>' 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"
}

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.
  • Substitua <image file path> pelos caminhos reais dos arquivos dos anexos que você deseja enviar.
  • Substitua <image/png> pelos tipos de conteúdo apropriados para seus anexos.
  • Substitua <inline-attachment.png> pelos nomes dos arquivos dos seus anexos.
  • Substitua <contentId> pela ID de conteúdo do seu anexo embutido.

Enfileira uma mensagem de email a ser enviada para um ou mais anexos embutidos.

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

$fileBytes1 = [System.IO.File]::ReadAllBytes("<image file path1>")
$fileBytes2 = [System.IO.File]::ReadAllBytes("<image file path2>")
$fileBytes3 = [System.IO.File]::ReadAllBytes("<image file path3>")

$emailAttachment = @(
    @{
        ContentInBase64 = $fileBytes1
        ContentType = "<image/png>"
        Name = "<inline-attachment1.png>"
        contentId = "<contentId1>"
    },
    @{
        ContentInBase64 = $fileBytes2
        ContentType = "<image/png>"
        Name = "<inline-attachment2.png>"
        contentId = "<contentId2>"
    },
    @{
        ContentInBase64 = $fileBytes3
        ContentType = "<image/png>"
        Name = "<inline-attachment3.png>"
        contentId = "<contentId3>"
    }
)

$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:<contentId1>' alt='Company Logo'/><img src='cid:<contentId2>' alt='Company Logo'/><img src='cid:<contentId3>' 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"
}

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 <image file path1><image file path2><image file path3> pelos caminhos de arquivo reais dos anexos que deseja enviar.
  • Substitua <image/png> pelos tipos de conteúdo apropriados para seus anexos.
  • Substitua <inline-attachment1.png><inline-attachment2.png><inline-attachment3.png> pelos nomes dos arquivos dos anexos.
  • Substitua <contentId1><contentId2><contentId3> pelo Content-ID do anexo embutido.

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.

  • Attachment Define a lista de anexos de e-mail e anexos embutidos. Esse parâmetro aceita uma matriz de caminhos de arquivo ou objetos de anexo.

Observação

Observe que limitamos o tamanho total de uma solicitação de email (que inclui 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.

  • Matriz de ReplyTo endereços de email para os quais as respostas dos destinatários serão enviadas.

  • UserEngagementTrackingDisabled indica se o acompanhamento da participação do usuário deve ser desabilitado para essa solicitação se a configuração de acompanhamento do compromisso do usuário no nível do recurso já estiver habilitada no painel de controle.

Além disso, você 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.

Começar a usar os Serviços de Comunicação do Azure usando a biblioteca de clientes de email .NET dos Serviços de Comunicação para enviar mensagens de email.

Concluir esse artigo gera um pequeno custo de alguns centavos de USD ou menos na sua conta do Azure.

Dica

Inicie sua experiência de envio de emails com os Serviços de Comunicação do Azure, usando os Exemplos do GitHub do Azure: Envio de Email Básico e Envio de Email Avançado.

Entender o modelo de objeto de email

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

Nome Descrição
Endereço de Email Essa classe contém um endereço de email e uma opção para um nome de exibição.
Anexo de Email Essa classe cria um anexo de email aceitando uma ID exclusiva, uma cadeia de caracteres de tipo MIME de anexo de email, dados binários para conteúdo e uma ID de conteúdo opcional para defini-lo como um anexo embutido.
Cliente de e-mail Essa classe é necessária para toda a funcionalidade de email. Você cria uma instância com sua cadeia de conexão e a utiliza para enviar mensagens de email.
Opções do Cliente de Email Essa classe pode ser adicionada à instanciação EmailClient para direcionar uma versão específica da API.
Conteúdo do Email Essa classe contém o assunto e o corpo da mensagem de email. Você precisa especificar pelo menos um conteúdo de texto não criptografado ou HTML
EmailCustomHeader Essa classe permite a adição de um par de nomes e valores a um cabeçalho personalizado. Email importância também pode ser especificada por meio desses cabeçalhos usando o nome de cabeçalho 'x-priority' ou 'x-msmail-priority'
Mensagem de Email Essa classe combina o remetente, o conteúdo e os destinatários. Cabeçalhos personalizados, anexos e endereços de email de resposta também podem ser adicionados.
Destinatários de Email Essa classe contém listas de objetos EmailAddress para destinatários da mensagem de email, incluindo listas opcionais para destinatários CC e CCO.
OperaçãoDeEnvioDeEmail Essa classe representa a operação de envio de email assíncrona e é retornada da chamada à API de envio de email.
ResultadoDoEnvioDeEmail Essa classe contém os resultados da operação de envio de e-mail. Ele tem uma ID da operação, o status da operação e o objeto de erro (quando aplicável).

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

Situação Descrição
Não começou Não estamos enviando esse status de nosso serviço no momento.
Executando A operação de envio de e-mail está em andamento e está sendo processada.
Com sucesso A operação de envio de email foi concluída sem erros e o email está fora para entrega. Qualquer status detalhado sobre a entrega de e-mail além desse estágio pode ser obtido por meio do Azure Monitor ou de Grade de Eventos do Azure. Saiba como assinar o e-mail de eventos
Com falha A operação de envio de e-mail não foi bem-sucedida e encontrou um erro. Este e-mail não foi enviado. O resultado contém um objeto de erro com mais detalhes sobre o motivo da falha.

Pré-requisitos

Concluir esse artigo gera um pequeno custo de alguns centavos de USD ou menos na sua conta do Azure.

Observação

Também podemos enviar um e-mail de nosso próprio domínio verificado. Como adicionar domínios verificados ao Serviço de Comunicação por E-mail.

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 C# "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

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

    }
  }
}

Você tem algumas opções disponíveis para autenticar um cliente de email:

Abra Program.cs em um editor de texto e substitua o corpo do método Main pelo código para inicializar um EmailClient com a cadeia de conexão. O código abaixo recupera a cadeia de conexão do recurso em uma variável de ambiente chamada COMMUNICATION_SERVICES_CONNECTION_STRING. Saiba como gerenciar a cadeia de conexão do seu recurso.

// 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);

Enviar uma mensagem de email com anexos embutidos

Podemos adicionar um anexo embutido definindo um ou mais EmailAttachment objetos, definindo um exclusivo ContentId para cada um e adicionando-os ao nosso objeto EmailMessage. Leia o arquivo de anexo e codifique-o usando Base64.

var jpgFilePath = "./inline-attachment.jpg";
byte[] jpgBytes = File.ReadAllBytes(jpgFilePath);
var jpgBinaryData = new BinaryData(jpgBytes);
var jpgInlineAttachment = new EmailAttachment(
    "inline-attachment.jpg",
    "image/jpeg",
    jpgBinaryData);
jpgInlineAttachment.ContentId = "my-inline-attachment-1";

var pngFilePath = "./inline-attachment.png";
byte[] pngBytes = File.ReadAllBytes(pngFilePath);
var pngBinaryData = new BinaryData(pngBytes);
var pngInlineAttachment = new EmailAttachment(
    "inline-attachment.png",
    "image/png",
    pngBinaryData);
pngInlineAttachment.ContentId = "my-inline-attachment-2";

Dentro do corpo HTML da mensagem, podemos incorporar uma imagem referenciando-a ContentId na origem de uma <img> tag.

var emailContent = new EmailContent("Welcome to Azure Communication Services Email")
{
    PlainText ="This email message is sent from Azure Communication Services Email using the .NET SDK.",
    Html = "<html><h1>HTML body inline images:</h1><img src=\"cid:my-inline-attachment-1\" /><img src=\"cid:my-inline-attachment-2\" /></html>"
};

var emailMessage = new EmailMessage(
    senderAddress: "donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net"
    recipientAddress: "emailalias@contoso.com"
    content: emailContent);

emailMessage.Attachments.Add(jpgInlineAttachment);
emailMessage.Attachments.Add(pngInlineAttachment);

try
{
    EmailSendOperation emailSendOperation = emailClient.Send(WaitUntil.Completed, emailMessage);
    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}");
}

Observação

Você pode combinar anexos regulares com anexos embutidos. A definição de a ContentId trata um anexo como embutido, enquanto um anexo sem a ContentId é tratado como um anexo regular.

Tipos MIME permitidos

Embora a maioria dos clientes modernos dê suporte a anexos embutidos, o comportamento de renderização de um anexo embutido depende em grande parte do cliente de email do destinatário. Por esse motivo, recomendamos o uso de formatos de imagem embutidos mais comuns sempre que possível, como .png, .jpg, ou .gif. Para obter mais informações sobre tipos MIME aceitáveis para anexos de email, consulte a documentação Tipos MIME com suporte .

Código de exemplo

Você pode baixar o aplicativo de exemplo que demonstra essa ação em Exemplos do GitHub Azure Enviar anexos embutidos de email usando .NET.

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

A realização deste início rápido gera um pequeno custo de alguns centavos de dólar ou menos em sua conta do Azure.

Dica

Inicie sua experiência de envio de email com os Serviços de Comunicação do Azure pulando diretamente para o código de exemplo Envio Básico de Email e Envio Avançado de Email no GitHub.

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

Nome Descrição
Endereço de Email Essa classe contém um endereço de email e uma opção para um nome de exibição.
Anexo de Email Essa classe cria um anexo de email aceitando uma ID exclusiva, uma cadeia de caracteres de tipo MIME de anexo de email, dados binários para conteúdo e uma ID de conteúdo opcional para defini-lo como um anexo embutido.
Cliente de e-mail Essa classe é necessária para toda a funcionalidade de email. Você cria uma instância com sua cadeia de conexão e a utiliza para enviar mensagens de email.
Opções do Cliente de Email Essa classe pode ser adicionada à instanciação EmailClient para direcionar uma versão específica da API.
Conteúdo do Email Essa classe contém o assunto e o corpo da mensagem de email. Você precisa especificar pelo menos um dos conteúdos de Texto não criptografado ou Html.
EmailCustomHeader Essa classe permite a adição de um par de nomes e valores a um cabeçalho personalizado. E-mail importância também pode ser especificada por meio desses cabeçalhos usando o nome de cabeçalho 'x-priority' ou 'x-msmail-priority'.
Mensagem de Email Essa classe combina o remetente, o conteúdo e os destinatários. Cabeçalhos personalizados, anexos e endereços de email de resposta também podem ser adicionados.
Destinatários de Email Essa classe contém listas de objetos EmailAddress para destinatários da mensagem de email, incluindo listas opcionais para destinatários CC e CCO.
ResultadoDoEnvioDeEmail Essa classe contém os resultados da operação de envio de e-mail. Ele tem uma ID de operação, status da operação e objeto de erro (quando aplicável).
EmailSendStatus Essa classe representa o conjunto de status de uma operação de envio de e-mail.

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

Nome do Status Descrição
Isstarted Retornará verdadeiro se a operação de envio de e-mail estiver em andamento e estiver sendo processada.
IsCompleted Retorna true se a operação de envio de e-mail tiver sido concluída sem erro e o e-mail estiver fora para entrega. Qualquer status detalhado sobre a entrega de e-mail além desse estágio pode ser obtido por meio do Azure Monitor ou de Grade de Eventos do Azure. Saiba como assinar o e-mail de eventos
resultado Propriedade que existe se a operação de envio de e-mail for concluída.
erro Propriedade que existe se a operação de envio de e-mail não foi bem-sucedida e encontrou um erro. Este e-mail não foi enviado. O resultado contém um objeto de erro com mais detalhes sobre o motivo da falha.

Pré-requisitos

A realização deste início rápido gera um pequeno custo de alguns centavos de dólar ou menos em sua conta do Azure.

Observação

Também podemos enviar um e-mail de nosso próprio domínio verificado. Como adicionar domínios verificados ao Serviço de Comunicação por E-mail.

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 a janela de comando ou do terminal para criar um 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 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.

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

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

Importe o EmailClient da biblioteca de clientes e crie uma instância dele com sua cadeia de conexão.

O código abaixo recupera a cadeia de conexão do recurso de uma variável de ambiente chamada COMMUNICATION_SERVICES_CONNECTION_STRING usando o pacote dotenv. Use o comando npm install para instalar o pacote dotenv. Saiba como gerenciar a cadeia de conexão do seu recurso.

npm install dotenv

Adicione o seguinte código a send-email.js:

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

Para simplificar, este guia de início rápido usa cadeias de conexão, mas em ambientes de produção, recomenda-se o uso de entidades de serviço.

Enviar uma mensagem de email com anexos embutidos

Podemos adicionar um anexo embutido definindo um ou mais objetos de anexo. Certifique-se de incluir um exclusivo contentId para cada um e adicioná-lo à nossa mensagem. Leia o arquivo de anexo e codifique-o usando Base64.

const jpgFilePath = "./inline-attachment.jpg";
const pngFilePath = "./inline-attachment.png";

const inlineAttachments = [
    {
        name: path.basename(jpgFilePath),
        contentId: "my-inline-attachment-1"
        contentType: "image/jpeg",
        contentInBase64: readFileSync(jpgFilePath, "base64"),
    },
    {
        name: path.basename(pngFilePath),
        contentId: "my-inline-attachment-2"
        contentType: "image/png",
        contentInBase64: readFileSync(pngFilePath, "base64"),
    }
];

No corpo HTML da mensagem, incorpore uma imagem referenciando-a contentId na origem de uma <img> tag.

const message = {
  sender: "<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.",
    html: "<html><h1>HTML body inline images:</h1><img src=\"cid:my-inline-attachment-1\" /><img src=\"cid:my-inline-attachment-2\" /></html>"
  },
  recipients: {
    to: [
      {
        address: "<emailalias@contoso.com>",
        displayName: "Customer Name",
      }
    ]
  },
  attachments: inlineAttachments
};

const poller = await emailClient.beginSend(message);
const response = await poller.pollUntilDone();

Observação

Você pode combinar anexos regulares com anexos embutidos. Defina a contentId para tratar um anexo como embutido. Um anexo sem um contentId é tratado como um anexo regular.

Tipos MIME permitidos

Embora a maioria dos clientes modernos dê suporte a anexos embutidos, o comportamento de renderização de um anexo embutido depende em grande parte do cliente de email do destinatário. Por esse motivo, recomendamos o uso de formatos de imagem embutidos mais comuns sempre que possível, como .png, .jpg, ou .gif. Para obter mais informações sobre tipos MIME aceitáveis para anexos de email, consulte a documentação Tipos MIME com suporte .

Código de exemplo

Você pode baixar o aplicativo de exemplo que demonstra essa ação em GitHub Exemplos do Azure Enviar anexos embutidos de email usando 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.

A realização deste início rápido gera um pequeno custo de alguns centavos de dólar ou menos em sua conta do Azure.

Dica

Inicie sua experiência de envio de email com os Serviços de Comunicação do Azure pulando diretamente para o código de exemplo Envio Básico de Email e Envio Avançado de Email no GitHub.

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 do SDK de Email dos Serviços de Comunicação do Azure para Python.

Nome Descrição
Endereço de Email Essa classe contém um endereço de email e uma opção para um nome de exibição.
Anexo de Email Essa interface cria um anexo de email aceitando uma ID exclusiva, uma cadeia de caracteres de tipo MIME de anexo de email, uma cadeia de caracteres de bytes de conteúdo e uma ID de conteúdo opcional para defini-la como um anexo embutido.
Cliente de e-mail Essa classe é necessária para toda a funcionalidade de email. Você cria uma instância com sua cadeia de conexão e a utiliza para enviar mensagens de email.
Mensagem de Email Essa classe combina o remetente, o conteúdo e os destinatários. Cabeçalhos personalizados, anexos e endereços de email de resposta também podem ser adicionados.
ResultadoDoEnvioDeEmail Essa classe contém os resultados da operação de envio de e-mail. Ele tem uma ID de operação, status da operação e objeto de erro (quando aplicável).
EmailSendStatus Essa classe representa o conjunto de status de uma operação de envio de e-mail.

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

Nome do Status Descrição
NOT_STARTED Não estamos enviando esse status de nosso serviço no momento.
EM ANDAMENTO A operação de envio de e-mail está em andamento e está sendo processada.
CONCLUÍDO_COM_SUCESSO A operação de envio de e-mail foi concluída sem erro e o e-mail está fora para entrega. Qualquer status detalhado sobre a entrega de e-mail além desse estágio pode ser obtido por meio do Azure Monitor ou de Grade de Eventos do Azure. Saiba como assinar o e-mail de eventos
FALHOU A operação de envio de e-mail não foi bem-sucedida e encontrou um erro. Este e-mail não foi enviado. O resultado contém um objeto de erro com mais detalhes sobre o motivo da falha.

Pré-requisitos

A realização deste início rápido gera um pequeno custo de alguns centavos de dólar ou menos em sua conta do Azure.

Observação

Também podemos enviar um e-mail de nosso próprio domínio verificado Adicionar domínios verificados personalizados para E-mail Serviço de Comunicação.

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 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 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.PollResponse;
import com.azure.core.util.polling.SyncPoller;

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:

Para autenticar um cliente, crie uma instância de EmailClient com sua cadeia de conexão. Saiba como gerenciar a cadeia de conexão do seu recurso. Também é possível criar uma instância do cliente com qualquer cliente HTTP personalizado que implemente a interface com.azure.core.http.HttpClient.

Para criar uma instância de um cliente, adicione o seguinte código ao método main:

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

Para simplificar, este guia de início rápido usa cadeias de conexão, mas em ambientes de produção, recomenda-se o uso de entidades de serviço.

Enviar uma mensagem de email com anexos embutidos

Adicione um anexo embutido definindo um ou mais objetos EmailAttachment, definindo um exclusivo ContentId para cada um e adicionando-os ao nosso objeto EmailMessage. Leia o arquivo de anexo e codifique-o usando Base64.

byte[] jpgContent = Files.readAllBytes(new File("./inline-attachment.jpg").toPath());
byte[] jpgEncodedContent = Base64.getEncoder().encodeToString(jpgContent).getBytes();
EmailAttachment jpgInlineAttachment = new EmailAttachment(
    "inline-attachment.jpg",
    "image/jpeg",
    BinaryData.fromBytes(jpgEncodedContent)
).setContentId("my-inline-attachment-1");

byte[] pngContent = Files.readAllBytes(new File("./inline-attachment.png").toPath());
byte[] pngEncodedContent = Base64.getEncoder().encodeToString(pngContent).getBytes();
EmailAttachment pngInlineAttachment = new EmailAttachment(
    "inline-attachment.png",
    "image/png",
    BinaryData.fromBytes(pngEncodedContent)
).setContentId("my-inline-attachment-2");

Dentro do corpo HTML da mensagem, podemos inserir uma imagem referenciando-a ContentId dentro da origem de uma marca <img>.

EmailMessage message = new EmailMessage()
    .setSenderAddress(senderAddress)
    .setToRecipients(recipientAddress)
    .setSubject("Welcome to Azure Communication Services Email")
    .setBodyPlainText("This email message is sent from Azure Communication Services Email using the Java SDK.");
    .setBodyHtml("<html><h1>HTML body inline images:</h1><img src=\"cid:my-inline-attachment-1\" /><img src=\"cid:my-inline-attachment-2\" /></html>")
    .setAttachments(jpgInlineAttachmentContent, pngInlineAttachmentContent);

SyncPoller<EmailSendResult, EmailSendResult> poller = emailClient.beginSend(message, null);
PollResponse<EmailSendResult> response = poller.waitForCompletion();

System.out.println("Operation Id: " + response.getValue().getId());

Observação

Você pode combinar anexos regulares com anexos embutidos. Definir um ContentId anexo trata um anexo como embutido. Um anexo sem um ContentId é tratado como um anexo regular.

Tipos MIME permitidos

Embora a maioria dos clientes modernos dê suporte a anexos embutidos, o comportamento de renderização de um anexo embutido depende em grande parte do cliente de email do destinatário. Por esse motivo, recomendamos o uso de formatos de imagem embutidos mais comuns sempre que possível, como .png, .jpg, ou .gif. Para obter mais informações sobre tipos MIME aceitáveis para anexos de email, consulte a documentação Tipos MIME com suporte .

Código de exemplo

Você pode baixar o aplicativo de exemplo que demonstra essa ação em GitHub Exemplos do Azure Enviar anexos embutidos de email usando 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.

A realização deste início rápido gera um pequeno custo de alguns centavos de dólar ou menos em sua conta do Azure.

Dica

Inicie sua experiência de envio de email com os Serviços de Comunicação do Azure pulando diretamente para o código de exemplo Envio Básico de Email e Envio Avançado de Email no GitHub.

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": [
        {
            "name": "str"  # Name of the attachment. Required.
            "contentType": "str",  # MIME type of the content being attached. Required.
            "contentInBase64": "str",  # Base64 encoded contents of the attachment. Required.
            "contentId": "str" # Unique identifier (CID) to reference an inline attachment. Optional
        }
    ],
    "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.

Nome do Status Descrição
InProgress A operação de envio de e-mail está em andamento e está sendo processada.
Com sucesso A operação de envio de e-mail foi concluída sem erro e o e-mail está fora para entrega. Qualquer status detalhado sobre a entrega de e-mail além desse estágio pode ser obtido por meio do Azure Monitor ou de Grade de Eventos do Azure. Saiba como assinar o e-mail de eventos
Com falha A operação de envio de e-mail não foi bem-sucedida e encontrou um erro. Este e-mail não foi enviado. O resultado contém um objeto de erro com mais detalhes sobre o motivo da falha.

Pré-requisitos

A realização deste início rápido gera um pequeno custo de alguns centavos de dólar ou menos em sua conta do Azure.

Observação

Também podemos enviar um e-mail de nosso próprio domínio verificado. Como adicionar domínios verificados ao Serviço de Comunicação por E-mail.

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:

Crie uma instância de um EmailClient com a cadeia de conexão. Saiba como gerenciar a cadeia de conexão do seu recurso.

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

Para simplificar, este guia de início rápido usa cadeias de conexão, mas em ambientes de produção, recomenda-se o uso de entidades de serviço.

Enviar uma mensagem de email com anexos embutidos

Podemos adicionar um anexo embutido definindo um ou mais attachments, certificando-se de incluir um exclusivo contentId para cada um e adicionando-os à nossa mensagem. Leia o arquivo de anexo e codifique-o usando Base64. Decodifique os bytes como uma cadeia de caracteres e passe-os para o objeto attachment.

import base64

with open("./inline-attachment.jpg", "rb") as file:
    jpg_file_bytes_b64 = base64.b64encode(file.read())

with open("./inline-attachment.png", "rb") as file:
    png_file_bytes_b64 = base64.b64encode(file.read())

inlineAttachments = [
    {
        "name": "inline-attachment.jpg",
        "contentId": "my-inline-attachment-1",
        "contentType": "image/jpeg",
        "contentInBase64": jpg_file_bytes_b64.decode()
    },
    {
        "name": "inline-attachment.png",
        "contentId": "my-inline-attachment-2",
        "contentType": "image/png",
        "contentInBase64": png_file_bytes_b64.decode()
    }
]

Dentro do corpo HTML da mensagem, podemos inserir uma imagem referenciando-a contentId dentro da origem de uma marca <img>.

message = {
    "content": {
        "subject": "Welcome to Azure Communication Services Email",
        "plainText": "This email message is sent from Azure Communication Services Email using the Python SDK.",
        "html": "<html><h1>HTML body inline images:</h1><img src=\"cid:my-inline-attachment-1\" /><img src=\"cid:my-inline-attachment-2\" /></html>"
    },
    "recipients": {
        "to": [
            {
                "address": "<emailalias@contoso.com>",
                "displayName": "Customer Name"
            }
        ]
    },
    "senderAddress": "<donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net>",
    "attachments": inlineAttachments
}

poller = email_client.begin_send(message)
result = poller.result()

Observação

Anexos regulares também podem ser combinados com anexos embutidos. Definir um contentId tratará um anexo como embutido, enquanto um anexo sem um contentId será tratado como um anexo regular.

Tipos MIME permitidos

Embora a maioria dos clientes modernos dê suporte a anexos embutidos, o comportamento de renderização de um anexo embutido depende em grande parte do cliente de email do destinatário. Por esse motivo, é sugerido usar formatos de imagem mais comuns embutidos sempre que possível, como .png, .jpg ou .gif. Para obter mais informações sobre os tipos MIME aceitáveis para anexos de email, consulte a documentação de tipos MIME permitidos.

Código de exemplo

Baixe o aplicativo de exemplo que demonstra isso no GitHub

Solução de problemas

Entrega de Emails

Para solucionar problemas relacionados à entrega de emails, você pode obter o status da entrega do email para capturar os detalhes da entrega.

Importante

O resultado bem-sucedido retornado pela sondagem do status da operação de envio valida apenas o fato de que o email é enviado para entrega. Para obter mais informações sobre o status da entrega no lado do destinatário, confira como lidar com eventos de email.

Limitação de Emails

Se o aplicativo estiver travado, pode ser devido à limitação de e-mail. Você pode lidar com o controle de fluxo de emails registrando ou implementando uma política personalizada.

Observação

Este sandbox destina-se a ajudar os desenvolvedores a começar a desenvolver o aplicativo. Você pode solicitar gradualmente para aumentar o volume de envio quando o aplicativo estiver pronto para entrar em operação. Envie uma solicitação de suporte para aumentar o limite de envio desejado se precisar enviar mais mensagens do que os limites de taxa.

Limpar recursos do Serviço de Comunicação do Azure

Se quiser limpar e remover uma assinatura dos Serviços de Comunicação, exclua o recurso ou o grupo de recursos. Excluir o grupo de recursos também exclui todos os recursos associados a ele. Saiba mais sobre como limpar recursos.

Próximas etapas