Das [AWS SDK für JavaScript V3-API-Referenzhandbuch](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) beschreibt detailliert alle API-Operationen für die AWS SDK für JavaScript Version 3 (V3).
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Beispiele für Amazon Simple Email Service
Amazon Simple Email Service (Amazon SES) ist ein Cloud-basierter E-Mail-Versandservice, der digitale Vermarkter und Anwendungsentwickler beim Versenden von Marketing-, Benachrichtigungs- und Transaktions-E-Mails unterstützt. Dabei handelt es sich um einen zuverlässigen, kosteneffektiven Dienst für Unternehmen jeder Größe, die den Kontakt zu ihren Kunden mithilfe von E-Mail aufrechterhalten
![\[Beziehung zwischen JavaScript Umgebungen, dem SDK und Amazon SES\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/code-samples-ses.png)
Die JavaScript API für Amazon SES wird über die `SES` Client-Klasse verfügbar gemacht. Weitere Informationen zur Verwendung der Amazon SES SES-Client-Klasse finden Sie unter [Class: SES](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SES/) in der API-Referenz.
**Topics**
+ [Verwaltung von Amazon SES SES-Identitäten](ses-examples-managing-identities.md)
+ [Arbeiten mit E-Mail-Vorlagen in Amazon SES](ses-examples-creating-template.md)
+ [Senden von E-Mails mit Amazon SES](ses-examples-sending-email.md)
# Verwaltung von Amazon SES SES-Identitäten
![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)
**Dieses Node.js-Codebeispiel zeigt:**
+ So verifizieren Sie E-Mail-Adressen und Domains, die mit Amazon SES verwendet werden.
+ So weisen Sie Ihren Amazon SES SES-Identitäten eine AWS Identity and Access Management (IAM-) Richtlinie zu.
+ So listen Sie alle Amazon SES SES-Identitäten für Ihr AWS Konto auf.
+ So löschen Sie Identitäten, die mit Amazon SES verwendet werden.
Eine Amazon *SES-Identität* ist eine E-Mail-Adresse oder Domain, die Amazon SES zum Senden von E-Mails verwendet. Amazon SES verlangt von Ihnen, Ihre E-Mail-Identitäten zu verifizieren, um zu bestätigen, dass sie Ihnen gehören, und zu verhindern, dass andere sie verwenden.
Einzelheiten zur Verifizierung von E-Mail-Adressen und Domains in Amazon SES finden Sie unter [Verifizieren von E-Mail-Adressen und Domains in Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html) im Amazon Simple Email Service Developer Guide. Informationen zur Sendeautorisierung in Amazon SES finden Sie unter [Überblick über die Amazon SES SES-Sendeautorisierung](Amazon Simple Email Service Developer Guidesending-authorization-overview.html).
## Das Szenario
In diesem Beispiel verwenden Sie eine Reihe von Node.js -Modulen, um Amazon SES SES-Identitäten zu überprüfen und zu verwalten. Die Module Node.js verwenden das SDK JavaScript zur Überprüfung von E-Mail-Adressen und Domains und verwenden dabei die folgenden Methoden der `SES` Client-Klasse:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/ListIdentitiesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/ListIdentitiesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/DeleteIdentityCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/DeleteIdentityCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/VerifyEmailIdentityCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/VerifyEmailIdentityCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/VerifyDomainIdentityCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/VerifyDomainIdentityCommand/)
## Erforderliche Aufgaben
Zum Einrichten und Ausführen dieses Beispiels müssen Sie zunächst diese Aufgaben abschließen:
+ Richten Sie die Projektumgebung ein, um diese TypeScript Node-Beispiele auszuführen, und installieren Sie die erforderlichen Module AWS SDK für JavaScript und Module von Drittanbietern. Folgen Sie den Anweisungen auf [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md).
+ Erstellen Sie eine freigegebene Konfigurationsdatei mit Ihren Anmeldeinformationen. Weitere Informationen zur Bereitstellung einer Datei mit gemeinsam genutzten Anmeldeinformationen finden Sie unter [Dateien mit gemeinsam genutzten Konfigurationen und Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) im *AWS SDKs Referenzhandbuch zu Tools*.
**Wichtig**
Diese Beispiele veranschaulichen, wie Sie Objekte und Befehle mithilfe von ECMAScript6 (ES6) als import/export Client verwalten können.
Dazu ist die Version 13.x von Node.js oder höher erforderlich. Informationen zum Herunterladen und Installieren der neuesten Version von Node.js finden Sie unter [Node.js downloads](https://nodejs.org/en/download). .
Wenn Sie die CommonJS-Syntax bevorzugen, finden Sie weitere Informationen unter[JavaScript ES6/CommonJs-Syntax](sdk-example-javascript-syntax.md).
## Auflisten Ihrer Identitäten
Verwenden Sie in diesem Beispiel ein Modul Node.js, um E-Mail-Adressen und Domains aufzulisten, die mit Amazon SES verwendet werden sollen.
Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`sesClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SES SES-Client-Objekt erstellt wird. *REGION*Ersetzen Sie es durch Ihre AWS Region.
```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```
Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_listidentities.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.
Erstellen Sie ein Objekt, um den `IdentityType` und andere Parameter für die `ListIdentitiesCommand`-Methode der `SES`-Client-Klasse zu übergeben. Um die `ListIdentitiesCommand` Methode aufzurufen, rufen Sie ein Amazon SES SES-Serviceobjekt auf und übergeben das Parameter-Objekt.
Das `data` zurückgegebene Objekt enthält ein Array von Domänenidentitäten, wie durch den `IdentityType` Parameter angegeben.
**Anmerkung**
*IdentityType*Ersetzen Sie es durch den Identitätstyp, der "EmailAddress" oder „Domain“ sein kann.
```
import { ListIdentitiesCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";
const createListIdentitiesCommand = () =>
new ListIdentitiesCommand({ IdentityType: "EmailAddress", MaxItems: 10 });
const run = async () => {
const listIdentitiesCommand = createListIdentitiesCommand();
try {
return await sesClient.send(listIdentitiesCommand);
} catch (err) {
console.log("Failed to list identities.", err);
return err;
}
};
```
Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein.
```
node ses_listidentities.js
```
Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_listidentities.js).
## Verifizieren der Identität einer E-Mail-Adresse
Verwenden Sie in diesem Beispiel ein Modul Node.js, um E-Mail-Absender für die Verwendung mit Amazon SES zu verifizieren.
Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`sesClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SES SES-Client-Objekt erstellt wird. *REGION*Ersetzen Sie es durch Ihre AWS Region.
```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```
Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_verifyemailidentity.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich des Herunterladens der erforderlichen Clients und Pakete.
Erstellen Sie ein Objekt mit dem sie den `EmailAddress`-Parameter an die `VerifyEmailIdentityCommand`-Methode der `SES`-Client-Klasse übergeben. Um die `VerifyEmailIdentityCommand` Methode aufzurufen, rufen Sie ein Amazon SES SES-Client-Serviceobjekt auf und übergeben die Parameter.
**Anmerkung**
*EMAIL\$1ADDRESS*Ersetzen Sie es durch die E-Mail-Adresse, z. B. name@example.com.
```
// Import required AWS SDK clients and commands for Node.js
import { VerifyEmailIdentityCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";
const EMAIL_ADDRESS = "name@example.com";
const createVerifyEmailIdentityCommand = (emailAddress) => {
return new VerifyEmailIdentityCommand({ EmailAddress: emailAddress });
};
const run = async () => {
const verifyEmailIdentityCommand =
createVerifyEmailIdentityCommand(EMAIL_ADDRESS);
try {
return await sesClient.send(verifyEmailIdentityCommand);
} catch (err) {
console.log("Failed to verify email identity.", err);
return err;
}
};
```
Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein. Die Domain wird zu Amazon SES hinzugefügt, um verifiziert zu werden.
```
node ses_verifyemailidentity.js
```
Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_verifyemailidentity.js).
## Überprüfung einer Domänenidentität
Verwenden Sie in diesem Beispiel ein Modul Node.js, um E-Mail-Domänen für die Verwendung mit Amazon SES zu verifizieren.
Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`sesClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SES SES-Client-Objekt erstellt wird. *REGION*Ersetzen Sie es durch Ihre AWS Region.
```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```
Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_verifydomainidentity.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.
Erstellen Sie ein Objekt mit dem sie den `Domain`-Parameter an die `VerifyDomainIdentityCommand`-Methode der `SES`-Client-Klasse übergeben. Um die `VerifyDomainIdentityCommand` Methode aufzurufen, rufen Sie ein Amazon SES SES-Client-Serviceobjekt auf und übergeben das Parameter-Objekt.
**Anmerkung**
In diesem Beispiel werden die erforderlichen AWS Service V3-Paketclients und V3-Befehle importiert und verwendet und die `send` Methode in einem async/await Muster verwendet. Sie können dieses Beispiel stattdessen mit V2-Befehlen erstellen, indem Sie einige geringfügige Änderungen vornehmen. Details hierzu finden Sie unter [Verwenden von v3-Befehlen](migrating.md#using_v3_commands).
**Anmerkung**
*DOMAIN\$1NAME*Ersetzen Sie es durch den Domainnamen.
```
import { VerifyDomainIdentityCommand } from "@aws-sdk/client-ses";
import {
getUniqueName,
postfix,
} from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";
/**
* You must have access to the domain's DNS settings to complete the
* domain verification process.
*/
const DOMAIN_NAME = postfix(getUniqueName("Domain"), ".example.com");
const createVerifyDomainIdentityCommand = () => {
return new VerifyDomainIdentityCommand({ Domain: DOMAIN_NAME });
};
const run = async () => {
const VerifyDomainIdentityCommand = createVerifyDomainIdentityCommand();
try {
return await sesClient.send(VerifyDomainIdentityCommand);
} catch (err) {
console.log("Failed to verify domain.", err);
return err;
}
};
```
Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein. Die Domain wird zu Amazon SES hinzugefügt, um verifiziert zu werden.
```
node ses_verifydomainidentity.js
```
Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_verifydomainidentity.js).
## Identitäten löschen
Verwenden Sie in diesem Beispiel ein Modul Node.js, um E-Mail-Adressen oder Domains zu löschen, die mit Amazon SES verwendet werden.
Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`sesClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SES SES-Client-Objekt erstellt wird. *REGION*Ersetzen Sie es durch Ihre AWS Region.
```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```
Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_deleteidentity.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.
Erstellen Sie ein Objekt mit dem sie den `Identity`-Parameter an die `DeleteIdentityCommand`-Methode der `SES`-Client-Klasse übergeben. Um die `DeleteIdentityCommand` Methode aufzurufen, erstellen Sie ein Serviceobjekt `request` für den Aufruf eines Amazon SES SES-Clients und übergeben dabei die Parameter.
**Anmerkung**
In diesem Beispiel werden die erforderlichen AWS Service V3-Paketclients und V3-Befehle importiert und verwendet und die `send` Methode in einem async/await Muster verwendet. Sie können dieses Beispiel stattdessen mit V2-Befehlen erstellen, indem Sie einige geringfügige Änderungen vornehmen. Details hierzu finden Sie unter [Verwenden von v3-Befehlen](migrating.md#using_v3_commands).
**Anmerkung**
*IDENTITY\$1EMAIL*Ersetzen Sie es durch die E-Mail-Adresse der Identität, die gelöscht werden soll.
```
import { DeleteIdentityCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";
const IDENTITY_EMAIL = "fake@example.com";
const createDeleteIdentityCommand = (identityName) => {
return new DeleteIdentityCommand({
Identity: identityName,
});
};
const run = async () => {
const deleteIdentityCommand = createDeleteIdentityCommand(IDENTITY_EMAIL);
try {
return await sesClient.send(deleteIdentityCommand);
} catch (err) {
console.log("Failed to delete identity.", err);
return err;
}
};
```
Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein.
```
node ses_deleteidentity.js
```
Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_deleteidentity.js).
# Arbeiten mit E-Mail-Vorlagen in Amazon SES
![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)
**Dieses Node.js-Codebeispiel zeigt:**
+ So erhalten Sie eine Liste all Ihrer E-Mail-Vorlagen.
+ So rufen Sie E-Mail-Vorlagen ab und aktualisieren sie.
+ So erstellen und löschen Sie E-Mail-Vorlagen.
Amazon SES ermöglicht es Ihnen, personalisierte E-Mail-Nachrichten mithilfe von E-Mail-Vorlagen zu versenden. Einzelheiten zum Erstellen und Verwenden von E-Mail-Vorlagen in Amazon SES finden Sie unter [Senden personalisierter E-Mails mit der Amazon SES SES-API](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-personalized-email-api.html) im Amazon Simple Email Service Developer Guide.
## Das Szenario
In diesem Beispiel verwenden Sie eine Reihe von Node.js-Module, um mit E-Mail-Vorlagen zu arbeiten. Die Module von Node.js verwenden das SDK JavaScript , um E-Mail-Vorlagen mithilfe der folgenden Methoden der `SES` Client-Klasse zu erstellen und zu verwenden:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/ListTemplatesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/ListTemplatesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/CreateTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/CreateTemplateCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/GetTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/GetTemplateCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/DeleteTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/DeleteTemplateCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/UpdateTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/UpdateTemplateCommand/)
## Erforderliche Aufgaben
Zum Einrichten und Ausführen dieses Beispiels müssen Sie zunächst diese Aufgaben abschließen:
+ Richten Sie die Projektumgebung ein, um diese TypeScript Node-Beispiele auszuführen, und installieren Sie die erforderlichen Module AWS SDK für JavaScript und Module von Drittanbietern. Folgen Sie den Anweisungen auf [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md).
+ Erstellen Sie eine freigegebene Konfigurationsdatei mit Ihren Anmeldeinformationen. Weitere Informationen zur Bereitstellung einer Datei mit gemeinsam genutzten Anmeldeinformationen finden Sie unter [Dateien mit gemeinsam genutzten Konfigurationen und Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) im *AWS SDKs Referenzhandbuch zu Tools*.
**Wichtig**
Diese Beispiele veranschaulichen, wie Sie Objekte und Befehle mithilfe von ECMAScript6 (ES6) als import/export Client verwalten können.
Dazu ist die Version 13.x von Node.js oder höher erforderlich. Informationen zum Herunterladen und Installieren der neuesten Version von Node.js finden Sie unter [Node.js downloads](https://nodejs.org/en/download). .
Wenn Sie die CommonJS-Syntax bevorzugen, finden Sie weitere Informationen unter[JavaScript ES6/CommonJs-Syntax](sdk-example-javascript-syntax.md).
## Ihre E-Mail-Vorlagen auflisten
Verwenden Sie in diesem Beispiel ein Modul Node.js, um eine E-Mail-Vorlage für Amazon SES zu erstellen.
Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`sesClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SES SES-Client-Objekt erstellt wird. *REGION*Ersetzen Sie es durch Ihre AWS Region.
```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```
Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_listtemplates.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.
Erstellen Sie ein Objekt, mit dem Sie die Parameter für die `ListTemplatesCommand`-Methode der `SES`-Client-Klasse übergeben können. Um die `ListTemplatesCommand` Methode aufzurufen, rufen Sie ein Amazon SES SES-Client-Serviceobjekt auf und übergeben die Parameter.
**Anmerkung**
In diesem Beispiel werden die erforderlichen AWS Service V3-Paketclients und V3-Befehle importiert und verwendet und die `send` Methode in einem async/await Muster verwendet. Sie können dieses Beispiel stattdessen mit V2-Befehlen erstellen, indem Sie einige geringfügige Änderungen vornehmen. Details hierzu finden Sie unter [Verwenden von v3-Befehlen](migrating.md#using_v3_commands).
```
import { ListTemplatesCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";
const createListTemplatesCommand = (maxItems) =>
new ListTemplatesCommand({ MaxItems: maxItems });
const run = async () => {
const listTemplatesCommand = createListTemplatesCommand(10);
try {
return await sesClient.send(listTemplatesCommand);
} catch (err) {
console.log("Failed to list templates.", err);
return err;
}
};
```
Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein. Amazon SES gibt die Liste der Vorlagen zurück.
```
node ses_listtemplates.js
```
Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_listtemplates.js).
## Eine E-Mail-Vorlage erhalten
Verwenden Sie in diesem Beispiel ein Modul Node.js, um eine E-Mail-Vorlage für Amazon SES abzurufen.
Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`sesClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SES SES-Client-Objekt erstellt wird. *REGION*Ersetzen Sie es durch Ihre AWS Region.
```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```
Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_gettemplate.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.
Erstellen Sie ein Objekt mit dem sie den `TemplateName`-Parameter an die `GetTemplateCommand`-Methode der `SES`-Client-Klasse übergeben. Um die `GetTemplateCommand` Methode aufzurufen, rufen Sie ein Amazon SES SES-Client-Serviceobjekt auf und übergeben die Parameter.
**Anmerkung**
In diesem Beispiel werden die erforderlichen AWS Service V3-Paketclients und V3-Befehle importiert und verwendet und die `send` Methode in einem async/await Muster verwendet. Sie können dieses Beispiel stattdessen mit V2-Befehlen erstellen, indem Sie einige geringfügige Änderungen vornehmen. Details hierzu finden Sie unter [Verwenden von v3-Befehlen](migrating.md#using_v3_commands).
**Anmerkung**
*TEMPLATE\$1NAME*Ersetzen Sie es durch den Namen der Vorlage, die zurückgegeben werden soll.
```
import { GetTemplateCommand } from "@aws-sdk/client-ses";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";
const TEMPLATE_NAME = getUniqueName("TemplateName");
const createGetTemplateCommand = (templateName) =>
new GetTemplateCommand({ TemplateName: templateName });
const run = async () => {
const getTemplateCommand = createGetTemplateCommand(TEMPLATE_NAME);
try {
return await sesClient.send(getTemplateCommand);
} catch (caught) {
if (caught instanceof Error && caught.name === "MessageRejected") {
/** @type { import('@aws-sdk/client-ses').MessageRejected} */
const messageRejectedError = caught;
return messageRejectedError;
}
throw caught;
}
};
```
Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein. Amazon SES gibt die Vorlagendetails zurück.
```
node ses_gettemplate.js
```
Dieser Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_gettemplate.js).
## Eine E-Mail-Vorlage erstellen
Verwenden Sie in diesem Beispiel ein Modul Node.js, um eine E-Mail-Vorlage für Amazon SES zu erstellen.
Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`sesClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SES SES-Client-Objekt erstellt wird. *REGION*Ersetzen Sie es durch Ihre AWS Region.
```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```
Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_createtemplate.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.
Erstellen Sie ein Objekt, um die Parameter für die `CreateTemplateCommand`-Methode der `SES`-Client-Klasse zu übergeben, einschließlich `TemplateName`, `HtmlPart`, `SubjectPart` und `TextPart`. Um die `CreateTemplateCommand` Methode aufzurufen, rufen Sie ein Amazon SES SES-Client-Serviceobjekt auf und übergeben die Parameter.
**Anmerkung**
In diesem Beispiel werden die erforderlichen AWS Service V3-Paketclients und V3-Befehle importiert und verwendet und die `send` Methode in einem async/await Muster verwendet. Sie können dieses Beispiel stattdessen mit V2-Befehlen erstellen, indem Sie einige geringfügige Änderungen vornehmen. Details hierzu finden Sie unter [Verwenden von v3-Befehlen](migrating.md#using_v3_commands).
**Anmerkung**
*TEMPLATE\$1NAME*Ersetzen Sie es durch einen Namen für die neue Vorlage, *HtmlPart* durch den HTML-markierten Inhalt der E-Mail und *SubjectPart* durch den Betreff der E-Mail.
```
import { CreateTemplateCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";
const TEMPLATE_NAME = getUniqueName("TestTemplateName");
const createCreateTemplateCommand = () => {
return new CreateTemplateCommand({
/**
* The template feature in Amazon SES is based on the Handlebars template system.
*/
Template: {
/**
* The name of an existing template in Amazon SES.
*/
TemplateName: TEMPLATE_NAME,
HtmlPart: `
Hello, {{contact.firstName}}!
Did you know Amazon has a mascot named Peccy?
`,
SubjectPart: "Amazon Tip",
},
});
};
const run = async () => {
const createTemplateCommand = createCreateTemplateCommand();
try {
return await sesClient.send(createTemplateCommand);
} catch (err) {
console.log("Failed to create template.", err);
return err;
}
};
```
Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein. Die Vorlage wird zu Amazon SES hinzugefügt.
```
node ses_createtemplate.js
```
Dieser Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_createtemplate.js).
## Aktualisieren einer E-Mail-Vorlage
Verwenden Sie in diesem Beispiel ein Modul Node.js, um eine E-Mail-Vorlage für Amazon SES zu erstellen.
Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`sesClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SES SES-Client-Objekt erstellt wird. *REGION*Ersetzen Sie es durch Ihre AWS Region.
```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```
Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_updatetemplate.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.
Erstellen Sie ein Objekt, um die `Template`-Parameterwerte, die Sie in der Vorlage aktualisieren möchten, mit dem erforderlichen `TemplateName`-Parameter an die `UpdateTemplateCommand`-Methode der `SES`-Client-Klasse zu übergeben. Um die `UpdateTemplateCommand` Methode aufzurufen, rufen Sie ein Amazon SES SES-Serviceobjekt auf und übergeben die Parameter.
**Anmerkung**
In diesem Beispiel werden die erforderlichen AWS Service V3-Paketclients und V3-Befehle importiert und verwendet und die `send` Methode in einem async/await Muster verwendet. Sie können dieses Beispiel stattdessen mit V2-Befehlen erstellen, indem Sie einige geringfügige Änderungen vornehmen. Details hierzu finden Sie unter [Verwenden von v3-Befehlen](migrating.md#using_v3_commands).
**Anmerkung**
*TEMPLATE\$1NAME*Ersetzen Sie es durch den Namen der Vorlage und durch den *HTML\$1PART* mit HTML markierten Inhalt der E-Mail.
```
import { UpdateTemplateCommand } from "@aws-sdk/client-ses";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";
const TEMPLATE_NAME = getUniqueName("TemplateName");
const HTML_PART = "Hello, World!
";
const createUpdateTemplateCommand = () => {
return new UpdateTemplateCommand({
Template: {
TemplateName: TEMPLATE_NAME,
HtmlPart: HTML_PART,
SubjectPart: "Example",
TextPart: "Updated template text.",
},
});
};
const run = async () => {
const updateTemplateCommand = createUpdateTemplateCommand();
try {
return await sesClient.send(updateTemplateCommand);
} catch (err) {
console.log("Failed to update template.", err);
return err;
}
};
```
Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein. Amazon SES gibt die Vorlagendetails zurück.
```
node ses_updatetemplate.js
```
Dieser Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_updatetemplate.js).
## Löschen einer E-Mail-Vorlage
Verwenden Sie in diesem Beispiel ein Modul Node.js, um eine E-Mail-Vorlage für Amazon SES zu erstellen.
Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`sesClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SES SES-Client-Objekt erstellt wird. *REGION*Ersetzen Sie es durch Ihre AWS Region.
```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```
Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_deletetemplate.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.
Erstellen Sie ein Objekt, um den erforderlichen `TemplateName`-Parameter an die `DeleteTemplateCommand`-Methode der `SES`-Client-Klasse zu übergeben. Um die `DeleteTemplateCommand` Methode aufzurufen, rufen Sie ein Amazon SES SES-Serviceobjekt auf und übergeben die Parameter.
**Anmerkung**
In diesem Beispiel werden die erforderlichen AWS Service V3-Paketclients und V3-Befehle importiert und verwendet und die `send` Methode in einem async/await Muster verwendet. Sie können dieses Beispiel stattdessen mit V2-Befehlen erstellen, indem Sie einige geringfügige Änderungen vornehmen. Details hierzu finden Sie unter [Verwenden von v3-Befehlen](migrating.md#using_v3_commands).
**Anmerkung**
*TEMPLATE\$1NAME*Ersetzen Sie es durch den Namen der Vorlage, die gelöscht werden soll.
```
import { DeleteTemplateCommand } from "@aws-sdk/client-ses";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";
const TEMPLATE_NAME = getUniqueName("TemplateName");
const createDeleteTemplateCommand = (templateName) =>
new DeleteTemplateCommand({ TemplateName: templateName });
const run = async () => {
const deleteTemplateCommand = createDeleteTemplateCommand(TEMPLATE_NAME);
try {
return await sesClient.send(deleteTemplateCommand);
} catch (err) {
console.log("Failed to delete template.", err);
return err;
}
};
```
Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein. Amazon SES gibt die Vorlagendetails zurück.
```
node ses_deletetemplate.js
```
Dieser Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_deletetemplate.js).
# Senden von E-Mails mit Amazon SES
![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)
**Dieses Node.js-Codebeispiel zeigt:**
+ das Senden einer Text- oder HTML-E-Mail.
+ das Senden von E-Mails, die auf einer E-Mail-Vorlage basieren.
+ das Senden von Massen-E-Mails, die auf einer E-Mail-Vorlage basieren.
Die Amazon SES SES-API bietet Ihnen zwei verschiedene Möglichkeiten, eine E-Mail zu senden, je nachdem, wie viel Kontrolle Sie über die Zusammensetzung der E-Mail-Nachricht haben möchten: formatiert und roh. Weitere Informationen finden Sie unter [Senden formatierter E-Mails mit der Amazon SES SES-API](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-formatted.html) und [Senden von Roh-E-Mails mit der Amazon SES SES-API](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-raw.html).
## Das Szenario
In diesem Beispiel verwenden Sie mehrere Node.js-Module, um E-Mails auf verschiedene Weisen zu senden. Die Module von Node.js verwenden das SDK JavaScript , um E-Mail-Vorlagen mithilfe der folgenden Methoden der `SES` Client-Klasse zu erstellen und zu verwenden:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendEmailCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendEmailCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendTemplatedEmailCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendTemplatedEmailCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendBulkTemplatedEmailCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendBulkTemplatedEmailCommand/)
## Erforderliche Aufgaben
Zum Einrichten und Ausführen dieses Beispiels müssen Sie zunächst diese Aufgaben abschließen:
+ Richten Sie die Projektumgebung ein, um diese TypeScript Node-Beispiele auszuführen, und installieren Sie die erforderlichen Module AWS SDK für JavaScript und Module von Drittanbietern. Folgen Sie den Anweisungen auf [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md).
+ Erstellen Sie eine freigegebene Konfigurationsdatei mit Ihren Anmeldeinformationen. Weitere Informationen zur Bereitstellung einer Datei mit gemeinsam genutzten Anmeldeinformationen finden Sie unter [Dateien mit gemeinsam genutzten Konfigurationen und Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) im *AWS SDKs Referenzhandbuch zu Tools*.
**Wichtig**
Diese Beispiele veranschaulichen, wie Sie Objekte und Befehle mithilfe von ECMAScript6 (ES6) als import/export Client verwalten können.
Dazu ist die Version 13.x von Node.js oder höher erforderlich. Informationen zum Herunterladen und Installieren der neuesten Version von Node.js finden Sie unter [Node.js downloads](https://nodejs.org/en/download). .
Wenn Sie die CommonJS-Syntax bevorzugen, finden Sie weitere Informationen unter[JavaScript ES6/CommonJs-Syntax](sdk-example-javascript-syntax.md).
## Anforderungen für den Versand von E-Mail-Nachrichten
Amazon SES verfasst eine E-Mail-Nachricht und stellt sie sofort in die Warteschlange für den Versand. Damit Sie mithilfe der `SendEmailCommand`-Methode E-Mails senden können, muss Ihre Nachricht die folgenden Anforderungen erfüllen:
+ Sie müssen die Nachricht von einer verifizierten E-Mail-Adresse oder Domäne senden. Wenn Sie versuchen, E-Mails über eine nicht verifizierte Adresse oder Domäne zu senden, führt die Operation zu einem `"Email address not verified"`-Fehler.
+ Wenn sich Ihr Konto noch in der Amazon SES Sandbox befindet, können Sie die E-Mails nur an verifizierte Adressen oder Domänen oder E-Mail-Adressen des Amazon SES-Postfachsimulators senden. Weitere Informationen finden Sie unter [Verifizieren von E-Mail-Adressen und Domains](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html) im Amazon Simple Email Service Developer Guide.
+ Die Gesamtgröße der Nachricht, einschließlich Anlagen, muss kleiner als 10 MB sein.
+ Die Nachricht muss mindestens eine E-Mail-Adresse für einen Empfänger enthalten. Bei der Empfänger-Adresse kann es sich um eine Empfängeradresse, eine CC: Adresse oder BCC: Adresse handeln. Wenn die E-Mail-Adresse eines Empfängers nicht gültig ist (d. h., sie hat nicht das Format`UserName@[SubDomain.]Domain.TopLevelDomain`), wird die gesamte Nachricht zurückgewiesen, auch wenn die Nachricht andere gültige Empfänger enthält.
+ Die Nachricht darf in den Feldern An:, CC: und BCC: nicht mehr als 50 Empfänger enthalten. Wenn Sie eine E-Mail an eine größere Zielgruppe senden möchten, können Sie Ihre Empfängerliste in Gruppen von höchstens 50 unterteilen und dann die `sendEmail`-Methode aufrufen, um die Nachricht mehrmals an die einzelnen Gruppen zu senden.
## Eine E-Mail senden
In diesem Beispiel verwenden Sie ein Node.js-Modul zum Senden von E-Mail mit Amazon SES.
Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`sesClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SES SES-Client-Objekt erstellt wird. *REGION*Ersetzen Sie es durch Ihre AWS Region.
```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```
Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_sendemail.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.
Erstellen Sie ein Objekt, um die Parameterwerte, die die zu sendende E-Mail definieren, einschließlich Absender- und Empfängeradressen, Betreff und E-Mail-Text in Klartext- und HTML-Formaten, an die `SendEmailCommand` Methode der `SES` Client-Klasse zu übergeben. Um die `SendEmailCommand` Methode aufzurufen, rufen Sie ein Amazon SES SES-Serviceobjekt auf und übergeben die Parameter.
**Anmerkung**
In diesem Beispiel werden die erforderlichen AWS Service V3-Paketclients und V3-Befehle importiert und verwendet und die `send` Methode in einem async/await Muster verwendet. Sie können dieses Beispiel stattdessen mit V2-Befehlen erstellen, indem Sie einige geringfügige Änderungen vornehmen. Details hierzu finden Sie unter [Verwenden von v3-Befehlen](migrating.md#using_v3_commands).
**Anmerkung**
*toAddress*Ersetzen Sie es durch die Adresse, an die die E-Mail gesendet werden soll, und *fromAddress* durch die E-Mail-Adresse, von der die E-Mail gesendet werden soll.
```
import { SendEmailCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";
const createSendEmailCommand = (toAddress, fromAddress) => {
return new SendEmailCommand({
Destination: {
/* required */
CcAddresses: [
/* more items */
],
ToAddresses: [
toAddress,
/* more To-email addresses */
],
},
Message: {
/* required */
Body: {
/* required */
Html: {
Charset: "UTF-8",
Data: "HTML_FORMAT_BODY",
},
Text: {
Charset: "UTF-8",
Data: "TEXT_FORMAT_BODY",
},
},
Subject: {
Charset: "UTF-8",
Data: "EMAIL_SUBJECT",
},
},
Source: fromAddress,
ReplyToAddresses: [
/* more items */
],
});
};
const run = async () => {
const sendEmailCommand = createSendEmailCommand(
"recipient@example.com",
"sender@example.com",
);
try {
return await sesClient.send(sendEmailCommand);
} catch (caught) {
if (caught instanceof Error && caught.name === "MessageRejected") {
/** @type { import('@aws-sdk/client-ses').MessageRejected} */
const messageRejectedError = caught;
return messageRejectedError;
}
throw caught;
}
};
```
Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein. Die E-Mail befindet sich in der Warteschlange für den Versand durch Amazon SES.
```
node ses_sendemail.js
```
Diesen Beispielcode [finden Sie hier auf GitHub.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendemail.js)
## Senden einer E-Mail mithilfe einer Vorlage
In diesem Beispiel verwenden Sie ein Node.js-Modul zum Senden von E-Mail mit Amazon SES. Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_sendtemplatedemail.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.
Erstellen Sie ein Objekt, um die Parameterwerte, die die zu sendende E-Mail definieren, z. B. die Sender- und Empfängeradressen, Betreff, E-Mail-Text im Klartext- und HTML-Format, an die `SendTemplatedEmailCommand`-Methode der `SES`-Client-Klasse zu übergeben. Um die `SendTemplatedEmailCommand` Methode aufzurufen, rufen Sie ein Amazon SES SES-Client-Serviceobjekt auf und übergeben die Parameter.
**Anmerkung**
In diesem Beispiel werden die erforderlichen AWS Service V3-Paketclients und V3-Befehle importiert und verwendet und die `send` Methode in einem async/await Muster verwendet. Sie können dieses Beispiel stattdessen mit V2-Befehlen erstellen, indem Sie einige geringfügige Änderungen vornehmen. Details hierzu finden Sie unter [Verwenden von v3-Befehlen](migrating.md#using_v3_commands).
**Anmerkung**
*REGION*Ersetzen Sie es durch Ihre AWS Region, *USER* durch den Namen und die E-Mail-Adresse, an die die E-Mail gesendet werden soll, *VERIFIED\$1EMAIL* durch die E-Mail-Adresse, von der aus die E-Mail gesendet werden soll, und *TEMPLATE\$1NAME* durch den Namen der Vorlage.
```
import { SendTemplatedEmailCommand } from "@aws-sdk/client-ses";
import {
getUniqueName,
postfix,
} from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";
/**
* Replace this with the name of an existing template.
*/
const TEMPLATE_NAME = getUniqueName("ReminderTemplate");
/**
* Replace these with existing verified emails.
*/
const VERIFIED_EMAIL = postfix(getUniqueName("Bilbo"), "@example.com");
const USER = { firstName: "Bilbo", emailAddress: VERIFIED_EMAIL };
/**
*
* @param { { emailAddress: string, firstName: string } } user
* @param { string } templateName - The name of an existing template in Amazon SES.
* @returns { SendTemplatedEmailCommand }
*/
const createReminderEmailCommand = (user, templateName) => {
return new SendTemplatedEmailCommand({
/**
* Here's an example of how a template would be replaced with user data:
* Template: Hello {{contact.firstName}},
Don't forget about the party gifts!
* Destination: Hello Bilbo,
Don't forget about the party gifts!
*/
Destination: { ToAddresses: [user.emailAddress] },
TemplateData: JSON.stringify({ contact: { firstName: user.firstName } }),
Source: VERIFIED_EMAIL,
Template: templateName,
});
};
const run = async () => {
const sendReminderEmailCommand = createReminderEmailCommand(
USER,
TEMPLATE_NAME,
);
try {
return await sesClient.send(sendReminderEmailCommand);
} catch (caught) {
if (caught instanceof Error && caught.name === "MessageRejected") {
/** @type { import('@aws-sdk/client-ses').MessageRejected} */
const messageRejectedError = caught;
return messageRejectedError;
}
throw caught;
}
};
```
Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein. Die E-Mail befindet sich in der Warteschlange für den Versand durch Amazon SES.
```
node ses_sendtemplatedemail.js
```
Diesen Beispielcode finden Sie [hier auf GitHub.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendtemplatedemail.js)
## Senden von Massen-E-Mails mithilfe einer Vorlage
In diesem Beispiel verwenden Sie ein Node.js-Modul zum Senden von E-Mail mit Amazon SES.
Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`sesClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SES SES-Client-Objekt erstellt wird. *REGION*Ersetzen Sie es durch Ihre AWS Region.
```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```
Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_sendbulktemplatedemail.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.
Erstellen Sie ein Objekt, um die Parameterwerte, die die zu sendende E-Mail definieren, einschließlich Absender- und Empfängeradressen, Betreff und E-Mail-Text in Klartext- und HTML-Formaten, an die `SendBulkTemplatedEmailCommand` Methode der `SES` Client-Klasse zu übergeben. Um die `SendBulkTemplatedEmailCommand` Methode aufzurufen, rufen Sie ein Amazon SES SES-Serviceobjekt auf und übergeben die Parameter.
**Anmerkung**
In diesem Beispiel werden die erforderlichen AWS Service V3-Paketclients und V3-Befehle importiert und verwendet und die `send` Methode in einem async/await Muster verwendet. Sie können dieses Beispiel stattdessen mit V2-Befehlen erstellen, indem Sie einige geringfügige Änderungen vornehmen. Details hierzu finden Sie unter [Verwenden von v3-Befehlen](migrating.md#using_v3_commands).
**Anmerkung**
*USERS*Ersetzen Sie es durch die Namen und E-Mail-Adressen, an die die E-Mail gesendet werden soll, *VERIFIED\$1EMAIL\$11* durch die E-Mail-Adresse, von der die E-Mail gesendet werden soll, und *TEMPLATE\$1NAME* durch den Namen der Vorlage.
```
import { SendBulkTemplatedEmailCommand } from "@aws-sdk/client-ses";
import {
getUniqueName,
postfix,
} from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";
/**
* Replace this with the name of an existing template.
*/
const TEMPLATE_NAME = getUniqueName("ReminderTemplate");
/**
* Replace these with existing verified emails.
*/
const VERIFIED_EMAIL_1 = postfix(getUniqueName("Bilbo"), "@example.com");
const VERIFIED_EMAIL_2 = postfix(getUniqueName("Frodo"), "@example.com");
const USERS = [
{ firstName: "Bilbo", emailAddress: VERIFIED_EMAIL_1 },
{ firstName: "Frodo", emailAddress: VERIFIED_EMAIL_2 },
];
/**
*
* @param { { emailAddress: string, firstName: string }[] } users
* @param { string } templateName the name of an existing template in SES
* @returns { SendBulkTemplatedEmailCommand }
*/
const createBulkReminderEmailCommand = (users, templateName) => {
return new SendBulkTemplatedEmailCommand({
/**
* Each 'Destination' uses a corresponding set of replacement data. We can map each user
* to a 'Destination' and provide user specific replacement data to create personalized emails.
*
* Here's an example of how a template would be replaced with user data:
* Template: Hello {{name}},
Don't forget about the party gifts!
* Destination 1: Hello Bilbo,
Don't forget about the party gifts!
* Destination 2: Hello Frodo,
Don't forget about the party gifts!
*/
Destinations: users.map((user) => ({
Destination: { ToAddresses: [user.emailAddress] },
ReplacementTemplateData: JSON.stringify({ name: user.firstName }),
})),
DefaultTemplateData: JSON.stringify({ name: "Shireling" }),
Source: VERIFIED_EMAIL_1,
Template: templateName,
});
};
const run = async () => {
const sendBulkTemplateEmailCommand = createBulkReminderEmailCommand(
USERS,
TEMPLATE_NAME,
);
try {
return await sesClient.send(sendBulkTemplateEmailCommand);
} catch (caught) {
if (caught instanceof Error && caught.name === "MessageRejected") {
/** @type { import('@aws-sdk/client-ses').MessageRejected} */
const messageRejectedError = caught;
return messageRejectedError;
}
throw caught;
}
};
```
Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein. Die E-Mail befindet sich in der Warteschlange für den Versand durch Amazon SES.
```
node ses_sendbulktemplatedemail.js
```
Diesen Beispielcode finden Sie [hier auf GitHub.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendbulktemplatedemail.js)