Le [guide de référence de l'API AWS SDK pour JavaScript V3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) décrit en détail toutes les opérations de l'API pour la AWS SDK pour JavaScript version 3 (V3).
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Exemples d'Amazon Simple Email Service
Amazon Simple Email Service (Amazon SES) est un service d'envoi d'e-mails basé sur le cloud conçu pour aider les spécialistes du marketing numérique et les développeurs d'applications à envoyer des e-mails marketing, de notification et transactionnels. C'est un service fiable et rentable pour les entreprises de toutes tailles utilisant les e-mails pour rester en contact avec leurs clients.
![\[Relation entre JavaScript les environnements, le SDK et Amazon SES\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/code-samples-ses.png)
L' JavaScript API d'Amazon SES est exposée par le biais de la classe `SES` client. Pour plus d'informations sur l'utilisation de la classe client Amazon SES, consultez [Classe : SES](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SES/) dans le Guide de référence des API.
**Topics**
+ [Gestion des identités Amazon SES](ses-examples-managing-identities.md)
+ [Utilisation de modèles d'e-mail dans Amazon SES](ses-examples-creating-template.md)
+ [Envoi d'e-mails à l'aide d'Amazon SES](ses-examples-sending-email.md)
# Gestion des identités Amazon SES
![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)
**Cet exemple de code Node.js présente :**
+ Comment vérifier les adresses e-mail et les domaines utilisés avec Amazon SES.
+ Comment attribuer une politique Gestion des identités et des accès AWS (IAM) à vos identités Amazon SES.
+ Comment répertorier toutes les identités Amazon SES associées à votre AWS compte.
+ Comment supprimer les identités utilisées avec Amazon SES
Une *identité* Amazon SES est une adresse e-mail ou un domaine qu'Amazon SES utilise pour envoyer des e-mails. Amazon SES vous demande de vérifier votre identité e-mail, de confirmer que vous en êtes le propriétaire et d'empêcher les autres de les utiliser.
Pour en savoir plus sur la façon de vérifier les adresses e-mail et les domaines dans Amazon SES, consultez la section [Vérification des adresses e-mail et des domaines dans Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html) dans le manuel Amazon Simple Email Service Developer Guide. Pour plus d'informations sur l'autorisation d'envoi dans Amazon SES, consultez [Présentation de l'autorisation d'envoi Amazon SES](Amazon Simple Email Service Developer Guidesending-authorization-overview.html).
## Le scénario
Dans cet exemple, vous utilisez une série de modules Node.js pour vérifier et gérer les identités Amazon SES. Les modules Node.js utilisent le SDK JavaScript pour vérifier les adresses e-mail et les domaines, en utilisant les méthodes suivantes de la classe `SES` client :
+ [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/)
## Tâches préalables
Pour configurer et exécuter cet exemple, vous devez d'abord :
+ Configurez l'environnement du projet pour exécuter ces TypeScript exemples de nœuds et installez les modules requis AWS SDK pour JavaScript et tiers. Suivez les instructions figurant sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md).
+ Créez un fichier de configurations partagé avec vos informations d'identification utilisateur. Pour plus d'informations sur la fourniture d'un fichier d'informations d'identification [partagé, consultez la section Fichiers de configuration et d'informations d'identification](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) partagés dans le *guide de référence AWS SDKs et Tools*.
**Important**
Ces exemples montrent comment utiliser des objets de service import/export client et des commandes en utilisant ECMAScript6 (ES6).
Cela nécessite la version 13.x ou supérieure de Node.js. Pour télécharger et installer la dernière version de Node.js, consultez la section [Téléchargements de Node.js.](https://nodejs.org/en/download) .
Si vous préférez utiliser la syntaxe CommonJS, consultez[JavaScript ES6Syntaxe /CommonJS](sdk-example-javascript-syntax.md).
## Répertorier vos identités
Dans cet exemple, utilisez un module Node.js pour répertorier les adresses e-mail et les domaines à utiliser avec Amazon SES.
Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`sesClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SES. Remplacez *REGION* par votre AWS région.
```
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 };
```
Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Créez un module Node.js nommé `ses_listidentities.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.
Créez un objet pour transmettre le paramètre `IdentityType` ainsi que les autres paramètres de la méthode `ListIdentitiesCommand` de la classe client `SES`. Pour appeler la `ListIdentitiesCommand` méthode, appelez un objet de service Amazon SES en transmettant l'objet de paramètres.
Le `data` résultat contient un tableau d'identités de domaine tel que spécifié par le `IdentityType` paramètre.
**Note**
Remplacez *IdentityType* par le type d'identité, qui peut être EmailAddress « » ou « Domaine ».
```
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;
}
};
```
Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.
```
node ses_listidentities.js
```
Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_listidentities.js).
## Vérification d'une identité d'adresse e-mail
Dans cet exemple, utilisez un module Node.js pour vérifier les expéditeurs d'e-mails à utiliser avec Amazon SES.
Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`sesClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SES. Remplacez *REGION* par votre AWS région.
```
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 };
```
Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Créez un module Node.js nommé `ses_verifyemailidentity.js`. Configurez le SDK comme indiqué précédemment, notamment en téléchargeant les clients et les packages requis.
Créez un objet pour transmettre le paramètre `EmailAddress` ainsi que les autres paramètres de la méthode `VerifyEmailIdentityCommand` de la classe client `SES`. Pour appeler la `VerifyEmailIdentityCommand` méthode, appelez un objet du service client Amazon SES en transmettant les paramètres.
**Note**
Remplacez *EMAIL\$1ADDRESS* par l'adresse e-mail, telle que 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;
}
};
```
Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande. Le domaine est ajouté à Amazon SES pour être vérifié.
```
node ses_verifyemailidentity.js
```
Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_verifyemailidentity.js).
## Vérification de l'identité d'un domaine
Dans cet exemple, utilisez un module Node.js pour vérifier les domaines de messagerie à utiliser avec Amazon SES.
Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`sesClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SES. Remplacez *REGION* par votre AWS région.
```
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 };
```
Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Créez un module Node.js nommé `ses_verifydomainidentity.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.
Créez un objet pour transmettre le paramètre `Domain` ainsi que les autres paramètres de la méthode `VerifyDomainIdentityCommand` de la classe client `SES`. Pour appeler la `VerifyDomainIdentityCommand` méthode, appelez un objet du service client Amazon SES en transmettant l'objet de paramètres.
**Note**
Cet exemple importe et utilise les clients du package AWS Service V3 requis, les commandes V3, et utilise la `send` méthode selon un async/await modèle. Vous pouvez créer cet exemple à l'aide des commandes V2 en apportant quelques modifications mineures. Pour en savoir plus, consultez [Utilisation des commandes v3](migrating.md#using_v3_commands).
**Note**
Remplacez *DOMAIN\$1NAME* par le nom de domaine.
```
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;
}
};
```
Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande. Le domaine est ajouté à Amazon SES pour être vérifié.
```
node ses_verifydomainidentity.js
```
Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_verifydomainidentity.js).
## Supprimer des identités
Dans cet exemple, utilisez un module Node.js pour supprimer les adresses e-mail ou les domaines utilisés avec Amazon SES.
Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`sesClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SES. Remplacez *REGION* par votre AWS région.
```
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 };
```
Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Créez un module Node.js nommé `ses_deleteidentity.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.
Créez un objet pour transmettre le paramètre `Identity` ainsi que les autres paramètres de la méthode `DeleteIdentityCommand` de la classe client `SES`. Pour appeler la `DeleteIdentityCommand` méthode, créez un `request` pour appeler un objet de service client Amazon SES en transmettant les paramètres.
**Note**
Cet exemple importe et utilise les clients du package AWS Service V3 requis, les commandes V3, et utilise la `send` méthode selon un async/await modèle. Vous pouvez créer cet exemple à l'aide des commandes V2 en apportant quelques modifications mineures. Pour en savoir plus, consultez [Utilisation des commandes v3](migrating.md#using_v3_commands).
**Note**
Remplacez *IDENTITY\$1EMAIL* par l'e-mail de l'identité à supprimer.
```
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;
}
};
```
Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.
```
node ses_deleteidentity.js
```
Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_deleteidentity.js).
# Utilisation de modèles d'e-mail dans Amazon SES
![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)
**Cet exemple de code Node.js présente :**
+ Comment obtenir une liste de tous vos modèles d'e-mails.
+ Comment récupérer et mettre à jour des modèles d'e-mails.
+ Comment créer et supprimer des modèles d'e-mails.
Amazon SES vous permet d'envoyer des e-mails personnalisés à l'aide de modèles d'e-mail. Pour en savoir plus sur la création et l'utilisation de modèles d'e-mails dans Amazon SES, consultez la section [Envoi d'e-mails personnalisés à l'aide de l'API Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-personalized-email-api.html) dans le manuel Amazon Simple Email Service Developer Guide.
## Le scénario
Dans cet exemple, vous utilisez une série de modules Node.js à utiliser avec des modèles d'e-mail. Les modules Node.js utilisent le SDK pour JavaScript créer et utiliser des modèles de courrier électronique en utilisant les méthodes suivantes de la classe `SES` client :
+ [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/)
## Tâches préalables
Pour configurer et exécuter cet exemple, vous devez d'abord :
+ Configurez l'environnement du projet pour exécuter ces TypeScript exemples de nœuds et installez les modules requis AWS SDK pour JavaScript et tiers. Suivez les instructions figurant sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md).
+ Créez un fichier de configurations partagé avec vos informations d'identification utilisateur. Pour plus d'informations sur la fourniture d'un fichier d'informations d'identification [partagé, consultez la section Fichiers de configuration et d'informations d'identification](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) partagés dans le *guide de référence AWS SDKs et Tools*.
**Important**
Ces exemples montrent comment utiliser des objets de service import/export client et des commandes en utilisant ECMAScript6 (ES6).
Cela nécessite la version 13.x ou supérieure de Node.js. Pour télécharger et installer la dernière version de Node.js, consultez la section [Téléchargements de Node.js.](https://nodejs.org/en/download) .
Si vous préférez utiliser la syntaxe CommonJS, consultez[JavaScript ES6Syntaxe /CommonJS](sdk-example-javascript-syntax.md).
## Répertorier vos modèles d'e-mails
Dans cet exemple, utilisez un module Node.js pour créer un modèle d'e-mail à utiliser avec Amazon SES.
Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`sesClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SES. Remplacez *REGION* par votre AWS région.
```
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 };
```
Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Créez un module Node.js nommé `ses_listtemplates.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.
Créez un objet pour transmettre les paramètres de la méthode `ListTemplatesCommand` de la classe client `SES`. Pour appeler la `ListTemplatesCommand` méthode, appelez un objet du service client Amazon SES en transmettant les paramètres.
**Note**
Cet exemple importe et utilise les clients du package AWS Service V3 requis, les commandes V3, et utilise la `send` méthode selon un async/await modèle. Vous pouvez créer cet exemple à l'aide des commandes V2 en apportant quelques modifications mineures. Pour en savoir plus, consultez [Utilisation des commandes v3](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;
}
};
```
Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande. Amazon SES renvoie la liste des modèles.
```
node ses_listtemplates.js
```
Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_listtemplates.js).
## Obtenir un modèle d'e-mail
Dans cet exemple, utilisez un module Node.js pour obtenir un modèle d'e-mail à utiliser avec Amazon SES.
Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`sesClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SES. Remplacez *REGION* par votre AWS région.
```
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 };
```
Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Créez un module Node.js nommé `ses_gettemplate.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.
Créez un objet pour transmettre le paramètre `TemplateName` ainsi que les autres paramètres de la méthode `GetTemplateCommand` de la classe client `SES`. Pour appeler la `GetTemplateCommand` méthode, appelez un objet du service client Amazon SES en transmettant les paramètres.
**Note**
Cet exemple importe et utilise les clients du package AWS Service V3 requis, les commandes V3, et utilise la `send` méthode selon un async/await modèle. Vous pouvez créer cet exemple à l'aide des commandes V2 en apportant quelques modifications mineures. Pour en savoir plus, consultez [Utilisation des commandes v3](migrating.md#using_v3_commands).
**Note**
Remplacez *TEMPLATE\$1NAME* par le nom du modèle à renvoyer.
```
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;
}
};
```
Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande. Amazon SES renvoie les détails du modèle.
```
node ses_gettemplate.js
```
Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_gettemplate.js).
## Création d'un modèle d'e-mail
Dans cet exemple, utilisez un module Node.js pour créer un modèle d'e-mail à utiliser avec Amazon SES.
Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`sesClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SES. Remplacez *REGION* par votre AWS région.
```
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 };
```
Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Créez un module Node.js nommé `ses_createtemplate.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.
Créez un objet pour transmettre les paramètres de la méthode `CreateTemplateCommand` de la classe client `SES`, y compris `TemplateName`, `HtmlPart`, `SubjectPart` et `TextPart`. Pour appeler la `CreateTemplateCommand` méthode, appelez un objet du service client Amazon SES en transmettant les paramètres.
**Note**
Cet exemple importe et utilise les clients du package AWS Service V3 requis, les commandes V3, et utilise la `send` méthode selon un async/await modèle. Vous pouvez créer cet exemple à l'aide des commandes V2 en apportant quelques modifications mineures. Pour en savoir plus, consultez [Utilisation des commandes v3](migrating.md#using_v3_commands).
**Note**
Remplacez-le *TEMPLATE\$1NAME* par le nom du nouveau modèle, *HtmlPart* par le contenu balisé HTML de l'e-mail et *SubjectPart* par l'objet de l'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;
}
};
```
Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande. Le modèle est ajouté à Amazon SES.
```
node ses_createtemplate.js
```
Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_createtemplate.js).
## Mise à jour d'un modèle d'e-mail
Dans cet exemple, utilisez un module Node.js pour créer un modèle d'e-mail à utiliser avec Amazon SES.
Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`sesClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SES. Remplacez *REGION* par votre AWS région.
```
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 };
```
Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Créez un module Node.js nommé `ses_updatetemplate.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.
Créez un objet pour transmettre les valeurs de paramètre `Template` que vous souhaitez mettre à jour dans le modèle, avec le paramètre `TemplateName` obligatoire transmis à la méthode `UpdateTemplateCommand` de la classe client `SES`. Pour appeler la `UpdateTemplateCommand` méthode, appelez un objet de service Amazon SES en transmettant les paramètres.
**Note**
Cet exemple importe et utilise les clients du package AWS Service V3 requis, les commandes V3, et utilise la `send` méthode selon un async/await modèle. Vous pouvez créer cet exemple à l'aide des commandes V2 en apportant quelques modifications mineures. Pour en savoir plus, consultez [Utilisation des commandes v3](migrating.md#using_v3_commands).
**Note**
*TEMPLATE\$1NAME*Remplacez-le par le nom du modèle et *HTML\$1PART* par le contenu HTML balisé de l'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;
}
};
```
Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande. Amazon SES renvoie les détails du modèle.
```
node ses_updatetemplate.js
```
Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_updatetemplate.js).
## Suppression d'un modèle d'e-mail
Dans cet exemple, utilisez un module Node.js pour créer un modèle d'e-mail à utiliser avec Amazon SES.
Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`sesClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SES. Remplacez *REGION* par votre AWS région.
```
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 };
```
Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Créez un module Node.js nommé `ses_deletetemplate.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.
Créez un objet pour transmettre le paramètre`TemplateName` obligatoire à la méthode `DeleteTemplateCommand` de la classe client `SES`. Pour appeler la `DeleteTemplateCommand` méthode, appelez un objet de service Amazon SES en transmettant les paramètres.
**Note**
Cet exemple importe et utilise les clients du package AWS Service V3 requis, les commandes V3, et utilise la `send` méthode selon un async/await modèle. Vous pouvez créer cet exemple à l'aide des commandes V2 en apportant quelques modifications mineures. Pour en savoir plus, consultez [Utilisation des commandes v3](migrating.md#using_v3_commands).
**Note**
Remplacez *TEMPLATE\$1NAME* par le nom du modèle à supprimer.
```
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;
}
};
```
Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande. Amazon SES renvoie les détails du modèle.
```
node ses_deletetemplate.js
```
Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_deletetemplate.js).
# Envoi d'e-mails à l'aide d'Amazon SES
![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)
**Cet exemple de code Node.js présente :**
+ L'envoi d'un texte ou d'un e-mail au format HTML.
+ L'envoi d'e-mails basés sur un modèle d'e-mail.
+ L'envoi d'e-mails en bloc basés sur un modèle d'e-mail.
L'API Amazon SES vous permet d'envoyer un e-mail de deux manières différentes, en fonction du niveau de contrôle que vous souhaitez obtenir sur la composition du message : formaté et brut. Pour plus de détails, consultez [Envoi d'e-mails formatés à l'aide de l'API Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-formatted.html) et [Envoi d'e-mails bruts à l'aide de l'API Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-raw.html).
## Le scénario
Dans cet exemple, vous utilisez une série de modules Node.js pour envoyer un e-mail de plusieurs façons. Les modules Node.js utilisent le SDK pour JavaScript créer et utiliser des modèles de courrier électronique en utilisant les méthodes suivantes de la classe `SES` client :
+ [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/)
## Tâches préalables
Pour configurer et exécuter cet exemple, vous devez d'abord :
+ Configurez l'environnement du projet pour exécuter ces TypeScript exemples de nœuds et installez les modules requis AWS SDK pour JavaScript et tiers. Suivez les instructions figurant sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md).
+ Créez un fichier de configurations partagé avec vos informations d'identification utilisateur. Pour plus d'informations sur la fourniture d'un fichier d'informations d'identification [partagé, consultez la section Fichiers de configuration et d'informations d'identification](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) partagés dans le *guide de référence AWS SDKs et Tools*.
**Important**
Ces exemples montrent comment utiliser des objets de service import/export client et des commandes en utilisant ECMAScript6 (ES6).
Cela nécessite la version 13.x ou supérieure de Node.js. Pour télécharger et installer la dernière version de Node.js, consultez la section [Téléchargements de Node.js.](https://nodejs.org/en/download) .
Si vous préférez utiliser la syntaxe CommonJS, consultez[JavaScript ES6Syntaxe /CommonJS](sdk-example-javascript-syntax.md).
## Exigences relatives à l'envoi de messages électroniques
Amazon SES rédige un e-mail et le met immédiatement en file d'attente pour envoi. Pour envoyer un e-mail à l'aide de la méthode `SendEmailCommand`, votre message doit répondre aux exigences suivantes :
+ Vous devez envoyer le message à partir d'une adresse e-mail ou d'un domaine vérifié(e). Si vous essayez d'envoyer un e-mail à l'aide d'une adresse ou d'un domaine non vérifié(e), cela engendre une erreur `"Email address not verified"`.
+ Si votre compte est encore dans l'environnement de test (sandbox) Amazon SES, vous pouvez uniquement envoyer un e-mail à des adresses ou des domaines vérifiés, ou à des adresses e-mail associées au simulateur de boîte de réception Amazon SES. Pour plus d'informations, consultez la section [Vérification des adresses e-mail et des domaines](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html) dans le manuel Amazon Simple Email Service Developer Guide.
+ La taille totale du message, pièces jointes comprises, doit être inférieure à 10 Mo.
+ Le message doit inclure au moins un destinataire. L'adresse e-mail du destinataire peut se trouver dans le champ À :, Cc : ou Cci :. Si l'adresse e-mail d'un destinataire n'est pas valide (c'est-à-dire qu'elle n'est pas au format`UserName@[SubDomain.]Domain.TopLevelDomain`), le message entier est rejeté, même s'il contient d'autres destinataires valides.
+ Le message ne peut pas inclure plus de 50 destinataires dans les champs To :, CC : et BCC :. Si vous avez besoin d'envoyer un e-mail à davantage de personnes, vous pouvez diviser votre liste de destinataires en groupes de 50 ou moins, puis appeler la méthode `sendEmail` plusieurs fois pour envoyer le message à chaque groupe.
## Envoi d'un e-mail
Dans cet exemple, utilisez un module Node.js pour envoyer un e-mail avec Amazon SES.
Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`sesClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SES. Remplacez *REGION* par votre AWS région.
```
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 };
```
Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Créez un module Node.js nommé `ses_sendemail.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.
Créez un objet pour transmettre les valeurs des paramètres qui définissent l'e-mail à envoyer, y compris les adresses de l'expéditeur et du destinataire, l'objet et le corps de l'e-mail au format texte brut et HTML, à la `SendEmailCommand` méthode de la classe `SES` client. Pour appeler la `SendEmailCommand` méthode, appelez un objet de service Amazon SES en transmettant les paramètres.
**Note**
Cet exemple importe et utilise les clients du package AWS Service V3 requis, les commandes V3, et utilise la `send` méthode selon un async/await modèle. Vous pouvez créer cet exemple à l'aide des commandes V2 en apportant quelques modifications mineures. Pour en savoir plus, consultez [Utilisation des commandes v3](migrating.md#using_v3_commands).
**Note**
Remplacez *toAddress* par l'adresse à laquelle envoyer l'e-mail et *fromAddress* par l'adresse e-mail à partir de laquelle l'e-mail doit être envoyé.
```
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;
}
};
```
Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande. L'e-mail est mis en file d'attente pour être envoyé par Amazon SES.
```
node ses_sendemail.js
```
Cet exemple de code se [trouve ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendemail.js).
## Envoi d'un e-mail à l'aide d'un modèle
Dans cet exemple, utilisez un module Node.js pour envoyer un e-mail avec Amazon SES. Créez un module Node.js nommé `ses_sendtemplatedemail.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.
Créez un objet pour transmettre les valeurs de paramètre qui définissent l'e-mail à envoyer, y compris l'expéditeur et le destinataire, l'objet, le corps du message en texte brut ou au format HTML, à la méthode `SendTemplatedEmailCommand` de la classe client `SES`. Pour appeler la `SendTemplatedEmailCommand` méthode, appelez un objet du service client Amazon SES en transmettant les paramètres.
**Note**
Cet exemple importe et utilise les clients du package AWS Service V3 requis, les commandes V3, et utilise la `send` méthode selon un async/await modèle. Vous pouvez créer cet exemple à l'aide des commandes V2 en apportant quelques modifications mineures. Pour en savoir plus, consultez [Utilisation des commandes v3](migrating.md#using_v3_commands).
**Note**
Remplacez *REGION* par votre AWS région, *USER* par le nom et l'adresse e-mail auxquels envoyer l'e-mail, *VERIFIED\$1EMAIL* par l'adresse e-mail à partir de laquelle envoyer l'e-mail et *TEMPLATE\$1NAME* par le nom du modèle.
```
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;
}
};
```
Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande. L'e-mail est mis en file d'attente pour être envoyé par Amazon SES.
```
node ses_sendtemplatedemail.js
```
Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendtemplatedemail.js).
## Envoi d'e-mails en masse à l'aide d'un modèle
Dans cet exemple, utilisez un module Node.js pour envoyer un e-mail avec Amazon SES.
Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`sesClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SES. Remplacez *REGION* par votre AWS région.
```
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 };
```
Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Créez un module Node.js nommé `ses_sendbulktemplatedemail.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.
Créez un objet pour transmettre les valeurs des paramètres qui définissent l'e-mail à envoyer, y compris les adresses de l'expéditeur et du destinataire, l'objet et le corps de l'e-mail au format texte brut et HTML, à la `SendBulkTemplatedEmailCommand` méthode de la classe `SES` client. Pour appeler la `SendBulkTemplatedEmailCommand` méthode, appelez un objet de service Amazon SES en transmettant les paramètres.
**Note**
Cet exemple importe et utilise les clients du package AWS Service V3 requis, les commandes V3, et utilise la `send` méthode selon un async/await modèle. Vous pouvez créer cet exemple à l'aide des commandes V2 en apportant quelques modifications mineures. Pour en savoir plus, consultez [Utilisation des commandes v3](migrating.md#using_v3_commands).
**Note**
Remplacez-le *USERS* par les noms et adresses e-mail auxquels envoyer l'e-mail, *VERIFIED\$1EMAIL\$11* par l'adresse e-mail à partir de laquelle l'e-mail doit être envoyé et *TEMPLATE\$1NAME* par le nom du modèle.
```
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;
}
};
```
Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande. L'e-mail est mis en file d'attente pour être envoyé par Amazon SES.
```
node ses_sendbulktemplatedemail.js
```
Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendbulktemplatedemail.js).