Envoyer un e-mail en utilisant Azure Communication Services

Prise en main d’Azure Communication Services à l’aide de Communication Services Essayez l’e-mail pour envoyer des messages électroniques.

Prérequis

• Compte Azure avec un abonnement actif. Créez un compte gratuitement.
• La dernière version de la bibliothèque de client .NET Core pour votre système d’exploitation.
• Une ressource Azure Email Communication Services créée et prête avec un domaine provisionné Bien démarrer avec la création d’une ressource Email Communication
• Une ressource Communication Services active connectée au domaine de courrier. Connectez un domaine de messagerie vérifié pour envoyer un e-mail.

Le fait d’effectuer les étapes de cet article entraîne un coût minime de quelques centimes de dollar USD ou moins sur votre compte Azure.

Envoyer un e-mail à l’aide de Try Email

Essayer l’e-mail vous aide à lancer l’envoi d’e-mails aux destinataires souhaités à l’aide d’Azure Communication Services et à vérifier la configuration de votre application pour envoyer des e-mails. Il permet également de démarrer le développement de votre notification par e-mail avec l’extrait de code dans le langage de votre choix.

Pour envoyer un message à un destinataire et spécifier l’objet et le corps du message :

1. Dans la page de présentation d’une ressource Azure Communication Services approvisionnée, cliquez sur Essayer l’adresse e-mail dans le volet de navigation de gauche sous Email.

   

2. Sélectionnez l’un des domaines vérifiés dans la liste déroulante.

   

3. Composez l’e-mail à envoyer.

   • Entrez l’adresse e-mail du destinataire
   • Entrez l'objet
   • Écrivez le corps de l’e-mail

   

4. Cliquez sur Envoyer.

   

5. E-mail envoyé avec succès.

   

6. Vous pouvez également copier l’exemple d’extrait de code pour envoyer un e-mail à utiliser dans votre exemple de projet pour envoyer des notifications.

   • Sélectionnez le langage de votre choix

   • Cliquez sur Insérer ma connexion

   • Cliquez sur Copier

     

7. L’extrait de code d’un e-mail est maintenant prêt à être utilisé dans votre projet de notification.

Commencez avec Azure Communication Services en utilisant l’extension de communication Azure CLI pour envoyer des e-mails.

Le fait d’effectuer les étapes de cet article entraîne un coût minime de quelques centimes de dollar USD ou moins sur votre compte Azure.

Prérequis

• Compte Azure avec un abonnement actif. Créez un compte gratuitement.
• Une ressource Azure Email Communication Services créée et prête avec un domaine provisionné. Créez une ressource de communication par e-mail.
• Une ressource Azure Communication Services active connectée à un domaine de courrier et sa chaîne de connexion. Connectez un domaine de messagerie vérifié pour envoyer un e-mail.
• La dernière version d’Azure CLI.

Vérification du prérequis

• Dans un terminal ou une fenêtre de commande, exécutez la commande az --version pour vérifier qu’Azure CLI et l’extension de communication sont installés.
• Pour voir les domaines vérifiés avec votre ressource Email Communication Services, connectez-vous au portail Azure. Localisez votre ressource Email Communication Services, puis ouvrez l’onglet Provisionner des domaines dans le volet de navigation gauche.

Configuration

Ajouter l’extension

Ajoutez l’extension Azure Communication Services pour Azure CLI à l’aide de la commande az extension.

az extension add --name communication

Connectez-vous à Azure CLI

Connectez-vous à Azure CLI. Vous pouvez vous connecter en exécutant la commande az login à partir du terminal et fournir vos informations d’identification.

Stocker votre chaîne de connexion dans une variable d’environnement

Vous pouvez configurer la variable d’environnement AZURE_COMMUNICATION_CONNECTION_STRING pour utiliser les opérations de clés d’Azure CLI sans devoir utiliser --connection_string pour passer la chaîne de connexion. Pour configurer une variable d’environnement, ouvrez une fenêtre de console, puis sélectionnez votre système d’exploitation dans les onglets suivants. Remplacez <connectionString> par votre chaîne de connexion.

setx AZURE_COMMUNICATION_CONNECTION_STRING "<yourConnectionString>"

export AZURE_COMMUNICATION_CONNECTION_STRING="<connectionString>"

export AZURE_COMMUNICATION_CONNECTION_STRING="<connectionString>"

Envoyer un e-mail

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

Apportez ces remplacements dans le code :

• Remplacez <yourConnectionString> par votre chaîne de connexion.
• Remplacez <emailalias@emaildomain.com> par l’adresse e-mail à laquelle vous souhaitez envoyer un message.
• Remplacez <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> par l’adresse MailFrom de votre domaine vérifié.

Cette commande effectue également une interrogation sur messageId et retourne le statut de la remise d’e-mail. L’état peut être l’une des valeurs suivantes :

Paramètres facultatifs

Les paramètres facultatifs suivants sont disponibles dans Azure CLI.

• --html peut être utilisé au lieu de --text pour le corps de l’e-mail html.

• --importance définit le type d’importance de l’e-mail. Les valeurs connues sont les suivantes : high (haute), normal et low (faible). La valeur par défaut est normal.

• --to définit la liste des destinataires de courrier électronique.

• --cc définit les adresses e-mail de copie carbone.

• --bcc définit les adresses e-mail de copie carbone invisibles.

• --reply-to définit l’adresse e-mail à laquelle répondre.

• --disable-tracking indique si le suivi de l’engagement utilisateur doit être désactivé pour cette demande.

• --attachments définit la liste des pièces jointes aux e-mails.

• --attachment-types définit la liste des types de pièces jointes d’e-mail, dans le même ordre de pièces jointes.

Vous pouvez également utiliser une liste de destinataires avec --cc et --bcc similaire à --to. Il doit y avoir au moins un destinataire dans --to ou --cc ou --bcc.

Commencez avec Azure Communication Services en utilisant la bibliothèque de client Communication Services C# Email pour envoyer des e-mails.

Comprendre le modèle objet de l’e-mail

Les classes et les interfaces suivantes gèrent certaines des principales fonctionnalités de la bibliothèque de client Azure Communication Services Email pour C#.

EmailSendResult renvoie l’état suivant sur l’opération de messagerie effectuée.

Prérequis

• Compte Azure avec un abonnement actif. Créez un compte gratuitement.
• La dernière version de la bibliothèque de client .NET Core pour votre système d’exploitation.
• Ressource Azure Email Communication Services créée et prête avec un domaine provisionné Créer une ressource de communication par e-mail.
• Une ressource Communication Services active connectée au domaine de courrier électronique et à une chaîne de connexion. Créez et gérez les ressources du service de communication par e-mail.

Le fait d’effectuer les étapes de cet article entraîne un coût minime de quelques centimes de dollar USD ou moins sur votre compte Azure.

Vérification du prérequis

• Dans une fenêtre de terminal ou de commande, exécutez la commande dotnet pour vérifier que la bibliothèque de client .NET est installée.
• Pour voir les sous-domaines associés à votre ressource Email Communication Services, connectez-vous au portail Azure, localisez votre ressource Email Communication Services, puis ouvrez l’onglet Provisionner des domaines dans le volet de navigation gauche.

Créer une application C#

Dans une fenêtre de console (par exemple cmd, PowerShell ou Bash), utilisez la commande dotnet new pour créer une application console avec le nom EmailQuickstart. Cette commande crée un projet C# « Hello World » simple avec un seul fichier source : Program.cs.

dotnet new console -o EmailQuickstart

Remplacez votre répertoire par le dossier d’application que vous venez de créer, puis utilisez la commande dotnet build pour compiler votre application.

cd EmailQuickstart
dotnet build

Installer le package

Dans le répertoire de l’application, installez le package de la bibliothèque de client Azure Communication Services Email pour .NET en utilisant la commande dotnet add package.

dotnet add package Azure.Communication.Email

Créer le client de messagerie avec l’authentification

Ouvrez Program.cs et remplacez le code existant par les instructions suivantes pour ajouter using des directives pour inclure l’espace Azure.Communication.Email de noms et un point de départ pour l’exécution de votre programme.

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

    }
  }
}

Il existe différentes options disponibles pour authentifier un client de messagerie :

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

Commencez avec Azure Communication Services à utiliser la bibliothèque cliente JavaScript d'Azure Communication Services pour l'envoi d'e-mails.

Comprendre le modèle objet de messagerie

Les classes et interfaces suivantes gèrent certaines fonctionnalités de la bibliothèque de client de messagerie Azure Communication Services pour JavaScript.

EmailSendResult renvoie l’état suivant sur l’opération de messagerie effectuée.

Prérequis

• Node.js (~14).
• Compte Azure avec un abonnement actif. Créez un compte gratuitement.
• Une ressource Azure Email Communication Services créée et prête avec un domaine provisionné. Créez une ressource de communication par e-mail.
• Une ressource Azure Communication Services active connectée à un domaine de courrier et sa chaîne de connexion. Créez et gérez les ressources du service de communication par e-mail.

Le fait d’effectuer les étapes de cet article entraîne un coût minime de quelques centimes de dollar USD ou moins sur votre compte Azure.

Vérification du prérequis

• Dans une fenêtre de terminal ou de commande, exécutez node --version pour vérifier que Node.js est installé.
• Pour voir les domaines vérifiés avec votre ressource Email Communication Services, connectez-vous au portail Azure, localisez votre ressource Email Communication Services, puis ouvrez l’onglet Provisionner des domaines dans le volet de navigation gauche.

Configurer l’environnement d’application

Créer une application Node.js

Tout d’abord, ouvrez votre terminal ou fenêtre de commande. Créez ensuite un répertoire pour votre application, puis accédez-y.

mkdir email-quickstart && cd email-quickstart

Exécutez npm init -y pour créer un fichier package.json avec les paramètres par défaut.

npm init -y

Utilisez un éditeur de texte pour créer un fichier appelé send-email.js dans le répertoire racine du projet. Modifiez la propriété main dans package.json en send-email.js. La section suivante montre comment ajouter le code source de cet article au fichier nouvellement créé.

Installer le package

Utilisez la commande npm install pour installer la bibliothèque de client Azure Communication Services Email pour JavaScript.

npm install @azure/communication-email --save

L’option --save répertorie la bibliothèque en tant que dépendance dans votre fichier package.json.

Créer le client de messagerie avec l’authentification

Il existe différentes options disponibles pour authentifier un client de messagerie :

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

Par souci de simplicité, cet article utilise des chaînes de connexion, mais, dans des environnements de production, nous recommandons l’utilisation de principaux de service.

Envoi d’e-mail de base

Envoyer un e-mail

Pour envoyer un e-mail, appelez la beginSend fonction à partir du EmailClient. Cette méthode renvoie un observateur qui vérifie l’état de l’opération et récupère le résultat une fois terminée.

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

Apportez ces remplacements dans le code :

• Remplacez <emailalias@emaildomain.com> par l’adresse e-mail à laquelle vous souhaitez envoyer un message.
• Remplacez <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> par l’adresse MailFrom de votre domaine vérifié.

Exécuter le code

Utilisez la commande node pour exécuter le code que vous avez ajouté au fichier send-email.js.

node ./send-email.js

Exemple de code

Vous pouvez télécharger l’exemple d’application à partir de GitHub Azure Samples Envoyer un e-mail pour JavaScript.

Commencez avec Azure Communication Services en utilisant le SDK Communication Services Java Email pour envoyer des e-mails.

Comprendre le modèle objet de messagerie

Les classes et interfaces suivantes gèrent certaines des principales fonctionnalités du Kit de développement logiciel (SDK) Azure Communication Services Email pour Java.

EmailSendResult renvoie l’état suivant sur l’opération de messagerie effectuée.

Prérequis

• Compte Azure avec un abonnement actif. Créez un compte gratuitement.
• Java Development Kit (JDK) version 8 ou ultérieure.
• Apache Maven.
• Une ressource Communication Services déployée et la chaîne de connexion. Pour plus d’informations, consultez Créer une ressource Communication Services.
• Pour commencer à envoyer des e-mails, créez une ressource Azure Email Communication Services.
• Pour configurer une identité gérée pour un environnement de développement, consultez Autoriser l'accès avec une identité gérée.

Le fait d’effectuer les étapes de cet article entraîne un coût minime de quelques centimes de dollar USD ou moins sur votre compte Azure.

Vérification du prérequis

• Dans une fenêtre de terminal ou de commande, exécutez mvn -v pour vérifier que Maven est installé.
• Pour voir les domaines vérifiés avec votre ressource Email Communication Services, connectez-vous au portail Azure. Recherchez votre ressource Email Communication Services et ouvrez l’onglet Approvisionner des domaines dans le volet de navigation gauche.

Configurer l’environnement d’application

Pour configurer un environnement afin d’envoyer des e-mails, effectuez les étapes décrites dans les sections suivantes.

Créer une application Java

Ouvrez votre terminal ou votre fenêtre Commande, puis accédez au répertoire dans lequel vous souhaitez créer votre application Java. Exécutez la commande suivante pour générer le projet Java à partir du modèle 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"

L’objectif generate crée un répertoire qui porte le même nom que la valeur artifactId. Sous ce répertoire, le répertoire src/main/java contient le code source du projet, le répertoire src/test/java contient la source de test et le fichier pom.xml est le modèle objet du projet (POM, Project Object Model).

Installer le package

Ouvrez le fichier pom.xml dans votre éditeur de texte. Ajoutez l’élément dépendance suivant au groupe de dépendances.

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

Configurer le framework d’application

Ouvrez /src/main/java/com/communication/quickstart/App.java dans un éditeur de texte, ajoutez des directives d’importation, puis supprimez l’instruction 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.
    }
}

Création du client de messagerie avec l’authentification

Il existe différentes options disponibles pour authentifier un client e-mail.

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

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

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

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

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

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

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

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

Par souci de simplicité, cet article utilise des chaînes de connexion, mais, dans des environnements de production, nous recommandons l’utilisation de principaux de service.

Envoi d’e-mail de base

Vous pouvez composer un e-mail à l’aide de l’objet EmailMessage dans le Kit de développement logiciel (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.");

Apportez ces remplacements dans le code :

• Remplacez <emailalias@emaildomain.com> par l’adresse e-mail à laquelle vous souhaitez envoyer un message.
• Remplacez <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> par l’adresse MailFrom de votre domaine vérifié.

Pour envoyer l’e-mail, appelez la fonction beginSend à partir de 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());
}

Exécuter le code

1. Accédez au répertoire qui contient le pom.xml fichier et compilez le projet à l’aide de la mvn commande.

   mvn compile
   

2. Générez le package.

   mvn package
   

3. Exécutez la commande suivante mvn pour démarrer l’application.

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

Exemple de code

Vous pouvez télécharger l’application d’exemple depuis GitHub Azure Samples Send Email for Java

Commencez avec Azure Communication Services en utilisant le SDK Communication Services Python Email pour envoyer des e-mails.

Présentation du modèle objet de l’e-mail

Le modèle de message JSON et l’objet de réponse suivants illustrent certaines des principales fonctionnalités du kit de développement logiciel (SDK) d’e-mail Azure Communication Services pour 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.
    }
}

Les valeurs response.status sont expliquées plus en détail dans le tableau suivant.

Prérequis

• Compte Azure avec un abonnement actif. Créez un compte gratuitement.
• Python 3.7+.
• Une ressource Azure Email Communication Services créée et prête avec un domaine provisionné. Créez une ressource de communication par e-mail.
• Une ressource Azure Communication Services active connectée à un domaine de courrier et sa chaîne de connexion. Connectez un domaine de messagerie vérifié pour envoyer un e-mail.

Le fait d’effectuer les étapes de cet article entraîne un coût minime de quelques centimes de dollar USD ou moins sur votre compte Azure.

Vérification du prérequis

• Dans une fenêtre de terminal ou de commande, exécutez la commande python --version pour vérifier que Python est installé.
• Pour voir les domaines vérifiés avec votre ressource Email Communication Services, connectez-vous au portail Azure. Localisez votre ressource Email Communication Services, puis ouvrez l’onglet Provisionner des domaines dans le volet de navigation gauche.

Configurer l’environnement d’application

Pour configurer un environnement afin d’envoyer des e-mails, effectuez les étapes décrites dans les sections suivantes.

Créer une application Python

1. Ouvrez votre fenêtre de terminal ou de commande. Ensuite, la commande suivante permet de créer un environnement virtuel et de l’activer. Cette commande crée un répertoire pour votre application.

   python -m venv email-quickstart
   

2. Accédez au répertoire racine de l’environnement virtuel et activez-le à l’aide des commandes suivantes.

   cd email-quickstart
   .\Scripts\activate
   

3. Utilisez un éditeur de texte pour créer un fichier appelé send-email.py dans le répertoire racine du projet, puis ajoutez la structure du programme, notamment la gestion des exceptions de base.

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

Dans les sections suivantes, vous ajoutez tout le code source pour ce guide de démarrage rapide au fichier send-email.py que vous créez.

Installer le package

Toujours dans le répertoire de l’application, installez le package SDK Azure Communication Services Email pour Python en utilisant la commande suivante.

pip install azure-communication-email

Création du client de messagerie avec l’authentification

Il existe différentes options disponibles pour authentifier un client de messagerie :

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

Par souci de simplicité, cet article utilise des chaînes de connexion, mais, dans des environnements de production, nous recommandons l’utilisation de principaux de service.

Envoi d’e-mail de base

Envoyer un e-mail

Pour envoyer un e-mail, vous devez :

• Créez le message avec les valeurs suivantes :
  • senderAddress : adresse e-mail valide de l’expéditeur, qui se trouve dans le champ MailFrom dans le volet vue d’ensemble du domaine lié à votre ressource e-mail Communication Services.
  • recipients : objet avec une liste de destinataires d’e-mails et éventuellement des listes de destinataires d’e-mails CC et BCC.
  • content : objet contenant le sujet, et éventuellement le contenu en texte clair ou HTML, d’un e-mail.
• Appelez la begin_send méthode, qui retourne le résultat de l’opération.

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

Apportez ces remplacements dans le code :

• Remplacez <emailalias@emaildomain.com> par l’adresse e-mail à laquelle vous souhaitez envoyer un message.
• Remplacez <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> par l’adresse MailFrom de votre domaine vérifié.

Obtenir l’état de la remise de l’e-mail

Nous pouvons interroger l’état de la remise de courrier en définissant une boucle sur l’objet d’état de l’opération retourné par la méthode 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)

Exécuter le code

Exécutez l’application à partir de votre répertoire d’application avec la commande python.

python send-email.py

Exemple de code

Vous pouvez télécharger l’application modèle depuis GitHub Azure Samples Envoyer un e-mail avec Python

Prérequis

• Un compte Azure avec un abonnement actif ou créez gratuitement un compte Azure.

• Une ressource Azure Communication Services active ou créez une ressource Communication Services.

• Une ressource (application logique) et un workflow Azure Logic Apps actifs, ou créez une ressource et un workflow d’application logique avec le déclencheur de votre choix. Actuellement, le connecteur Azure Communication Services Email ne fournit que des actions, de sorte que le flux de travail de votre application logique nécessite au minimum un déclencheur. Vous pouvez créer une ressource d’application logique de type Consommation ou Standard.

• Une ressource Azure Communication Services Email avec un domaine configuré ou un domaine personnalisé.

• Une ressource Azure Communication Services connectée à un domaine Azure Email.

Envoyer un e-mail

Pour ajouter une nouvelle étape à votre workflow à l’aide du connecteur Azure Communication Services Email, suivez ces étapes :

1. Dans le concepteur, ouvrez votre flux de travail d’application logique.

   Consommation

   1. Sous l’étape à laquelle vous souhaitez ajouter la nouvelle action, sélectionnez Nouvelle étape. Vous pouvez également ajouter la nouvelle action entre des étapes, déplacer votre pointeur sur la flèche située entre ces étapes, sélectionner le signe plus (+), puis sélectionner Ajouter une action.

   2. Sous la zone de recherche Choisir une opération, sélectionnez Premium. Dans la zone de recherche, entrez E-mail de communication Azure.

   3. Dans la liste d’actions, sélectionnez Envoyer un e-mail.

      

   Standard

   1. Sous l’étape à laquelle vous souhaitez ajouter la nouvelle action, sélectionnez le signe plus (+). Vous pouvez également ajouter la nouvelle action entre des étapes, déplacer votre pointeur sur la flèche située entre ces étapes, sélectionner le signe plus (+), puis sélectionner Ajouter une action.

   2. Sous la zone de recherche Ajouter une action, sélectionnez Premium dans la liste déroulante runtime. Dans la zone de recherche, entrez E-mail de communication Azure.

   3. Dans la liste d’actions, sélectionnez Envoyer un e-mail.

2. Entrez un nom pour la connexion.

3. Entrez la chaîne de connexion pour votre ressource Azure Communications Service. Pour trouver cette chaîne, suivez ces étapes :

   1. Sur le portail Azure, ouvrez votre ressource Azure Communication Service.

   2. Dans le menu de ressources, sous Paramètres, sélectionnez Clés, puis copiez la chaîne de connexion.

      

4. Sélectionnez Créer lorsque vous avez terminé.

5. Dans le champ De, utilisez l’adresse e-mail que vous avez configurée dans les prérequis. Entrez les valeurs des champs Destinataire, Objet et Corps, par exemple :

   

6. Enregistrez votre flux de travail. Dans la barre d’outils du Concepteur, sélectionnez Enregistrer.

Tester votre workflow

En fonction du workflow dont vous disposez (Consommation ou Standard), démarrez manuellement votre workflow comme suit :

• Consommation : Dans la barre d’outils du concepteur, sélectionnez Exécuter le déclencheur>Exécuter.
• Standard : Dans le menu du workflow, sélectionnez Vue d’ensemble. Dans la barre d’outils, sélectionnez Exécuter le déclencheur>Exécuter.

Le flux de travail crée un utilisateur, émet un jeton d’accès pour cet utilisateur, puis enlève l’utilisateur et le supprime. Vous pouvez vérifier les sorties de ces actions une fois que le flux de travail s’exécute correctement.

Vous devez recevoir un e-mail à l’adresse spécifiée. De même, vous pouvez utiliser l’action Obtenir l’état des messages électroniques pour vérifier l’état des e-mails envoyés via l’action Envoyer un e-mail. Pour découvrir plus d’actions, consultez la documentation sur le connecteur Azure Communication Services Email.

Nettoyer des ressources de flux de travail

Pour nettoyer votre ressource d’application logique, votre workflow et les ressources associées, consultez Nettoyer des ressources d’application logique de consommation ou Nettoyer des ressources d’application logique standard.

Prise en main d’Azure Communication Services à l’aide du module de communication Azure PowerShell pour envoyer des messages électroniques.

Le fait d’effectuer les étapes de cet article entraîne un coût minime de quelques centimes de dollar USD ou moins sur votre compte Azure.

Prérequis

• Compte Azure avec un abonnement actif. Créez un compte gratuitement.
• Une ressource Azure Email Communication Services créée et prête avec un domaine provisionné. Créez une ressource de communication par e-mail.
• Une ressource Azure Communication Services active connectée à un domaine de courrier et sa chaîne de connexion. Connectez un domaine de messagerie vérifié pour envoyer un e-mail.
• La dernière version d’Azure PowerShell.

Vérification du prérequis

• Dans une fenêtre PowerShell, exécutez la Get-Module -ListAvailable -Name Az.Communication commande pour vérifier si le module de communication est installé.
• Pour voir les domaines vérifiés avec votre ressource Email Communication Services, connectez-vous au portail Azure. Recherchez votre ressource Email Communication Services et ouvrez l’onglet Approvisionner des domaines dans le volet de navigation gauche.

Configurer

Installer le module de communication

Installez le module Azure Communication Services pour Azure PowerShell à l’aide de la Install-Module -Name Az.Communication commande.

Install-Module -Name Az.Communication

Après avoir installé le module Communication, exécutez la commande Get-Command -Module Az.Communication pour obtenir tous les modules de communication.

Get-Command -Module Az.Communication

Envoyer un e-mail

Mettre en file d’attente un message électronique à envoyer à un ou plusieurs destinataires avec uniquement les champs obligatoires.

$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>"

Apportez ces remplacements dans le code :

• Remplacez <yourEndpoint> par votre point de terminaison.
• Remplacez <emailalias@emaildomain.com> par l’adresse e-mail à laquelle vous souhaitez envoyer un message.
• Remplacez <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> par l’adresse MailFrom de votre domaine vérifié.

Mettre en file d’attente un message électronique à envoyer à un ou plusieurs destinataires avec tous les champs.

$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>"

Apportez ces remplacements dans le code :

• Remplacez <yourEndpoint> par votre point de terminaison.
• Remplacez <emailalias@emaildomain.com> and <emailalias1@emaildomain.com> par les adresses e-mail auxquelles vous souhaitez envoyer un message.
• Remplacez <file path> and <image file path> par les chemins d’accès réels des pièces jointes que vous souhaitez envoyer.
• Remplacez <text/plain> and <image/png> par les types de contenu appropriés pour vos pièces jointes.
• Remplacez <test.txt> and <inline-attachment.png> par les noms de fichiers de vos pièces jointes.
• Remplacez <inline-attachment> par l’ID de contenu de votre pièce jointe inline.
• Remplacez <emailbccalias@emaildomain.com> par l’adresse e-mail à laquelle vous souhaitez envoyer le message en tant que Cci.
• Remplacez <emailccalias@emaildomain.com> par l’adresse e-mail à laquelle vous souhaitez envoyer le message en tant que Cc.
• Remplacez <emailreplytoalias@emaildomain.com> par l’adresse e-mail à laquelle vous souhaitez recevoir des réponses.
• Remplacez <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> par l’adresse MailFrom de votre domaine vérifié.

Paramètres facultatifs

Les paramètres facultatifs suivants sont disponibles dans Azure PowerShell.

• ContentHtml peut être utilisé pour spécifier le corps de l’e-mail au format HTML.

• ContentPlainText permet de spécifier le corps de l’e-mail en texte brut.

• Attachment définit la liste des pièces jointes aux e-mails. Ce paramètre accepte un tableau de chemins d’accès ou d’objets de pièce jointe. Nous limitons la taille totale d’une demande de courrier électronique, y compris les pièces jointes régulières et inline, à 10 Mo.

• Header personnalise les en-têtes de courrier à transmettre et définit le niveau d’importance de l’e-mail (élevé, normal ou faible).

• RecipientBcc Tableau de destinataires pour le champ Cci.

• RecipientCc Tableau de destinataires pour le champ Cc.

• ReplyTo tableau d'adresses e-mail vers lesquelles les réponses des destinataires sont envoyées.

• UserEngagementTrackingDisabled indique si le suivi de l’engagement utilisateur doit être désactivé pour cette demande si le paramètre de suivi de l’engagement utilisateur au niveau de la ressource a déjà été activé dans le plan de contrôle.

Vous pouvez également utiliser une liste de destinataires avec RecipientCc et RecipientBcc similaire à RecipientTo. Il doit y avoir au moins un destinataire dans RecipientTo ou RecipientCc ou RecipientBcc.