Enviar un correo electrónico mediante Azure Communication Services

Comienza con Azure Communication Services usando Communication Services Try Email para enviar mensajes de correo electrónico.

Requisitos previos

• Una cuenta de Azure con una suscripción activa. Cree una cuenta gratuita.
• La versión más reciente de la biblioteca cliente de .NET Core para su sistema operativo.
• Un recurso de Azure Email Communication Services creado y listo con un dominio aprovisionado. Comenzar con la creación de un recurso de comunicación por correo electrónico
• Un recurso activo de Communication Services conectado con el dominio de correo electrónico. Conecte un dominio de correo electrónico comprobado para enviar correo electrónico.

Completar este artículo conlleva un pequeño costo de unos pocos centavos de USD o menos en su cuenta de Azure.

Enviar un correo electrónico mediante Try Email

Probar correo electrónico le ayuda a iniciar el envío de correos electrónicos a los destinatarios deseados mediante Azure Communication Services y comprobar la configuración de la aplicación para enviar correo electrónico. También ayuda a iniciar el desarrollo de notificaciones por correo electrónico con el fragmento de código de su lenguaje preferido.

Para enviar un mensaje a un destinatario y especificar el asunto y el cuerpo del mensaje:

1. En la página de información general de un recurso de Azure Communication Services aprovisionado, haga clic en Probar correo electrónico en el panel de navegación izquierdo en Correo electrónico.

   

2. Seleccione uno de los dominios comprobados en la lista desplegable.

   

3. Redacte el correo electrónico que se va a enviar.

   • Escriba la dirección de correo electrónico del destinatario
   • Escriba el asunto
   • Escriba el cuerpo del mensaje del correo electrónico

   

4. Haga clic en Enviar.

   

5. Correo electrónico enviado correctamente.

   

6. También puede copiar el fragmento de código de ejemplo para enviar un correo electrónico para usarlo en el proyecto de ejemplo para enviar notificaciones.

   • Seleccione el lenguaje que prefiera

   • Haga clic en Insertar mi conexión

   • Haga clic en Copiar

     

7. El fragmento de código para enviar un correo electrónico ya está listo para usarse en el proyecto de notificación.

Introducción al uso de Azure Communication Services mediante la extensión de comunicación de la CLI de Azure para enviar mensajes de correo electrónico.

Completar este artículo conlleva un pequeño costo de unos pocos centavos de USD o menos en su cuenta de Azure.

Requisitos previos

• Una cuenta de Azure con una suscripción activa. Cree una cuenta gratuita.
• Un recurso de Azure Email Communication Services creado y listo con un dominio aprovisionado. Cree un recurso de comunicación por correo electrónico.
• Un recurso de Azure Communication Services activo conectado a un dominio de correo electrónico y su cadena de conexión. Conecte un dominio de correo electrónico comprobado para enviar correo electrónico.
• La CLI de Azure más reciente.

Comprobación de requisitos previos

• En una ventana de terminal o comando, ejecute el comando az --version para comprobar que la CLI de Azure y la extensión de comunicación están instaladas.
• Para ver los dominios comprobados con su recurso de correo electrónico Email Communication Services, inicie sesión en Azure Portal. Busque el recurso Email Communication Services y abra la pestaña Aprovisionar dominios en el panel de navegación izquierdo.

Configuración

Adición de la extensión

Agregue la extensión Azure Communication Services para la CLI de Azure mediante el comando az extension.

az extension add --name communication

Inicio de sesión en la CLI de Azure

Deberá iniciar sesión en la CLI de Azure. Para iniciar sesión, ejecute el comando az login desde el terminal y proporcione sus credenciales.

Almacenamiento de la cadena de conexión en una variable de entorno

Puede configurar la variable de entorno AZURE_COMMUNICATION_CONNECTION_STRING para usar las operaciones de claves de la CLI de Azure sin tener que usar --connection_string para pasar la cadena de conexión. Para configurar una variable de entorno, abra una ventana de la consola y seleccione el sistema operativo en las pestañas siguientes. Reemplace <connectionString> por la cadena de conexión real.

setx AZURE_COMMUNICATION_CONNECTION_STRING "<yourConnectionString>"

export AZURE_COMMUNICATION_CONNECTION_STRING="<connectionString>"

export AZURE_COMMUNICATION_CONNECTION_STRING="<connectionString>"

Enviar un mensaje de correo electrónico

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

Haga estas sustituciones en el código:

• Reemplaza <yourConnectionString> por la cadena de conexión.
• Reemplace <emailalias@emaildomain.com> por la dirección de correo electrónico a la que quiere enviar un mensaje.
• Reemplace <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> por la dirección MailFrom del dominio comprobado.

Este comando también realiza un sondeo sobre messageId y devuelve el estado de la entrega de correo electrónico. El estado puede ser uno de los siguientes valores:

Parámetros opcionales

Los siguientes parámetros opcionales están disponibles en la CLI de Azure.

• --html se puede usar en lugar de --text para el cuerpo del correo electrónico HTML.

• --importance establece el tipo de importancia para el correo electrónico. Los valores conocidos son: alto, normal y bajo. El valor predeterminado es normal.

• --to establece la lista de destinatarios de correo electrónico.

• --cc establece direcciones de correo electrónico de copia carbón.

• --bcc establece direcciones de correo electrónico de copia oculta.

• --reply-to establece la dirección de correo electrónico de respuesta.

• --disable-tracking indica si el seguimiento de involucración del usuario debe deshabilitarse para esta solicitud.

• --attachments establece la lista de datos adjuntos de correo electrónico.

• --attachment-types establece la lista de tipos de datos adjuntos de correo electrónico, en el mismo orden de los datos adjuntos.

También puede usar una lista de destinatarios con --cc y --bcc similar a --to. Es necesario que haya al menos un destinatario en --to o --cc o --bcc.

Para empezar a usar Azure Communication Services, utilice la biblioteca cliente de correo electrónico de C# de Communication Services para enviar mensajes por correo electrónico.

Descripción del modelo de objetos de correo electrónico

Las clases e interfaces siguientes controlan algunas de las características principales de la biblioteca cliente de correo electrónico de Azure Communication Services para C#.

EmailSendResult devuelve el siguiente estado de la operación de correo electrónico realizada.

Requisitos previos

• Una cuenta de Azure con una suscripción activa. Cree una cuenta gratuita.
• La versión más reciente de la biblioteca cliente de .NET Core para su sistema operativo.
• Un recurso de Azure Email Communication Services creado y listo con un dominio aprovisionado Creación de un recurso de comunicación por correo electrónico.
• Un recurso activo de Communication Services conectado con el dominio de correo electrónico y una cadena de conexión. Cree y administre recursos de Email Communication Service.

Completar este artículo conlleva un pequeño costo de unos pocos centavos de USD o menos en su cuenta de Azure.

Comprobación de requisitos previos

• En una ventana de terminal o de comandos, ejecute dotnet para comprobar que la biblioteca cliente de .NET esté instalada.
• Para ver los subdominios asociados a su recurso de correo electrónico Email Communication Services, inicie sesión en Azure Portal, busque el recurso Email Communication Services y abra la pestaña Aprovisionar dominios en el panel de navegación izquierdo.

Creación de una aplicación de C#

En una ventana de consola (por ejemplo, cmd, PowerShell o Bash), use el comando dotnet new para crear una nueva aplicación de consola con el nombre EmailQuickstart. Este comando crea un sencillo proyecto "Hola mundo" de C# con un solo archivo de origen: Program.cs.

dotnet new console -o EmailQuickstart

Cambie el directorio a la carpeta de la aplicación recién creada y use el comando dotnet build para compilar la aplicación.

cd EmailQuickstart
dotnet build

Instalar el paquete

Mientras sigue en el directorio de aplicaciones, instale el paquete de la biblioteca cliente de correo electrónico de Azure Communication Services para .NET con el comando dotnet add package.

dotnet add package Azure.Communication.Email

Creación del cliente de correo electrónico con autenticación

Abra Program.cs y reemplace el código existente por lo siguiente para agregar directivas using que incluyan el espacio de nombres y establezcan un punto de inicio para ejecutar su programa Azure.Communication.Email.

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

    }
  }
}

Hay algunas opciones diferentes disponibles para autenticar un cliente de correo electrónico:

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

dotnet add package Azure.Identity

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

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

var emailClient = new EmailClient(endpoint, key);

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

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

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

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

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

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

dotnet run

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

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

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

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

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

dotnet run

Introducción a Azure Communication Services mediante la biblioteca cliente de correo electrónico de JavaScript de Communication Services para enviar mensajes de correo electrónico.

Descripción del modelo de objetos de correo electrónico

Las siguientes clases e interfaces controlan algunas características de la biblioteca cliente de correo electrónico de Azure Communication Services para JavaScript.

EmailSendResult devuelve el siguiente estado de la operación de correo electrónico realizada.

Requisitos previos

• Node.js (~14).
• Una cuenta de Azure con una suscripción activa. Cree una cuenta gratuita.
• Un recurso de Azure Email Communication Services creado y listo con un dominio aprovisionado. Cree un recurso de comunicación por correo electrónico.
• Un recurso de Azure Communication Services activo conectado a un dominio de correo electrónico y su cadena de conexión. Cree y administre recursos de Email Communication Service.

Completar este artículo conlleva un pequeño costo de unos pocos centavos de USD o menos en su cuenta de Azure.

Comprobación de requisitos previos

• En una ventana de terminal o de comandos, ejecute node --version para comprobar que Node.js está instalado.
• Para ver los dominios comprobados con su recurso de correo electrónico Email Communication Services, inicie sesión en Azure Portal, busque el recurso Email Communication Services y abra la pestaña Aprovisionar dominios en el panel de navegación izquierdo.

Configuración del entorno de la aplicación

Creación de una nueva aplicación Node.js

En primer lugar, abra el terminal o la ventana de comandos. A continuación, cree un nuevo directorio para la aplicación y vaya a él.

mkdir email-quickstart && cd email-quickstart

Ejecute npm init -y para crear un archivo package.json con la configuración predeterminada.

npm init -y

Use un editor de texto para crear un archivo denominado send-email.js en el directorio raíz del proyecto. Cambie la propiedad main de package.json a send-email.js. En la sección siguiente se muestra cómo agregar el código fuente de este artículo al archivo recién creado.

Instalar el paquete

Use el comando npm install para instalar la biblioteca cliente de correo electrónico de Azure Communication Services para JavaScript.

npm install @azure/communication-email --save

La opción --save muestra la biblioteca como dependencia en el archivo package.json.

Creación del cliente de correo electrónico con autenticación

Hay algunas opciones diferentes disponibles para autenticar un cliente de correo electrónico:

npm install dotenv

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

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

npm install @azure/identity

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

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

const emailClient = new EmailClient(endpoint, credential);

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

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

const emailClient = new EmailClient(endpoint, key);

Por simplicidad, este artículo utiliza cadenas de conexión, pero en entornos de producción, recomendamos usar principales de servicio.

Envío de correo electrónico básico

Enviar un mensaje de correo electrónico

Para enviar un mensaje de correo electrónico, llame a la función beginSend desde el EmailClient. Este método devuelve un sondeo que comprueba el estado de la operación y recupera el resultado una vez finalizado.

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

    const poller = await emailClient.beginSend(message);

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

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

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

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

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

main();

Haga estas sustituciones en el código:

• Reemplace <emailalias@emaildomain.com> por la dirección de correo electrónico a la que quiere enviar un mensaje.
• Reemplace <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> por la dirección MailFrom del dominio comprobado.

Ejecución del código

Use el comando node para ejecutar el código que agregó al archivo send-email.js.

node ./send-email.js

Código de ejemplo

Puede descargar la aplicación de ejemplo desde los ejemplos de Azure en GitHub Enviar Correo Electrónico para JavaScript.

Comienza con Azure Communication Services utilizando el SDK de Email de Communication Services para Java para enviar emails.

Descripción del modelo de objetos de correo electrónico

Las siguientes clases e interfaces controlan algunas de las características principales del SDK de correo electrónico de Azure Communication Services para Java.

EmailSendResult devuelve el siguiente estado de la operación de correo electrónico realizada.

Requisitos previos

• Una cuenta de Azure con una suscripción activa. Cree una cuenta gratuita.
• Kit de desarrollo de Java (JDK), versión 8 o posterior.
• Apache Maven.
• Un recurso de Communication Services implementado y una cadena de conexión. Para obtener más información, consulte Creación de un recurso de Communication Services.
• Para empezar a enviar correos electrónicos, cree un recurso de Azure Email Communication Services.
• Una identidad administrada de configuración para un entorno de desarrollo, consulte Autorización del acceso con identidad administrada.

Completar este artículo conlleva un pequeño costo de unos pocos centavos de USD o menos en su cuenta de Azure.

Comprobación de requisitos previos

• En una ventana de terminal o de comandos, ejecute mvn -v para comprobar que Maven está instalado.
• Para ver los dominios comprobados con su recurso de correo electrónico Email Communication Services, inicie sesión en Azure Portal. Ubique su recurso Servicios de Comunicación por Correo Electrónico y abra la pestaña Aprovisionar dominios en el panel de navegación izquierdo.

Configuración del entorno de la aplicación

Para configurar un entorno a fin de enviar correos electrónicos, siga los pasos descritos en las secciones siguientes.

Creación de una aplicación Java

Abra la ventana de terminal o de comandos y navegue hasta el directorio en el que quiere crear la aplicación de Java. Ejecute el siguiente comando para generar el proyecto Java desde la plantilla 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"

El objetivo generate crea un directorio con el mismo nombre que el valor artifactId. En este directorio, el directorio src/main/java contiene el código fuente del proyecto, el directorio src/test/java contiene el origen de la prueba, y el archivo pom.xml es el modelo de objetos del proyecto (POM).

Instalar el paquete

Abra el archivo pom.xml en el editor de texto. Agregue el siguiente elemento de dependencia al grupo de dependencias.

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

Instalación del marco de la aplicación

Abra /src/main/java/com/communication/quickstart/App.java en un editor de texto, agregue directivas de importación y quite la instrucción System.out.println("Hello world!");:

package com.communication.quickstart;

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

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

Creación del cliente de correo electrónico con autenticación

Hay algunas opciones diferentes disponibles para autenticar un cliente de correo electrónico.

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

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

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

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

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

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

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

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

Por simplicidad, este artículo utiliza cadenas de conexión, pero en entornos de producción, recomendamos usar principales de servicio.

Envío de correo electrónico básico

Puede redactar un mensaje de correo electrónico mediante el EmailMessage objeto en el SDK.

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

Haga estas sustituciones en el código:

• Reemplace <emailalias@emaildomain.com> por la dirección de correo electrónico a la que quiere enviar un mensaje.
• Reemplace <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> por la dirección MailFrom del dominio comprobado.

Para enviar el mensaje de correo electrónico, llame a la función beginSend desde EmailClient.

Duration MAIN_THREAD_WAIT_TIME = Duration.ofSeconds(30);

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

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

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

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

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

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

    PollResponse<EmailSendResult> pollResponse = null;

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

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

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

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

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

Ejecución del código

1. Vaya al directorio que contiene el pom.xml archivo y compile el proyecto mediante el mvn comando .

   mvn compile
   

2. Compile el paquete.

   mvn package
   

3. Ejecute el siguiente mvn comando para iniciar la aplicación.

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

Código de ejemplo

Puede descargar la aplicación de ejemplo desde GitHub Azure Samples Send Email for Java

Comienza con Azure Communication Services utilizando el SDK de Email de Communication Services para Python para enviar mensajes de correo electrónico.

Descripción del modelo de objetos de correo electrónico

La plantilla de mensaje JSON y objeto de respuesta siguientes muestran algunas de las características principales del SDK de correo electrónico de Azure Communication Services para Python.

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

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

Los valores response.status se explican con más detalle en la tabla siguiente.

Requisitos previos

• Una cuenta de Azure con una suscripción activa. Cree una cuenta gratuita.
• Versión 3.7 o superiores de Python.
• Un recurso de Azure Email Communication Services creado y listo con un dominio aprovisionado. Cree un recurso de comunicación por correo electrónico.
• Un recurso de Azure Communication Services activo conectado a un dominio de correo electrónico y su cadena de conexión. Conecte un dominio de correo electrónico comprobado para enviar correo electrónico.

Completar este artículo conlleva un pequeño costo de unos pocos centavos de USD o menos en su cuenta de Azure.

Comprobación de requisitos previos

• En una ventana de terminal o de comandos, ejecute python --version para comprobar que Python está instalado.
• Para ver los dominios comprobados con su recurso de correo electrónico Email Communication Services, inicie sesión en Azure Portal. Busque el recurso Email Communication Services y abra la pestaña Aprovisionar dominios en el panel de navegación izquierdo.

Configuración del entorno de la aplicación

Para configurar un entorno a fin de enviar correos electrónicos, siga los pasos descritos en las secciones siguientes.

Creación de una nueva aplicación de Python

1. Abra el terminal o la ventana de comandos. A continuación, use el siguiente comando para crear un entorno virtual y activarlo. Este comando crea un nuevo directorio para la aplicación.

   python -m venv email-quickstart
   

2. Vaya al directorio raíz del entorno virtual y actívelo con los siguientes comandos.

   cd email-quickstart
   .\Scripts\activate
   

3. Use un editor de texto para crear un archivo denominado send-email.py en el directorio raíz del proyecto y agregue la estructura del programa, incluido el control de excepciones básico.

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

En las secciones siguientes, agregará todo el código fuente de este inicio rápido al archivo send-email.py que ha creado.

Instalar el paquete

Mientras sigue en el directorio de la aplicación, instale el paquete del SDK de correo electrónico de Azure Communication Services para Python con el siguiente comando.

pip install azure-communication-email

Creación del cliente de correo electrónico con autenticación

Hay algunas opciones diferentes disponibles para autenticar un cliente de correo electrónico:

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

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

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

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

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

email_client = EmailClient(endpoint, key);

Por simplicidad, este artículo utiliza cadenas de conexión, pero en entornos de producción, recomendamos usar principales de servicio.

Envío de correo electrónico básico

Enviar un mensaje de correo electrónico

Para enviar un mensaje de correo electrónico, debe hacer lo siguiente:

• Construya el mensaje con los siguientes valores:
  • senderAddress: una dirección de correo electrónico de remitente válida, que se encuentra en el campo MailFrom en el panel de información general del dominio vinculado al recurso de Servicios de Comunicación por Correo Electrónico.
  • recipients: un objeto con una lista de destinatarios de correo electrónico y opcionalmente, listas de destinatarios de correo electrónico CC & BCC.
  • content: un objeto que contiene el asunto y, opcionalmente, el texto sin formato o el contenido HTML de un mensaje de correo electrónico.
• Llame al método begin_send, que devuelve el resultado de la operación.

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

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

Haga estas sustituciones en el código:

• Reemplace <emailalias@emaildomain.com> por la dirección de correo electrónico a la que quiere enviar un mensaje.
• Reemplace <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> por la dirección MailFrom del dominio comprobado.

Obtención del estado de la entrega del correo electrónico

Podemos sondear el estado de la entrega de correo electrónico estableciendo un bucle en el objeto de estado de la operación devuelto desde el método EmailClient begin_send :

POLLER_WAIT_TIME = 10

try:
    email_client = EmailClient.from_connection_string(connection_string)

    poller = email_client.begin_send(message);

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

        poller.wait(POLLER_WAIT_TIME)
        time_elapsed += POLLER_WAIT_TIME

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

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

except Exception as ex:
    print(ex)

Ejecución del código

Ejecute la aplicación desde el directorio de la aplicación con el comando python.

python send-email.py

Código de ejemplo

Puede descargar la aplicación de ejemplo desde GitHub Azure Samples "Send email for Python" (Envío de correo electrónico en Python)

Requisitos previos

• Una cuenta de Azure con una suscripción activa o también puede crear una cuenta de Azure de forma gratuita.

• Un recurso activo de Azure Communication Services o crear un recurso de Communication Services.

• Un recurso de Azure Logic Apps activo (aplicación lógica) y un flujo de trabajo, o cree un nuevo recurso de aplicación lógica y flujo de trabajo con el desencadenador que desee usar. Actualmente, el conector de Azure Communication Services para Correo Electrónico solo proporciona acciones, por lo que el flujo de trabajo de la aplicación de lógica requiere al menos un desencadenador. Puede crear un recurso de aplicación lógica Consumo o Estándar.

• Un recurso de correo electrónico de Azure Communication Services con un dominio configurado o un dominio personalizado.

• Un recurso Azure Communication Services conectado a un dominio de correo electrónico de Azure.

Enviar correo electrónico

Para agregar un nuevo paso al flujo de trabajo mediante el conector de correo electrónico de Azure Communication Services, siga estos pasos:

1. En el diseñador, abra el flujo de trabajo de la aplicación lógica.

   Consumo

   1. En el paso en el que quiera agregar la nueva acción, seleccione Nuevo paso. Como alternativa, para agregar la nueva acción entre pasos, mueva el puntero sobre la flecha entre esos pasos, seleccione el signo más (+) y seleccione Agregar una acción.

   2. En el cuadro de búsqueda Elegir una operación, seleccione Premium. En el cuadro de búsqueda, escriba Correo electrónico de comunicación de Azure.

   3. En la lista de acciones, seleccione Enviar correo electrónico.

      

   Estándar

   1. En el paso en el que quiera agregar la nueva acción, seleccione el signo más (+). Como alternativa, para agregar la nueva acción entre pasos, mueva el puntero sobre la flecha entre esos pasos, seleccione el signo más (+) y seleccione Agregar una acción.

   2. En el cuadro de búsqueda Agregar una acción, seleccione Premium en la lista desplegable de ejecución. En el cuadro de búsqueda, escriba Correo electrónico de comunicación de Azure.

   3. En la lista de acciones, seleccione Enviar correo electrónico.

2. Proporcione un nombre para la conexión.

3. Escriba la cadena de conexión para el recurso de Azure Communications Service. Para buscar esta cadena, siga estos pasos:

   1. En Azure Portal, abra el recurso de Azure Communication Service.

   2. En el menú de recursos, en Configuración, seleccione Claves y copie la cadena de conexión.

      

4. Seleccione Crear cuando haya terminado.

5. En el campo Desde, use la dirección de correo electrónico que configuró en los requisitos previos. Escriba los valores de los campos Destinatario, Asunto y Mensaje, por ejemplo:

   

6. Guarde el flujo de trabajo. En la barra de herramientas del diseñador, seleccione Save (Guardar).

Prueba del flujo de trabajo

En función de si tiene un flujo de trabajo de Consumo o Estándar, inicie manualmente el flujo de trabajo:

• Consumo: en la barra de herramientas del diseñador, seleccione Ejecutar desencadenador>Ejecutar.
• Estándar: en el menú del flujo de trabajo, seleccione Información general. En la barra de herramientas, seleccione Ejecutar desencadenador>Ejecutar.

El flujo de trabajo crea un usuario, emite un token de acceso para ese usuario y, a continuación, quita y elimina al usuario. Puede comprobar las salidas de estas acciones después de que el flujo de trabajo se ejecute correctamente.

Debería obtener un correo electrónico en la dirección especificada. También puede usar la acción Obtener estado del mensaje de correo electrónico para comprobar el estado de los correos electrónicos enviados a través de la acción Enviar correo electrónico. Para más acciones, revise la documentación de referencia del conector de correo electrónico de Azure Communication Services.

Limpieza de recursos de flujo de trabajo

Para limpiar el flujo de trabajo y el recurso de la aplicación lógica, así como los recursos relacionados, revise cómo limpiar los recursos de la aplicación lógica Consumo o cómo limpiar los recursos de la aplicación lógica Estándar.

Introducción a Azure Communication Services mediante el módulo de comunicación de Azure PowerShell para enviar mensajes de correo electrónico.

Completar este artículo conlleva un pequeño costo de unos pocos centavos de USD o menos en su cuenta de Azure.

Requisitos previos

• Una cuenta de Azure con una suscripción activa. Cree una cuenta gratuita.
• Un recurso de Azure Email Communication Services creado y listo con un dominio aprovisionado. Cree un recurso de comunicación por correo electrónico.
• Un recurso de Azure Communication Services activo conectado a un dominio de correo electrónico y su cadena de conexión. Conecte un dominio de correo electrónico comprobado para enviar correo electrónico.
• La versión de Azure PowerShell más reciente.

Comprobación de requisitos previos

• En windows PowerShell, ejecute el Get-Module -ListAvailable -Name Az.Communication comando para comprobar si el módulo de comunicación está instalado.
• Para ver los dominios comprobados con su recurso de correo electrónico Email Communication Services, inicie sesión en Azure Portal. Ubique su recurso Servicios de Comunicación por Correo Electrónico y abra la pestaña Aprovisionar dominios en el panel de navegación izquierdo.

Configurar

Instalación del módulo de comunicación

Instale el módulo azure Communication Services para Azure PowerShell mediante el Install-Module -Name Az.Communication comando .

Install-Module -Name Az.Communication

Después de instalar el módulo Comunicación, ejecute el comando Get-Command -Module Az.Communication para obtener todos los módulos de comunicación.

Get-Command -Module Az.Communication

Enviar un mensaje de correo electrónico

Poner en cola un mensaje de correo electrónico que se enviará a uno o varios destinatarios con solo campos obligatorios.

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

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

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

Haga estas sustituciones en el código:

• Reemplace <yourEndpoint> por el punto de conexión.
• Reemplace <emailalias@emaildomain.com> por la dirección de correo electrónico a la que quiere enviar un mensaje.
• Reemplace <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> por la dirección MailFrom del dominio comprobado.

Poner en cola un mensaje de correo electrónico para enviarlo a uno o varios destinatarios con todos los campos.

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

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

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

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

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

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

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

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

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

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

Haga estas sustituciones en el código:

• Reemplace <yourEndpoint> por el punto de conexión.
• Reemplace <emailalias@emaildomain.com> and <emailalias1@emaildomain.com> por las direcciones de correo electrónico a las que desea enviar un mensaje.
• Reemplace <file path> and <image file path> por las rutas de archivo reales de los adjuntos que desea enviar.
• Reemplace <text/plain> and <image/png> por los tipos de contenido adecuados para los archivos adjuntos.
• Reemplace <test.txt> and <inline-attachment.png> por los nombres de tus archivos adjuntos.
• Reemplace <inline-attachment> por Content-ID para los datos adjuntos insertados.
• Reemplace <emailbccalias@emaildomain.com> por la dirección de correo electrónico a la que desea enviar el mensaje como BCC.
• Reemplace <emailccalias@emaildomain.com> por la dirección de correo electrónico a la que desea enviar el mensaje como CC.
• Reemplace <emailreplytoalias@emaildomain.com> por la dirección de correo electrónico a la que desea enviar las respuestas.
• Reemplace <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> por la dirección MailFrom del dominio comprobado.

Parámetros opcionales

Los siguientes parámetros opcionales están disponibles en Azure PowerShell.

• ContentHtml se puede usar para especificar el cuerpo HTML del correo electrónico.

• ContentPlainText se usa para especificar el cuerpo de texto sin formato del correo electrónico.

• Attachment establece la lista de datos adjuntos de correo electrónico. Este parámetro acepta una matriz de rutas de acceso de archivo o objetos adjuntos. Limitamos el tamaño total de una solicitud de correo electrónico, incluidos los datos adjuntos normales e insertados, a 10 MB.

• Header encabezados de correo electrónico personalizados que se van a pasar y establece el nivel de importancia del correo electrónico (alto, normal o bajo).

• RecipientBcc matriz de destinatarios para el campo BCC.

• RecipientCc matriz de destinatarios para el campo CC.

• ReplyTo matriz de direcciones de correo electrónico en las que se envían las respuestas de los destinatarios.

• UserEngagementTrackingDisabled indica si el seguimiento de involucración del usuario debe deshabilitarse para esta solicitud si la configuración de seguimiento de involucración del usuario de nivel de recurso ya estaba habilitada en el plano de control.

También puede usar una lista de destinatarios con RecipientCc y RecipientBcc similar a RecipientTo. Es necesario que haya al menos un destinatario en RecipientTo o RecipientCc o RecipientBcc.