Enviar e-mail com anexos embutidos

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

Importante

Esta funcionalidade dos Serviços de Comunicação do Azure está atualmente em pré-visualização. Os recursos na visualização estão disponíveis publicamente e podem ser usados por todos os clientes novos e existentes da Microsoft.

Esta versão de pré-visualização é fornecida sem um contrato de nível de serviço e não a recomendamos para cargas de trabalho de produção. Algumas funcionalidades podem não ser suportadas ou as capacidades podem ser restringidas.

Para obter mais informações, veja Termos Suplementares de Utilização para Pré-visualizações do Microsoft Azure.

Enviar uma mensagem de e-mail com anexos embutidos

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

Completar este artigo acarreta um pequeno custo de alguns cêntimos de dólar americano ou menos na sua conta Azure.

Pré-requisitos

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. Encontre o recurso Serviços de Comunicação por Email e abra o separador Provisionar domínios no painel de navegação à esquerda.

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 inserir a 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.

Nota

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, você deve gerar novas cadeias de conexão. Recomendamos que você criptografe cadeias de conexão e altere-as regularmente.

setx AZURE_COMMUNICATION_CONNECTION_STRING "<yourConnectionString>"

Depois de adicionar a variável de ambiente, poderá ter de reiniciar todos os programas em execução que irão precisar de ler a variável de ambiente, incluindo a janela da consola. Por exemplo, se você estiver usando o Visual Studio como editor, reinicie o Visual Studio 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> 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.
  • 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 seu anexo incorporado, que é mencionado na seção 'img src' do HTML.
  • Substitua <alternatetext> por um texto descritivo para a 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> 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.
  • 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 seu anexo incorporado, que é mencionado na seção 'img src' do HTML.
  • Substitua <alternatetext> por um texto descritivo para a imagem para ajudar na acessibilidade.

Enviar uma mensagem de e-mail 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> 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.
  • Substitua <attachmenttype1><attachmenttype2><inlineattachmenttype1><inlineattachmenttype2><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 percursos de ficheiro para o anexo e pelo nome ou id cid do anexo em linha.
  • Substitua <contentid1><contentid2><contentid3> pelo CID para seu anexo embutido, que é referido na parte img src do HTML.
  • Substitua <alternatetext> por um texto descritivo para a imagem para ajudar na acessibilidade.

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

Nome do estado Descrição
Não Iniciado Não estamos enviando este status do nosso serviço no momento.
A Correr A operação de envio de e-mail está atualmente em andamento e sendo processada.
Com êxito 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 email além desse estágio pode ser obtido por meio do Azure Monitor ou da Grade de Eventos do Azure. Saiba como subscrever eventos por e-mail.
Com falhas A operação de envio de e-mail não foi bem-sucedida e encontrou um erro. O e-mail não foi enviado. O resultado contém um objeto de erro com mais detalhes sobre o motivo da falha.

Parâmetros opcionais

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

  • --html pode ser usado em vez de --text para o corpo do 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 de resposta 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.

Nota

Limitamos o tamanho total de um pedido de e-mail (que inclui anexos regulares e em linha) a 10 MB.

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

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

Nota

É 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 o módulo de comunicação do Azure PowerShell para enviar mensagens de email.

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

Pré-requisitos

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 ou não.
  • Para exibir os domínios verificados com seu recurso Serviços de Comunicação por Email, entre no portal do Azure. Encontre o recurso Serviços de Comunicação por Email e abra o separador Provisionar domínios no painel de navegação à esquerda.

Configuração

Instalar módulo de comunicação

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

Install-Module -Name Az.Communication

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

Get-Command -Module Az.Communication

Enviar uma mensagem de e-mail com anexo embutido

Enfileira uma mensagem de email a ser enviada para um ou mais destinatários com apenas 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 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.
  • Substitua <image file path> pelos caminhos de arquivo reais 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 anexos.
  • Substitua <contentId> pelo ID de conteúdo do anexo embutido.

Enfileira uma mensagem de e-mail 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 e-mail para os quais você gostaria de enviar uma mensagem.
  • Substitua <image file path1><image file path2><image file path3> pelos caminhos de arquivo reais dos anexos que você 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 em linha.

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

  • ContentPlainText usado para especificar o corpo de texto sem formatação do e-mail.

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

Nota

Por favor, note que limitamos o tamanho total de um pedido de e-mail (que inclui anexos regulares e embutidos) a 10MB.

  • Header cabeçalhos de e-mail personalizados a serem passados e define o nível de importância do e-mail (alto, normal ou baixo).

  • RecipientBcc matriz de destinatários para o campo BCC.

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

  • ReplyTo matriz de endereços de e-mail para onde as respostas dos destinatários serão enviadas.

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

Além disso, você pode usar uma lista de destinatários com RecipientCc e RecipientBcc semelhante a RecipientTo. É necessário que haja pelo menos um destinatário em RecipientTo ou RecipientCcRecipientBcc.

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

Completar este artigo acarreta um pequeno custo de alguns cêntimos de dólar americano ou menos na sua conta Azure.

Gorjeta

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

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

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

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

Estado Descrição
Não Iniciado Não estamos enviando este status do nosso serviço no momento.
A Correr A operação de envio de e-mail está atualmente em andamento e sendo processada.
Com êxito 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 email além desse estágio pode ser obtido por meio do Azure Monitor ou da Grade de Eventos do Azure. Saiba como subscrever eventos por e-mail
Com falhas A operação de envio de e-mail não foi bem-sucedida e encontrou um erro. O e-mail não foi enviado. O resultado contém um objeto de erro com mais detalhes sobre o motivo da falha.

Pré-requisitos

Completar este artigo acarreta um pequeno custo de alguns cêntimos de dólar americano ou menos na sua conta Azure.

Nota

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

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

    }
  }
}

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

Abra Program.cs num editor de texto e substitua o Main corpo do método por código para inicializar um EmailClient com a sua string de conexão. O código a seguir recupera a cadeia de conexão para o recurso de uma variável de ambiente chamada COMMUNICATION_SERVICES_CONNECTION_STRING. Saiba como gerir a cadeia de ligaçã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 e-mail 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 anexo e codifice-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 fazendo referência à sua 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}");
}

Nota

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

Tipos MIME permitidos

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

Código de exemplo

Você pode baixar o aplicativo de exemplo demonstrando essa ação do GitHub Azure Samples Enviar anexos embutidos de email usando .NET.

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.

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

Gorjeta

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 de Email Básico e Envio de Email Avançado no GitHub.

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.

Nome Descrição
Endereço de Email Esta classe contém um endereço de e-mail e uma opção para um nome de exibição.
Anexo de Email Essa classe cria um anexo de email aceitando uma ID exclusiva, cadeia de caracteres do tipo MIME do anexo de email, dados binários para conteúdo e uma ID de conteúdo opcional para defini-lo como um anexo embutido.
EmailClient Esta classe é necessária para todas as funcionalidades de e-mail. Você o instancia com sua cadeia de conexão e o usa para enviar mensagens de email.
OpçõesDoClienteDeEmail Essa classe pode ser adicionada à instanciação EmailClient para direcionar uma versão específica da API.
Conteúdo do Email Esta classe contém o assunto e o corpo da mensagem de email. Você precisa especificar pelo menos um dos conteúdos PlainText ou Html.
CabeçalhoPersonalizadoDeEmail Essa classe permite a adição de um par de nome e valor para um cabeçalho personalizado. A importância do e-mail também pode ser especificada através desses cabeçalhos usando o nome do cabeçalho 'x-priority' ou 'x-msmail-priority'.
Mensagem de e-mail Essa classe combina o remetente, o conteúdo e os destinatários. Opcionalmente, também podem ser adicionados cabeçalhos, anexos e endereços de e-mail de resposta personalizados.
Destinatários de e-mail Esta classe contém listas de objetos EmailAddress para destinatários da mensagem de email, incluindo listas opcionais para destinatários CC ou BCC.
ResultadoDeEnvioDeEmail Esta classe contém os resultados da operação de envio de e-mail. Ele tem um ID de operação, status da operação e objeto de erro (quando aplicável).
StatusEnvioEmail Essa classe representa o conjunto de status de uma operação de envio de email.

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

Nome do estado Descrição
estáIniciado Retorna true se a operação de envio de e-mail estiver atualmente em andamento e sendo processada.
estáConcluído Retorna verdadeiro se a operação de envio de e-mail tiver sido concluída sem erro e o e-mail foi enviado para entrega. Qualquer status detalhado sobre a entrega de email além desse estágio pode ser obtido por meio do Azure Monitor ou da Grade de Eventos do Azure. Saiba como subscrever eventos por e-mail
resultado Propriedade que existe se a operação de envio de e-mail tiver sido concluída.
erro Propriedade que existe se a operação de envio de e-mail não teve sucesso e encontrou um erro. O 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 conclusão deste início rápido acarreta um pequeno custo de alguns cêntimos (USD) ou menos na sua conta do Azure.

Nota

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

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:

Importe o EmailClient da biblioteca do cliente e instancie-o com a sua string de conexão.

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

npm install dotenv

Adicione o seguinte código ao 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 início rápido usa cadeias de conexão, mas em ambientes de produção, recomendamos o uso de principais de serviço.

Enviar uma mensagem de e-mail com anexos embutidos

Podemos adicionar um anexo embutido definindo um ou mais objetos de anexo. Certifique-se de incluir um identificador exclusivo contentId para cada um deles e adicioná-lo à nossa mensagem. Leia o arquivo anexo e codifice-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 fazendo referência à sua 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();

Nota

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

Tipos MIME permitidos

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

Código de exemplo

Você pode baixar o aplicativo de exemplo demonstrando essa ação do GitHub Azure Samples Enviar anexos embutidos de email usando JavaScript

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.

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

Gorjeta

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 de Email Básico e Envio de Email Avançado no GitHub.

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.

Nome Descrição
Endereço de Email Esta classe contém um endereço de e-mail e uma opção para um nome de exibição.
Anexo de Email Esta interface cria um anexo de e-mail aceitando uma ID exclusiva, uma cadeia de caracteres do tipo MIME do anexo de e-mail, uma string de bytes de conteúdo e uma ID de conteúdo opcional para defini-lo como um anexo inline.
EmailClient Esta classe é necessária para todas as funcionalidades de e-mail. Você o instancia com sua cadeia de conexão e o usa para enviar mensagens de email.
Mensagem de e-mail Essa classe combina o remetente, o conteúdo e os destinatários. Opcionalmente, também podem ser adicionados cabeçalhos, anexos e endereços de e-mail de resposta personalizados.
ResultadoDeEnvioDeEmail Esta classe contém os resultados da operação de envio de e-mail. Ele tem um ID de operação, status da operação e objeto de erro (quando aplicável).
StatusEnvioEmail Essa classe representa o conjunto de status de uma operação de envio de email.

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

Nome do estado Descrição
NÃO_INICIADO Não estamos enviando este status do nosso serviço no momento.
EM_PROGRESSO A operação de envio de e-mail está atualmente em andamento e 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 email além desse estágio pode ser obtido por meio do Azure Monitor ou da Grade de Eventos do Azure. Saiba como subscrever eventos por e-mail
FALHA A operação de envio de e-mail não foi bem-sucedida e encontrou um erro. O 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 conclusão deste início rápido do projeto incorre num pequeno custo de alguns cêntimos de dólar ou menos na sua conta do Azure.

Nota

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

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. Encontre o recurso Serviços de Comunicação por Email e abra o separador Provisionar domínios no painel de navegação à esquerda.

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

Para autenticar um cliente, instancie um EmailClient com sua cadeia de conexão. Saiba como gerir a cadeia de ligação do seu recurso. Você também pode inicializar o cliente com qualquer cliente HTTP personalizado que implemente a com.azure.core.http.HttpClient interface.

Para instanciar um cliente, adicione o seguinte código ao main método:

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

Enviar uma mensagem de e-mail 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 anexo e codifice-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 então incorporar uma imagem fazendo referência à sua ContentId na origem de uma <img> tag.

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

Nota

Você pode combinar anexos regulares com anexos embutidos. Ao definir um ContentId, um anexo é tratado como embutido. Um anexo sem um ContentId é tratado como um anexo regular.

Tipos MIME permitidos

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

Código de exemplo

Você pode baixar o aplicativo de exemplo demonstrando essa ação do GitHub Azure Samples Enviar anexos embutidos de email usando Java

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.

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

Gorjeta

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 de Email Básico e Envio de Email Avançado no GitHub.

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": [
        {
            "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 mais detalhadamente na tabela a seguir.

Nome do estado Descrição
Em curso A operação de envio de e-mail está atualmente em andamento e sendo processada.
Com êxito 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 email além desse estágio pode ser obtido por meio do Azure Monitor ou da Grade de Eventos do Azure. Saiba como subscrever eventos por e-mail
Com falhas A operação de envio de e-mail não foi bem-sucedida e encontrou um erro. O 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 conclusão deste início rápido acarreta um pequeno custo de alguns cêntimos (USD) ou menos na sua conta do Azure.

Nota

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

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. Encontre o recurso Serviços de Comunicação por Email e abra o separador Provisionar domínios no painel de navegação à esquerda.

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:

Instancie um EmailClient com sua cadeia de conexão. Saiba como gerir a cadeia de ligaçã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 início rápido usa cadeias de conexão, mas em ambientes de produção, recomendamos o uso de principais de serviço.

Enviar uma mensagem de e-mail 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 anexo e codifice-o usando Base64. Decodifice os bytes como uma cadeia de caracteres e passe-os para o attachment objeto.

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 então incorporar uma imagem fazendo referência à sua contentId na origem de uma <img> tag.

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

Nota

Anexos regulares também podem ser combinados com anexos incorporados. Definir um contentId fará com que um anexo seja considerado embutido, enquanto um anexo sem um contentId será considerado um anexo normal.

Tipos MIME permitidos

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

Código de exemplo

Você pode baixar o aplicativo de exemplo demonstrando essa ação do GitHub

Resolução de Problemas

Entrega de e-mail

Para solucionar problemas relacionados à entrega de e-mails, você pode obter o status da entrega de e-mails para capturar detalhes de entrega.

Importante

O resultado de sucesso retornado pela verificação do status da operação de envio apenas valida o fato de que o e-mail foi enviado para entrega. Para obter mais informações sobre o status da entrega no destinatário, consulte como lidar com eventos de email.

Controlo de Velocidade de Envio de E-mails

Se a sua aplicação estiver bloqueada, pode ser devido à limitação de envio de e-mails. Você pode lidar com a limitação de e-mails registando ou implementando uma política personalizada.

Nota

Esta sandbox destina-se a ajudar os desenvolvedores a começar a criar o aplicativo. Você pode solicitar gradualmente para aumentar o volume de envio assim que 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, você pode excluir o recurso ou grupo de recursos. A exclusão do grupo de recursos também exclui quaisquer outros recursos associados a ele. Saiba mais sobre a limpeza de recursos.

Próximos passos

  • Last updated on