Freigeben über

Senden einer E-Mail mithilfe von Azure Communication Services

In dieser Schnellstartanleitung wird beschrieben, wie E-Mails mithilfe unserer E-Mail-SDKs gesandt werden.

Steigen Sie in Azure Communication Services ein, indem Sie ein Try-Email von Communication Services nutzen, um E-Mails zu senden.

Voraussetzungen

Um die Anleitungen in diesem Artikel zu befolgen, fallen in Ihrem Azure-Konto geringfügige Kosten von höchstens einigen wenigen Cent (USD) an.

Senden einer E-Mail mithilfe von Try Email

Testen Sie E-Mail, um mit dem Senden von E-Mails an die gewünschten Empfänger mit Azure Communication Services zu beginnen und die Konfiguration ihrer Anwendung zum Senden von E-Mails zu überprüfen. Außerdem können Sie mit Codeschnipseln in Ihrer bevorzugten Sprache mit dem Entwickeln von E-Mail-Benachrichtigungen beginnen.

So senden Sie eine Nachricht an einen Empfänger, und geben Sie den Betreff und den Textkörper der Nachricht an:

  1. Klicken Sie auf der Übersichtsseite einer bereitgestellten Azure Communication Service-Ressource im linken Navigationsbereich unter „E-Mail“ auf Try Email.

    Screenshot des linken Navigationsbereichs für Try Email.

  2. Wählen Sie in der Dropdownliste eine der überprüften Domänen aus.

    Screenshot zeigt die überprüfte Domäne in der Dropdownliste.

  3. Verfassen Sie die zu sendende E-Mail.

    • Geben Sie die E-Mail-Adresse des Empfängers oder der Empfängerin ein.
    • Geben Sie den Betreff ein.
    • Schreiben Sie den E-Mail-Text.

    Screenshot, der zeigt, wie Sie eine der überprüften E-Mail-Domänen filtern und auswählen, um eine Verbindung herzustellen.

  4. Klicken Sie auf Senden.

    Screenshot, der zeigt, dass eine der überprüften E-Mail-Domänen jetzt verbunden ist.

  5. E-Mails wurden erfolgreich gesendet.

    Screenshot des erfolgreichen Sendens einer E-Mail.

  6. Sie können auch den Beispielcodeausschnitt kopieren, um eine E-Mail zur Verwendung in Ihrem Beispielprojekt zum Senden von Benachrichtigungen zu senden.

    • Wählen Sie die gewünschte Sprache aus.

    • Klicken Sie auf „Meine Verbindung einfügen“.

    • Klicken Sie auf „Kopieren“.

      Screenshot des Codeschnipsels zum Senden einer E-Mail.

  7. Der E-Mail-Codeschnipsel kann jetzt in Ihrem Benachrichtigungsprojekt verwendet werden.

Beginnen Sie mit Azure Communication Services, indem Sie die Kommunikationserweiterung der Azure-Befehlszeilenschnittstelle verwenden, um E-Mail-Nachrichten zu senden.

Um die Anleitungen in diesem Artikel zu befolgen, fallen in Ihrem Azure-Konto geringfügige Kosten von höchstens einigen wenigen Cent (USD) an.

Voraussetzungen

Prüfen der Voraussetzungen

  • Führen Sie in einem Terminal- oder Befehlsfenster den Befehl az --version aus, um zu überprüfen, ob die Azure-Befehlszeilenschnittstelle und die Kommunikationserweiterung installiert sind.
  • Um die mit Ihrer Communication Services-Ressource für E-Mails verifizierten Domänen anzuzeigen, melden Sie sich beim Azure-Portal an. Suchen Sie Ihre E-Mail-Communication Services-Ressource, und öffnen Sie im linken Navigationsbereich die Registerkarte Domänen bereitstellen.

Einrichten

Hinzufügen der Erweiterung

Fügen Sie die Azure Communication Services-Erweiterung für Azure CLI mithilfe des Befehls az extension hinzu.

az extension add --name communication

Anmelden bei Azure CLI

Sie müssen sich bei der Azure-Befehlszeilenschnittstelle anmelden. Sie können sich beim Ausführen des az login-Befehls vom Terminal anmelden und Ihre Anmeldeinformationen bereitstellen.

Speichern der Verbindungszeichenfolge in einer Umgebungsvariablen

Sie können die Umgebungsvariable AZURE_COMMUNICATION_CONNECTION_STRING so konfigurieren, dass Azure CLI-Schlüsselvorgänge verwendet werden, ohne dass Sie --connection_string zum Übergeben der Verbindungszeichenfolge verwenden müssen. Öffnen Sie zum Konfigurieren einer Umgebungsvariablen ein Konsolenfenster, und wählen Sie über die folgenden Registerkarten Ihr Betriebssystem aus. Ersetzen Sie <connectionString> durch Ihre Verbindungszeichenfolge.

Hinweis

Speichern Sie Ihre Verbindungszeichenfolge nicht als unverschlüsselte Umgebungsvariable für Produktionsumgebungen. Diese Methode dient nur zu Testzwecken. Für Produktionsumgebungen müssen Sie neue Verbindungszeichenfolgen generieren. Wir empfehlen Ihnen, Verbindungszeichenfolgen zu verschlüsseln und sie regelmäßig zu ändern.

setx AZURE_COMMUNICATION_CONNECTION_STRING "<yourConnectionString>"

Nachdem Sie die Umgebungsvariable hinzugefügt haben, müssen Sie möglicherweise alle ausgeführten Programme neu starten, die die Umgebungsvariable lesen müssen, einschließlich des Konsolenfensters. Wenn Sie beispielsweise Visual Studio als Editor verwenden, müssen Sie Visual Studio neu starten, bevor Sie das Beispiel ausführen.

Senden einer E-Mail-Nachricht

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

Führen Sie im Code die folgenden Ersetzungen durch:

  • Ersetzen Sie <yourConnectionString> durch Ihre Verbindungszeichenfolge.
  • Ersetzen Sie <emailalias@emaildomain.com> durch die E-Mail-Adresse, an die Sie eine Nachricht senden möchten.
  • Ersetzen Sie <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> durch die MailFrom-Adresse Ihrer überprüften Domäne.

Dieser Befehl führt auch eine Abfrage von messageId durch und gibt den Status der E-Mail-Zustellung zurück. Der Status kann einer der folgenden Werte sein:

Statusname BESCHREIBUNG
Nicht gestartet Wir senden diesen Status derzeit nicht von unserem Dienst.
Laufen Der E-Mail-Sendevorgang wird derzeit ausgeführt und verarbeitet.
Erfolgreich Der E-Mail-Sendevorgang wurde ohne Fehler abgeschlossen, und die E-Mail wurde zur Zustellung versandt. Der detaillierte Status zur E-Mail-Übermittlung über diese Phase hinaus kann entweder über Azure Monitor oder über Azure Event Grid abgerufen werden. Erfahren Sie, wie Sie E-Mail-Ereignisse abonnieren.
Fehlgeschlagen Der E-Mail-Sendevorgang konnte nicht erfolgreich ausgeführt werden, und es ist ein Fehler aufgetreten. Die E-Mail wurde nicht gesendet. Das Ergebnis enthält ein Fehlerobjekt mit weiteren Details zum Fehlergrund.

Optionale Parameter

Die folgenden optionalen Parameter sind in der Azure-Befehlszeilenschnittstelle verfügbar.

  • --html kann anstelle von --text für HTML-E-Mail-Text verwendet werden.

  • --importance legt den Relevanztyp für die E-Mail fest. Bekannte Werte sind: „Hoch“, „Normal“ und „Niedrig“. Der Standardwert ist „Normal“.

  • --to legt die Liste der E-Mail-Empfänger fest.

  • --cc legt E-Mail-Adressen für Empfänger*innen fest, die eine Kopie erhalten.

  • --bcc legt E-Mail-Adressen für Empfänger*innen fest, die eine Blindkopie erhalten.

  • --reply-to legt die E-Mail-Adresse für Antworten fest.

  • --disable-tracking gibt an, ob die Nachverfolgung des Benutzereinsatzes für diese Anforderung deaktiviert werden muss.

  • --attachments legt die Liste der E-Mail-Anhänge fest.

  • --attachment-types legt die Liste der E-Mail-Anhangtypen in der Reihenfolge der Anhänge fest.

Sie können auch eine Empfängerliste mit --cc und --bcc ähnlich wie bei --to verwenden. Es muss mindestens ein Empfänger in --to, --cc oder --bcc vorhanden sein.

Machen Sie die ersten Schritte mit Azure Communication Services, indem Sie die C#-Clientbibliothek für E-Mail von Communication Services nutzen, um E-Mail-Nachrichten zu senden.

Tipp

Starten Sie Ihre E-Mail-Sendeerfahrung mit Azure Communication Services, indem Sie direkt zum Beispielcode Einfaches Senden von E-Mails and Erweitertes Senden von E-Mails auf GitHub überspringen.

Grundlegendes zum E-Mail-Objektmodell

Die folgenden Klassen und Schnittstellen werden für einige der wichtigsten Features der C#-Clientbibliothek für E-Mail von Azure Communication Services verwendet.

Name BESCHREIBUNG
E-Mail-Adresse Diese Klasse enthält eine E-Mail-Adresse und eine Option für einen Anzeigenamen.
E-Mail-Anhang In dieser Klasse wird eine E-Mail-Anlage erstellt, indem eine eindeutige ID, eine MIME-Typ-Zeichenfolge für die E-Mail-Anlage, binäre Daten für Inhalte und eine optionale Inhalts-ID akzeptiert werden, um sie als Inline-Anlage zu definieren.
E-Mail-Client Diese Klasse ist für sämtliche E-Mail-Funktionen erforderlich. Sie instanziieren sie mit Ihrer Verbindungszeichenfolge und verwenden sie zum Senden von E-Mail-Nachrichten.
E-Mail-Client-Optionen Diese Klasse kann der EmailClient-Instanziierung für eine bestimmte API-Version hinzugefügt werden.
E-Mail-Inhalt Diese Klasse enthält den Betreff und Text der E-Mail-Nachricht. Sie müssen mindestens eine der Inhaltsoptionen „PlainText“ oder „Html“ angeben.
EmailCustomHeader Diese Klasse ermöglicht das Hinzufügen eines Name-Wert-Paars für einen benutzerdefinierten Header. Die Wichtigkeit von E-Mails kann auch über diese Header mithilfe des Headernamens „x-priority“ oder „x-msmail-priority“ angegeben werden.
E-Mail-Nachricht Diese Klasse kombiniert Absender, Inhalt und Empfänger. Benutzerdefinierte Header, Anlagen und Antwort-E-Mail-Adressen können optional hinzugefügt werden.
E-Mail-Empfänger Diese Klasse enthält Listen von EmailAddress-Objekten für Empfänger*innen der E-Mail-Nachricht, einschließlich optionaler Listen für CC- und BCC-Empfänger*innen.
EmailSendOperation Diese Klasse stellt den asynchronen E-Mail-Sendevorgang dar und wird vom API-Aufruf des E-Mail-Sendens zurückgegeben.
ErgebnisDesE-MailVersands Diese Klasse enthält die Ergebnisse des E-Mail-Sendevorgangs. Es verfügt über eine Vorgangs-ID, einen Vorgangsstatus und ein Fehlerobjekt (falls zutreffend).

EmailSendResult gibt den folgenden Status für den ausgeführten E-Mail-Vorgang zurück.

Der Status BESCHREIBUNG
Nicht gestartet Wir senden diesen Status derzeit nicht von unserem Dienst.
Laufen Der E-Mail-Sendevorgang wird derzeit ausgeführt und verarbeitet.
Erfolgreich Der E-Mail-Sendevorgang wird ohne Fehler abgeschlossen, und die E-Mail wird zur Zustellung freigegeben. Der detaillierte Status zur E-Mail-Übermittlung über diese Phase hinaus kann entweder über Azure Monitor oder über Azure Event Grid abgerufen werden. Informationen zum Abonnieren von E-Mail-Ereignissen
Fehlgeschlagen Der E-Mail-Sendevorgang war nicht erfolgreich, und es ist ein Fehler aufgetreten. Die E-Mail wurde nicht gesendet. Das Ergebnis enthält ein Fehlerobjekt mit weiteren Details zum Fehlergrund.

Voraussetzungen

Um die Anleitungen in diesem Artikel zu befolgen, fallen in Ihrem Azure-Konto geringfügige Kosten von höchstens einigen wenigen Cent (USD) an.

Hinweis

Sie können auch eine E-Mail von unserer eigenen überprüften Domäne senden. Hinzufügen benutzerdefinierter überprüfter Domänen zu Email Communication Service

Prüfen der Voraussetzungen

  • Führen Sie in einem Terminal- oder Befehlsfenster den Befehl dotnet aus, um sich zu vergewissern, dass die .NET-Clientbibliothek installiert ist.
  • Melden Sie sich zum Anzeigen der Ihrer E-Mail-Communication Service-Ressource zugeordneten Unterdomänen beim Azure-Portal an. Suchen Sie nach Ihrer E-Mail-Communication Service-Ressource, und öffnen Sie im linken Navigationsbereich die Registerkarte Domänen bereitstellen.

Erstellen einer neuen C#-Anwendung

Verwenden Sie in einem Konsolenfenster (z. B. cmd, PowerShell oder Bash) den Befehl dotnet new zum Erstellen einer neuen Konsolen-App mit dem Namen EmailQuickstart. Dieser Befehl erstellt ein einfaches „Hallo Welt“-C#-Projekt mit einer einzigen Quelldatei: Program.cs.

dotnet new console -o EmailQuickstart

Wechseln Sie zum neu erstellten App-Ordner, und verwenden Sie den Befehl dotnet build, um Ihre Anwendung zu kompilieren.

cd EmailQuickstart
dotnet build

Installieren des Pakets

Installieren Sie, während Sie sich noch im Anwendungsverzeichnis befinden, das .NET-Paket für die E-Mail-Clientbibliothek von Azure Communication Services mit dem Befehl dotnet add package.

dotnet add package Azure.Communication.Email

Erstellen des E-Mail-Clients mit Authentifizierung

Öffnen Sie Program.cs, und ersetzen Sie den vorhandenen Code durch folgendes, um Direktiven zum Einschließen des using Namespaces und einen Ausgangspunkt für die Ausführung für Ihr Programm hinzuzufügenAzure.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)
    {

    }
  }
}

Für die Authentifizierung eines E-Mail-Clients stehen verschiedene Optionen zur Verfügung:

Öffnen Sie Program.cs in einem Texteditor und ersetzen Sie den Rumpf der Main-Methode durch Code, um ein EmailClient mit Ihrer Verbindungszeichenfolge zu initialisieren. Im folgenden Code wird die Verbindungszeichenfolge für die Ressource aus einer Umgebungsvariablen namens COMMUNICATION_SERVICES_CONNECTION_STRING abgerufen. Informationen zur Verwaltung der Verbindungszeichenfolge Ihrer Ressource.

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

Hinweis

Es wird nicht empfohlen, die manuelle Abfrage (Senden von E-Mails mit asynchroner Statusabfragung) zum Senden von E-Mails zu verwenden.

Einfaches Senden von E-Mails

Erstellen Ihrer E-Mail-Nachricht

Zum Senden einer E-Mail-Nachricht müssen Sie diese Schritte ausführen:

  • Den Betreff und Textkörper Ihrer E-Mail festlegen.
  • Ihre Absenderadresse definieren. Verfassen Sie Ihre E-Mail-Nachricht mit den Absenderinformationen, die Sie von der MailFrom-Adresse Ihrer überprüften Domäne erhalten.
  • Die Empfängeradresse definieren.
  • Die SendAsync-Methode aufrufen. Fügen Sie in Main am Ende der Methode den folgenden Code hinzu:

Fügen Sie Ihre Domänendetails hinzu, und ändern Sie den Inhalt und die Empfängerdaten wie gewünscht.


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

Senden und Abrufen des E-Mail-Sendestatus

Wenn Sie SendAsync mit Azure.WaitUntil.Started aufrufen, kehrt Ihre Methode nach dem Starten des Vorgangs zurück. Die Methode gibt ein EmailSendOperation-Objekt zurück. Sie können die UpdateStatusAsync-Methode aufrufen, um den E-Mail-Betriebsstatus zu aktualisieren.

Das zurückgegebene EmailSendOperation-Objekt enthält ein EmailSendStatus-Objekt, das Folgendes enthält:

  • Aktueller Status des E-Mail-Sendevorgangs.
  • Ein Fehlerobjekt mit Fehlerdetails, wenn sich der aktuelle Status in einem fehlerbehafteten Zustand befindet.

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

Führen Sie die Anwendung mit dem Befehl dotnet run aus dem Anwendungsverzeichnis aus.

dotnet run

Beispielcode

Sie können die Beispiel-App von GitHub herunterladen.

Machen Sie die ersten Schritte mit Azure Communication Services, indem Sie die JavaScript-Clientbibliothek für E-Mail von Communication Services nutzen, um E-Mail-Nachrichten zu senden.

Tipp

Starten Sie Ihre E-Mail-Sendeerfahrung mit Azure Communication Services mit dem Beispielcode "Einfaches Senden von E-Mails " und "Erweiterter E-Mail-Versand " auf GitHub.

Grundlegendes zum E-Mail-Objektmodell

Die folgenden Klassen und Schnittstellen behandeln einige Features der Azure Communication Services-E-Mail-Clientbibliothek für JavaScript.

Name BESCHREIBUNG
E-Mail-Adresse Diese Klasse enthält eine E-Mail-Adresse und eine Option für einen Anzeigenamen.
E-Mail-Anhang In dieser Klasse wird eine E-Mail-Anlage erstellt, indem eine eindeutige ID, eine MIME-Typ-Zeichenfolge für die E-Mail-Anlage, binäre Daten für Inhalte und eine optionale Inhalts-ID akzeptiert werden, um sie als Inline-Anlage zu definieren.
E-Mail-Client Diese Klasse ist für sämtliche E-Mail-Funktionen erforderlich. Sie instanziieren sie mit Ihrer Verbindungszeichenfolge und verwenden sie zum Senden von E-Mail-Nachrichten.
E-Mail-Client-Optionen Diese Klasse kann der EmailClient-Instanziierung für eine bestimmte API-Version hinzugefügt werden.
E-Mail-Inhalt Diese Klasse enthält den Betreff und Text der E-Mail-Nachricht. Sie müssen mindestens eine der Inhaltsoptionen „PlainText“ oder „Html“ angeben.
EmailCustomHeader Diese Klasse ermöglicht das Hinzufügen eines Name-Wert-Paars für einen benutzerdefinierten Header. Die Wichtigkeit von E-Mails kann auch über diese Kopfzeilen mithilfe des Kopfzeilennamens x-priority oder x-msmail-priority festgelegt werden.
E-Mail-Nachricht Diese Klasse kombiniert Absender, Inhalt und Empfänger. Benutzerdefinierte Header, Anlagen und Antwort-E-Mail-Adressen können optional hinzugefügt werden.
E-Mail-Empfänger Diese Klasse enthält Listen von EmailAddress-Objekten für Empfänger*innen der E-Mail-Nachricht, einschließlich optionaler Listen für CC- und BCC-Empfänger*innen.
ErgebnisDesE-MailVersands Diese Klasse enthält die Ergebnisse des E-Mail-Sendevorgangs. Es verfügt über eine Vorgangs-ID, einen Vorgangsstatus und ein Fehlerobjekt (falls zutreffend).
E-MailSendStatus Diese Klasse stellt den Statussatz eines E-Mail-Sendevorgangs dar.

EmailSendResult gibt den folgenden Status für den ausgeführten E-Mail-Vorgang zurück.

Statusname BESCHREIBUNG
isStarted (Englisch) Gibt „true“ zurück, wenn der E-Mail-Sendevorgang aktuell ausgeführt und verarbeitet wird.
isCompleted Gibt "true" zurück, wenn der E-Mail-Sendevorgang ohne Fehler abgeschlossen wurde und die E-Mail zur Zustellung freigegeben wurde. Der detaillierte Status zur E-Mail-Übermittlung über diese Phase hinaus kann entweder über Azure Monitor oder über Azure Event Grid abgerufen werden. Informationen zum Abonnieren von E-Mail-Ereignissen
Ergebnis Eigenschaft, die vorhanden ist, wenn der E-Mail-Sendevorgang beendet wird.
Fehler Eigenschaft, die vorhanden ist, wenn der E-Mail-Sendevorgang nicht erfolgreich war und ein Fehler aufgetreten ist. Die E-Mail wurde nicht gesendet. Das Ergebnis enthält ein Fehlerobjekt mit weiteren Details zum Fehlergrund.

Voraussetzungen

Um die Anleitungen in diesem Artikel zu befolgen, fallen in Ihrem Azure-Konto geringfügige Kosten von höchstens einigen wenigen Cent (USD) an.

Hinweis

Sie können auch eine E-Mail von unserer eigenen überprüften Domäne senden. Hinzufügen benutzerdefinierter überprüfter Domänen zu Email Communication Service

Prüfen der Voraussetzungen

  • Führen Sie in einem Terminal- oder Befehlsfenster node --version aus, um sich zu vergewissern, dass Node.js installiert ist.
  • Melden Sie sich zum Anzeigen der für Ihre E-Mail-Communication Service-Ressource überprüften Domänen beim Azure-Portal an. Suchen Sie nach Ihrer E-Mail-Communication Service-Ressource, und öffnen Sie im linken Navigationsbereich die Registerkarte Domänen bereitstellen.

Einrichten der Anwendungsumgebung

Erstellen einer neuen Node.js-Anwendung

Öffnen Sie zuerst Ihr Terminal oder Befehlsfenster. Erstellen Sie dann ein neues Verzeichnis für Ihre App, und navigieren Sie zu ihr.

mkdir email-quickstart && cd email-quickstart

Führen Sie npm init -y aus, um eine Datei package.json mit den Standardeinstellungen zu erstellen.

npm init -y

Verwenden Sie einen Text-Editor, um im Stammverzeichnis des Projekts eine Datei mit Namen send-email.js zu erstellen. Ändern Sie die main Eigenschaft in package.json zu send-email.js. Im folgenden Abschnitt wird veranschaulicht, wie Sie der neu erstellten Datei den Quellcode für diesen Artikel hinzufügen.

Installieren des Pakets

Verwenden Sie den Befehl npm install, um die JavaScript-Clientbibliothek für E-Mail von Azure Communication Services zu installieren.

npm install @azure/communication-email --save

Die Option --save listet die Bibliothek als Abhängigkeit in Ihrer Datei package.json auf.

Erstellen des E-Mail-Clients mit Authentifizierung

Für die Authentifizierung eines E-Mail-Clients stehen verschiedene Optionen zur Verfügung:

Importieren Sie EmailClient aus der Client-Bibliothek und instanziieren Sie es mit Ihrer Verbindungszeichenfolge.

Verwenden Sie den folgenden Code, um die Verbindungszeichenfolge für die Ressource aus einer Umgebungsvariablen abzurufen, die über das Dotenv-Paket benannt ist COMMUNICATION_SERVICES_CONNECTION_STRING . Verwenden Sie den Befehl npm install, um das dotenv-Paket zu installieren. Informationen zur Verwaltung der Verbindungszeichenfolge Ihrer Ressource.

npm install dotenv

Fügen Sie den folgenden Code zu send-email.js hinzu:

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

Aus Gründen der Einfachheit werden in diesem Artikel Verbindungszeichenfolgen verwendet, jedoch empfehlen wir in Produktionsumgebungen die Verwendung von Dienstprinzipalen.

Einfaches Senden von E-Mails

Senden einer E-Mail-Nachricht

Rufen Sie zum Senden einer E-Mail-Nachricht die beginSend-Funktion aus der EmailClientauf. Diese Methode gibt einen Poller zurück, der den Status des Vorgangs überprüft und das Ergebnis abruft, sobald er abgeschlossen ist.


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

Führen Sie im Code die folgenden Ersetzungen durch:

  • Ersetzen Sie <emailalias@emaildomain.com> durch die E-Mail-Adresse, an die Sie eine Nachricht senden möchten.
  • Ersetzen Sie <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> durch die MailFrom-Adresse Ihrer überprüften Domäne.

Ausführen des Codes

Verwenden Sie den node-Befehl, um den Code auszuführen, den Sie der Datei send-email.js hinzugefügt haben.

node ./send-email.js

Beispielcode

Sie können die Beispiel-App von GitHub Azure Samples Send Email for JavaScript herunterladen.

Steigen Sie in Azure Communication Services ein, indem Sie das Java-E-Mail-SDK von Communication Services nutzen, um E-Mails zu senden.

Tipp

Starten Sie Ihre E-Mail-Sendeerfahrung mit Azure Communication Services, indem Sie den Beispielcode " Einfaches Senden von E-Mails " und "Erweiterte E-Mail-Senden " auf GitHub verwenden.

Grundlegendes zum E-Mail-Objektmodell

Die folgenden Klassen und Schnittstellen behandeln einige der wichtigsten Features des Azure Communication Services Email SDK für Java.

Name BESCHREIBUNG
E-Mail-Adresse Diese Klasse enthält eine E-Mail-Adresse und eine Option für einen Anzeigenamen.
E-Mail-Anhang In dieser Schnittstelle wird eine E-Mail-Anlage erstellt, indem eine eindeutige ID, eine MIME-Typ-Zeichenfolge für die E-Mail-Anlage, eine Zeichenfolge mit Inhaltsbytes und eine optionale Inhalts-ID akzeptiert werden, um sie als Inline-Anlage zu definieren.
E-Mail-Client Diese Klasse ist für sämtliche E-Mail-Funktionen erforderlich. Sie instanziieren sie mit Ihrer Verbindungszeichenfolge und verwenden sie zum Senden von E-Mail-Nachrichten.
E-Mail-Nachricht Diese Klasse kombiniert Absender, Inhalt und Empfänger. Benutzerdefinierte Header, Anlagen und Antwort-E-Mail-Adressen können optional hinzugefügt werden.
ErgebnisDesE-MailVersands Diese Klasse enthält die Ergebnisse des E-Mail-Sendevorgangs. Es verfügt über eine Vorgangs-ID, einen Vorgangsstatus und ein Fehlerobjekt (falls zutreffend).
E-MailSendStatus Diese Klasse stellt den Statussatz eines E-Mail-Sendevorgangs dar.

EmailSendResult gibt den folgenden Status für den ausgeführten E-Mail-Vorgang zurück.

Statusname BESCHREIBUNG
NOT_STARTED Wir senden diesen Status derzeit nicht von unserem Dienst.
IN_PROGRESS Der E-Mail-Sendevorgang wird derzeit ausgeführt und verarbeitet.
ERFOLGREICH_ABGESCHLOSSEN Der E-Mail-Sendevorgang wurde ohne Fehler abgeschlossen, und die E-Mail wurde zur Zustellung versandt. Der detaillierte Status zur E-Mail-Übermittlung über diese Phase hinaus kann entweder über Azure Monitor oder über Azure Event Grid abgerufen werden. Informationen zum Abonnieren von E-Mail-Ereignissen
FEHLERHAFT Der E-Mail-Sendevorgang war nicht erfolgreich, und es ist ein Fehler aufgetreten. Die E-Mail wurde nicht gesendet. Das Ergebnis enthält ein Fehlerobjekt mit weiteren Details zum Fehlergrund.

Voraussetzungen

Um die Anleitungen in diesem Artikel zu befolgen, fallen in Ihrem Azure-Konto geringfügige Kosten von höchstens einigen wenigen Cent (USD) an.

Hinweis

Sie können auch eine E-Mail aus unserer eigenen überprüften Domäne senden , um E-Mail-Kommunikationsdienstressourcen zu erstellen und zu verwalten.

Prüfen der Voraussetzungen

  • Führen Sie in einem Terminal- oder Befehlsfenster mvn -v aus, um sich zu vergewissern, dass Maven installiert ist.
  • Um die mit Ihrer Communication Services-Ressource für E-Mails verifizierten Domänen anzuzeigen, melden Sie sich beim Azure-Portal an. Suchen Sie Ihre E-Mail-Kommunikationsdienste-Ressource, und öffnen Sie die Registerkarte " Domänen bereitstellen " im linken Navigationsbereich.

Einrichten der Anwendungsumgebung

Um eine Umgebung zum Senden von E-Mails einzurichten, müssen Sie die Schritte in den folgenden Abschnitten ausführen.

Erstellen einer neuen Java-Anwendung

Öffnen Sie Ihr Terminal- oder Befehlsfenster, und navigieren Sie zu dem Verzeichnis, in dem Sie Ihre Java-Anwendung erstellen möchten. Führen Sie den folgenden Befehl aus, um das Java-Projekt aus der Vorlage „maven-archetype-quickstart“ zu generieren.

mvn archetype:generate -DarchetypeArtifactId="maven-archetype-quickstart" -DarchetypeGroupId="org.apache.maven.archetypes" -DarchetypeVersion="1.4" -DgroupId="com.communication.quickstart" -DartifactId="communication-quickstart"

Das generate-Ziel erstellt ein Verzeichnis, das den gleichen Namen wie der artifactId-Wert besitzt. In diesem Verzeichnis enthält das Verzeichnis src/main/java den Quellcode des Projekts. Das Verzeichnis src/test/java enthält die Testquelle, und die Datei pom.xml ist das Projektobjektmodell (POM) des Projekts.

Installieren des Pakets

Öffnen Sie die Datei pom.xml in Ihrem Text-Editor. Fügen Sie der Gruppe „Abhängigkeiten“ das folgende Abhängigkeitselement hinzu.

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

Einrichten des App-Frameworks

Öffnen Sie /src/main/java/com/communication/quickstart/App.java in einem Text-Editor, fügen Sie Importanweisungen hinzu, und entfernen Sie die System.out.println("Hello world!");-Anweisung:

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

Erstellen des E-Mail-Clients mit Authentifizierung

Für die Authentifizierung eines E-Mail-Clients stehen verschiedene Optionen zur Verfügung:

Um einen Client zu authentifizieren, instanziieren Sie EmailClient mit Ihrer Verbindungszeichenfolge. Informationen zur Verwaltung der Verbindungszeichenfolge Ihrer Ressource. Sie können den Client auch mit einem beliebigen benutzerdefinierten HTTP-Client initialisieren, der die com.azure.core.http.HttpClient-Schnittstelle implementiert.

Um einen synchronen Client zu instanziieren, fügen Sie der main-Methode den folgenden Code hinzu:

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

Um einen asynchronen Client zu instanziieren, fügen Sie der main-Methode den folgenden Code hinzu:

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

Aus Gründen der Einfachheit werden in diesem Artikel Verbindungszeichenfolgen verwendet, jedoch empfehlen wir in Produktionsumgebungen die Verwendung von Dienstprinzipalen.

Einfaches Senden von E-Mails

Sie können eine E-Mail-Nachricht mithilfe des EmailMessage Objekts im SDK verfassen.

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

Führen Sie im Code die folgenden Ersetzungen durch:

  • Ersetzen Sie <emailalias@emaildomain.com> durch die E-Mail-Adresse, an die Sie eine Nachricht senden möchten.
  • Ersetzen Sie <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> durch die MailFrom-Adresse Ihrer überprüften Domäne.

Rufen Sie zum Senden der E-Mail-Nachricht die beginSend-Funktion über EmailClient auf.

Das Aufrufen beginSend des Synchronisierungsclients gibt ein SyncPoller Objekt zurück, das verwendet werden kann, um den Status des Vorgangs zu überprüfen und das Ergebnis nach Abschluss abzurufen. Die anfängliche Anforderung zum Senden einer E-Mail beginnt, sobald die beginSend Methode aufgerufen wird. Beim Senden einer E-Mail handelt es sich um einen zeitintensiven Vorgang. Es ist wichtig zu beachten, dass die getFinalResult()-Methode für den Poller ein blockierender Vorgang ist, bis ein Endzustand (SUCCESSFULLY_COMPLETED oder FAILED) erreicht ist. Es wird empfohlen, die manuelle Abfrage in einem Intervall auszuführen, das für Ihre Anwendungsanforderungen geeignet ist, wie im folgenden Beispiel gezeigt.

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

Ausführen des Codes

  1. Navigieren Sie mit dem pom.xml Befehl zu dem Verzeichnis, das die mvn Datei enthält, und kompilieren Sie das Projekt.

    mvn compile

  2. Erstellen Sie das Paket.

    mvn package

  3. Führen Sie den folgenden mvn Befehl aus, um die App zu starten.

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

Beispielcode

Sie können die Beispiel-App von GitHub Azure Samples Send Email for Java herunterladen.

Steigen Sie in Azure Communication Services ein, indem Sie das Python-E-Mail-SDK von Communication Services nutzen, um E-Mails zu senden.

Tipp

Starten Sie Ihre E-Mail-Sendeerfahrung mit Azure Communication Services, indem Sie direkt zum Beispielcode Einfaches Senden von E-Mails and Erweitertes Senden von E-Mails auf GitHub überspringen.

Grundlegendes zum E-Mail-Objektmodell

Die folgende JSON-Nachrichtenvorlage und das Antwortobjekt veranschaulichen einige der wichtigsten Features des E-Mail-SDK für Python von Azure Communication Services.

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

Die response.status-Werte werden in der folgenden Tabelle weiter erläutert.

Statusname BESCHREIBUNG
In Bearbeitung Der E-Mail-Sendevorgang wird derzeit ausgeführt und verarbeitet.
Erfolgreich Der E-Mail-Sendevorgang wurde ohne Fehler abgeschlossen, und die E-Mail wurde zur Zustellung versandt. Der detaillierte Status zur E-Mail-Übermittlung über diese Phase hinaus kann entweder über Azure Monitor oder über Azure Event Grid abgerufen werden. Informationen zum Abonnieren von E-Mail-Ereignissen
Fehlgeschlagen Der E-Mail-Sendevorgang war nicht erfolgreich, und es ist ein Fehler aufgetreten. Die E-Mail wurde nicht gesendet. Das Ergebnis enthält ein Fehlerobjekt mit weiteren Details zum Fehlergrund.

Voraussetzungen

Um die Anleitungen in diesem Artikel zu befolgen, fallen in Ihrem Azure-Konto geringfügige Kosten von höchstens einigen wenigen Cent (USD) an.

Hinweis

Wir können auch eine E-Mail von unserer eigenen verifizierten Domäne senden. Hinzufügen benutzerdefinierter überprüfter Domänen zu Email Communication Service

Prüfen der Voraussetzungen

  • Führen Sie in einem Terminal- oder Befehlsfenster den Befehl python --version aus, um sich zu vergewissern, dass Python installiert ist.
  • Um die mit Ihrer Communication Services-Ressource für E-Mails verifizierten Domänen anzuzeigen, melden Sie sich beim Azure-Portal an. Suchen Sie Ihre E-Mail-Communication Services-Ressource, und öffnen Sie im linken Navigationsbereich die Registerkarte Domänen bereitstellen.

Einrichten der Anwendungsumgebung

Um eine Umgebung zum Senden von E-Mails einzurichten, müssen Sie die Schritte in den folgenden Abschnitten ausführen.

Erstellen einer neuen Python-Anwendung

  1. Öffnen Sie Ihr Terminal oder Befehlsfenster. Verwenden Sie dann den folgenden Befehl, um eine virtuelle Umgebung zu erstellen und zu aktivieren. Mit diesem Befehl wird ein neues Verzeichnis für Ihre App erstellt.

    python -m venv email-quickstart

  2. Navigieren Sie zum Stammverzeichnis der virtuellen Umgebung, und aktivieren Sie sie mit den folgenden Befehlen.

    cd email-quickstart
.\Scripts\activate

  3. Erstellen Sie mithilfe eines Text-Editors eine Datei mit dem Namen send-email.py im Stammverzeichnis des Projekts, und fügen Sie die Struktur für das Programm hinzu (einschließlich einer einfachen Ausnahmebehandlung).

    import os
from azure.communication.email import EmailClient

try:
    # Quickstart code goes here.
except Exception as ex:
    print('Exception:')
    print(ex)

In den folgenden Abschnitten fügen Sie den gesamten Quellcode aus diesem Schnellstart zur soeben erstellten Datei send-email.py hinzu.

Installieren des Pakets

Installieren Sie im Anwendungsverzeichnis mithilfe des folgenden Befehls das E-Mail-SDK von Azure Communication Services für Python.

pip install azure-communication-email

Erstellen des E-Mail-Clients mit Authentifizierung

Für die Authentifizierung eines E-Mail-Clients stehen verschiedene Optionen zur Verfügung:

Instanziieren Sie einen EmailClient mit Ihrer Verbindungszeichenfolge. Informationen zur Verwaltung der Verbindungszeichenfolge Ihrer Ressource.

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

Aus Gründen der Einfachheit werden in diesem Artikel Verbindungszeichenfolgen verwendet, jedoch empfehlen wir in Produktionsumgebungen die Verwendung von Dienstprinzipalen.

Einfaches Senden von E-Mails

Senden einer E-Mail-Nachricht

Zum Senden einer E-Mail-Nachricht müssen Sie diese Schritte ausführen:

  • Erstellen Sie die Nachricht mit den folgenden Werten:
    • senderAddress: Eine gültige E-Mail-Absenderadresse im Feld MailFrom im Übersichtsbereich der Domäne, die mit Ihrer Email Communication Services-Ressource verknüpft ist.
    • recipients: Ein Objekt mit einer Liste von E-Mail-Empfänger*innen und optional Listen von CC- und BCC-E-Mail-Empfänger*innen.
    • content: Ein Objekt, das den Betreff und optional den Klartext- oder HTML-Inhalt einer E-Mail-Nachricht enthält.
  • Rufen Sie die begin_send Methode auf, die das Ergebnis des Vorgangs zurückgibt.
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())

Führen Sie im Code die folgenden Ersetzungen durch:

  • Ersetzen Sie <emailalias@emaildomain.com> durch die E-Mail-Adresse, an die Sie eine Nachricht senden möchten.
  • Ersetzen Sie <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> durch die MailFrom-Adresse Ihrer überprüften Domäne.

Abrufen des Status der E-Mail-Übermittlung

Wir können den Status der E-Mail-Zustellung abfragen, indem wir eine Schleife für das Vorgangsstatusobjekt festlegen, das von der EmailClient-Methode begin_send zurückgegeben wird:

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)

Ausführen des Codes

Führen Sie die Anwendung mit dem Befehl python aus dem Anwendungsverzeichnis aus.

python send-email.py

Beispielcode

Sie können die Beispiel-App von GitHub Azure Samples Send email for Python herunterladen

Voraussetzungen

E-Mail senden

Um Ihrem Workflow mithilfe des Email-Connectors für Azure Communication Services einen neuen Schritt hinzuzufügen, führen Sie die folgenden Schritte durch:

  1. Öffnen Sie im Designer Ihren Logik-App-Workflow.

    Verbrauch

    1. Wählen Sie unter dem Schritt, in dem Sie die neue Aktion hinzufügen möchten, die Option Neuer Schritt aus. Alternativ können Sie die neue Aktion zwischen den Schritten hinzufügen, indem Sie den Mauszeiger über den Pfeil zwischen diesen Schritten bewegen, das Pluszeichen (+) und dann die Option Aktion hinzufügen auswählen.

    2. Wählen Sie unter dem Suchfeld Vorgang auswählen die Option Premium aus. Geben Sie im Suchfeld Azure-Kommunikations-E-Mail ein.

    3. Wählen Sie in der Aktionsliste E-Mail senden aus.

      Screenshot: Aktion „E-Mail senden“ des E-Mail-Connectors von Azure Communication Services.

    Norm

    1. Wählen Sie unter dem Schritt, in dem Sie die neue Aktion hinzufügen möchten, das Pluszeichen (+) aus. Alternativ können Sie die neue Aktion zwischen den Schritten hinzufügen, indem Sie den Mauszeiger über den Pfeil zwischen diesen Schritten bewegen, das Pluszeichen (+) und dann die Option Aktion hinzufügen auswählen.

    2. Wählen Sie unter dem Suchfeld Aktion hinzufügen im Runtime-Dropdownmenü Premium aus. Geben Sie im Suchfeld Azure-Kommunikations-E-Mail ein.

    3. Wählen Sie in der Aktionsliste E-Mail senden aus.

  2. Geben Sie einen Namen für die Verbindung an.

  3. Geben Sie die Verbindungszeichenfolge für Ihre Azure Communications Service-Ressource ein. Führen Sie die folgenden Schritte aus, um diese Zeichenfolge zu suchen:

    1. Öffnen Sie im Azure-Portal Ihre Azure Communication Service-Ressource.

    2. Wählen Sie im Ressourcenmenü unter Einstellungen die Option Schlüssel aus, und kopieren Sie die Verbindungszeichenfolge.

      Screenshot: Verbindungszeichenfolge von Azure Communication Services.

  4. Wählen Sie Erstellen, wenn Sie fertig sind.

  5. Verwenden Sie im Feld Von die E-Mail-Adresse, die Sie in den Voraussetzungen konfiguriert haben. Geben Sie die Werte für die Felder An E-Mail, Betreff und Text ein, beispielsweise:

    Screenshot: Eingabe für die Aktion „E-Mail senden“ des E-Mail-Connectors von Azure Communication Services.

  6. Speichern Sie den Workflow. Wählen Sie auf der Symbolleiste des Designers Speichern aus.

Testen Ihres Workflows

Je nachdem, ob Sie über einen Verbrauchs- oder Standardworkflow verfügen, starten Sie Ihren Workflow manuell:

  • Verbrauch: Wählen Sie auf der Symbolleiste des Designers Trigger ausführen>Ausführen aus.
  • Standard: Wählen Sie im Menü „Workflow“ die Option Übersicht aus. Wählen Sie auf der Symbolleiste Trigger ausführen>Ausführen aus.

Der Workflow erstellt einen Benutzer, gibt ein Zugriffstoken für diesen Benutzer aus und entfernt dann das Token und löscht den Benutzer. Sie können die Ausgaben dieser Aktionen überprüfen, nachdem der Workflow erfolgreich ausgeführt wurde.

Sie sollten eine E-Mail an die angegebene Adresse erhalten. Sie können auch die Aktion Status der E-Mail-Nachrichten abrufen verwenden, um den Status von E-Mails zu überprüfen, die über die Aktion E-Mail senden gesendet wurden. Weitere Aktionen finden Sie in der Dokumentation zum E-Mail-Connector von Azure Communication Services.

Bereinigen von Workflow-Ressourcen

Um die Logik-App-Ressource, den Workflow und die zugehörigen Ressourcen zu bereinigen, lesen Sie die Abschnitte Bereinigen der Verbrauchs-Logik-App-Ressourcen oder Bereinigen der Standard-Logik-App-Ressourcen.

Erste Schritte mit Azure Communication Services mithilfe des Azure PowerShell-Kommunikationsmoduls zum Senden von E-Mail-Nachrichten.

Um die Anleitungen in diesem Artikel zu befolgen, fallen in Ihrem Azure-Konto geringfügige Kosten von höchstens einigen wenigen Cent (USD) an.

Voraussetzungen

Prüfen der Voraussetzungen

  • Führen Sie in einer Windows PowerShell den Get-Module -ListAvailable -Name Az.Communication Befehl aus, um zu überprüfen, ob das Kommunikationsmodul installiert ist.
  • Um die mit Ihrer Communication Services-Ressource für E-Mails verifizierten Domänen anzuzeigen, melden Sie sich beim Azure-Portal an. Suchen Sie Ihre E-Mail-Kommunikationsdienste-Ressource, und öffnen Sie die Registerkarte " Domänen bereitstellen " im linken Navigationsbereich.

Einrichten

Installieren des Kommunikationsmoduls

Installieren Sie das Azure Communication Services-Modul für Azure PowerShell mit dem Install-Module -Name Az.Communication Befehl.

Install-Module -Name Az.Communication

Führen Sie nach der Installation des Kommunikationsmoduls den Befehl Get-Command -Module Az.Communication aus, um alle Kommunikationsmodule abzurufen.

Get-Command -Module Az.Communication

Senden einer E-Mail-Nachricht

Eine E-Mail-Nachricht in die Warteschlange stellen, die an einen oder mehrere Empfänger mit nur erforderlichen Feldern gesendet werden soll.

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

Führen Sie im Code die folgenden Ersetzungen durch:

  • Ersetzen Sie <yourEndpoint> durch Ihren Endpunkt.
  • Ersetzen Sie <emailalias@emaildomain.com> durch die E-Mail-Adresse, an die Sie eine Nachricht senden möchten.
  • Ersetzen Sie <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> durch die MailFrom-Adresse Ihrer überprüften Domäne.

Eine E-Mail-Nachricht in die Warteschlange stellen, die an einen oder mehrere Empfänger mit allen Feldern gesendet werden soll.

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

Führen Sie im Code die folgenden Ersetzungen durch:

  • Ersetzen Sie <yourEndpoint> durch Ihren Endpunkt.
  • Ersetzen Sie <emailalias@emaildomain.com> and <emailalias1@emaildomain.com> durch die E-Mail-Adressen, an die Sie eine Nachricht senden möchten.
  • Ersetzen Sie <file path> and <image file path> durch die eigentlichen Dateipfade der Anhänge, die Sie senden möchten.
  • Ersetzen Sie <text/plain> and <image/png> durch die entsprechenden Inhaltstypen für Ihre Anhänge.
  • Ersetzen Sie <test.txt> and <inline-attachment.png> durch die Dateinamen Ihrer Anhänge.
  • Ersetzen Sie <inline-attachment> durch die Inhalts-ID für Ihren Inline-Anhang.
  • Ersetzen Sie <emailbccalias@emaildomain.com> durch die E-Mail-Adresse, an die die Nachricht als BCC gesendet werden soll.
  • Ersetzen Sie <emailccalias@emaildomain.com> durch die E-Mail-Adresse, an die die Nachricht als CC gesendet werden soll.
  • Ersetzen Sie <emailreplytoalias@emaildomain.com> durch die E-Mail-Adresse, an die Antworten gesendet werden sollen.
  • Ersetzen Sie <donotreply@xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.azurecomm.net> durch die MailFrom-Adresse Ihrer überprüften Domäne.

Optionale Parameter

Die folgenden optionalen Parameter sind in Azure PowerShell verfügbar.

  • ContentHtml kann verwendet werden, um den HTML-Textkörper der E-Mail anzugeben.

  • ContentPlainText kann verwendet werden, um den Reintextkörper der E-Mail anzugeben.

  • Attachment legt die Liste der E-Mail-Anhänge fest. Dieser akzeptiert ein Array von Dateipfaden oder Anhangsobjekten. Wir beschränken die Gesamtgröße einer E-Mail-Anfrage, einschließlich regulärer und Inline-Anhänge, auf 10 MB.

  • Header benutzerdefinierte E-Mail-Header werden übergeben und die Wichtigkeitsstufe der E-Mail wird festgelegt (hoch, normal oder niedrig).

  • RecipientBcc Array der Empfänger für das BCC-Feld.

  • RecipientCc Array der Empfänger für das CC-Feld.

  • ReplyTo Array von E-Mail-Adressen, bei denen Empfängerantworten gesendet werden.

  • UserEngagementTrackingDisabled gibt an, ob die Benutzerbindungsnachverfolgung für diese Anforderung deaktiviert werden muss, wenn die Einstellung zur Nachverfolgung der Benutzerbindung auf Ressourcenebene bereits in der Steuerungsebene aktiviert wurde.

Sie können auch eine Empfängerliste mit RecipientCc und RecipientBcc ähnlich wie bei RecipientTo verwenden. Es muss mindestens ein Empfänger in RecipientTo, RecipientCc oder RecipientBcc vorhanden sein.

Problembehandlung

E-Mail-Zustellung

Zur Behebung von Problemen im Zusammenhang mit der E-Mail-Zustellung können Sie den Status der E-Mail-Zustellung abrufen, um Zustellungsdetails zu erfassen.

Wichtig

Das Erfolgsergebnis, das durch Abfragen des Sendestatus zurückgegeben wird, beweist nur, dass die E-Mail erfolgreich zur Zustellung abgesendet wurde. Weitere Informationen zum Status der Übermittlung am Empfängerende finden Sie in der Behandlung von E-Mail-Ereignissen.

E-Mail-Drosselung

Wenn Ihre Anwendung hängen bleibt, kann dies darauf zurückzuführen sein, dass E-Mails gedrosselt werden. Sie können Ebenenbeschränkungen über die Protokollierung oder durch Implementieren einer benutzerdefinierten Richtlinie behandeln.

Hinweis

Dieser Sandkasten soll Entwicklern beim Erstellen der Anwendung helfen. Sie können eine schrittweise Erhöhung des Sendevolumens anfordern, sobald die Anwendung einsatzbereit ist. Übermitteln Sie eine Supportanfrage, um das von Ihnen gewünschte Sendelimit zu erhöhen, wenn Sie ein Nachrichtenvolumen senden müssen, das die Ratenbegrenzungen überschreitet.

Bereinigen von Azure Communication Service-Ressourcen

Um ein Communication Services-Abonnement zu bereinigen und zu entfernen, können Sie die Ressource oder Ressourcengruppe löschen. Wenn Sie die Ressourcengruppe löschen, werden auch alle anderen zugeordneten Ressourcen gelöscht. Weitere Informationen zum Bereinigen von Ressourcen finden Sie hier.

Nächste Schritte

In diesem Artikel wird beschrieben, wie Sie E-Mails mithilfe von Azure Communication Services senden. Sie können außerdem: