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.

# Configuration de l'envoi d'e-mails avec Amazon SES
<a name="send-email"></a>

Vous pouvez envoyer un e-mail avec Amazon Simple Email Service (Amazon SES) à l'aide de la console Amazon SES, de l'interface protocole SMTP (Simple Mail Transfer Protocol) d'Amazon SES ou de l'API Amazon SES. Vous utilisez généralement la console pour envoyer des e-mails de test et gérer votre activité d'envoi. Pour envoyer des e-mails en nombre, vous pouvez utiliser l'interface SMTP ou l'API. Pour en savoir plus sur la tarification des e-mails envoyés via Amazon SES, consultez [Tarification d'Amazon SES](https://aws.amazon.com/ses/pricing).
+ Si vous souhaitez utiliser un package logiciel, une application ou un langage de programmation compatible avec SMTP pour envoyer des e-mails via Amazon SES, ou intégrer Amazon SES à votre serveur de messagerie existant, utilisez l'interface SMTP Amazon SES. Pour plus d'informations, consultez [Envoi d'un e-mail via l'interface SMTP Amazon SES par programmation](send-using-smtp-programmatically.md).
+ Si vous souhaitez appeler Amazon SES à l'aide de demandes HTTP brutes, utilisez l'API Amazon SES. Pour plus d'informations, consultez [Utilisation de l'API Amazon SES pour envoyer un e-mail](send-email-api.md).

**Important**  
Lorsque vous envoyez un e-mail à plusieurs destinataires (les destinataires sont les adresses figurant dans les zones « À », « Cc » et « Cci ») et que l'appel d'Amazon SES échoue, l'ensemble de l'e-mail est rejeté et aucun des destinataires ne reçoit l'e-mail concerné. Toutefois, nous vous recommandons d'envoyer un e-mail à un seul destinataire à la fois.

# Utilisation de l'interface SMTP d'Amazon SES pour envoyer des e-mails
<a name="send-email-smtp"></a>

Pour envoyer un e-mail de production via Amazon SES, vous pouvez utiliser l'interface protocole SMTP (Simple Mail Transfer Protocol) ou l'API Amazon SES. Pour en savoir plus sur l'API Amazon SES, consultez [Utilisation de l'API Amazon SES pour envoyer un e-mail](send-email-api.md). Cette section décrit l'interface SMTP.

Amazon SES envoie des e-mails à l'aide de SMTP, qui est le protocole de messagerie le plus courant sur Internet. Vous pouvez envoyer des e-mails via Amazon SES en utilisant différents langages de programmation et logiciels compatibles avec SMTP pour vous connecter à l'interface SMTP Amazon SES. Cette section explique comment obtenir vos informations d'identification SMTP Amazon SES, comment envoyer des e-mails à l'aide de l'interface SMTP et comment configurer plusieurs logiciels et serveurs de messagerie afin d'utiliser Amazon SES pour envoyer des e-mails.

Pour trouver des solutions aux problèmes courants que vous êtes susceptible de rencontrer lors de l'utilisation d'Amazon SES via son interface SMTP, consultez [Problèmes SMTP Amazon SES](troubleshoot-smtp.md). 

## Conditions requises pour envoyer des e-mails via SMTP
<a name="send-email-smtp-requirements"></a>

Pour envoyer des e-mails à l'aide de l'interface SMTP Amazon SES, vous aurez besoin des éléments suivants :
+ Adresse du point de terminaison SMTP. Pour obtenir la liste des points de terminaison SMTP Amazon SES, consultez [Connexion à un point de terminaison SMTP Amazon SES](smtp-connect.md).
+ Le numéro de port de l'interface SMTP. Le numéro de port varie selon la méthode de connexion. Pour plus d'informations, consultez [Connexion à un point de terminaison SMTP Amazon SES](smtp-connect.md).
+ Un nom d'utilisateur et un mot de passe SMTP. Les informations d'identification SMTP sont uniques pour chaque région AWS . Si vous prévoyez d'utiliser l'interface SMTP pour envoyer des e-mails dans plusieurs régions AWS , vous avez besoin d'informations d'identification SMTP pour chaque région.
**Important**  
Vos informations d'identification SMTP ne sont pas identiques à vos clés d' AWS accès ou à celles que vous utilisez pour vous connecter à la console Amazon SES. Pour plus d'informations sur la manière de générer vos informations d'identification SMTP, consultez [Obtention des informations d'identification SMTP Amazon SES](smtp-credentials.md).
+ Un logiciel client capable de communiquer à l'aide du protocole TLS (Transport Layer Security). Pour plus d'informations, consultez [Connexion à un point de terminaison SMTP Amazon SES](smtp-connect.md).
+ Une adresse e-mail que vous avez vérifiée auprès d'Amazon SES. Pour plus d'informations, consultez [Identités vérifiées dans Amazon SES](verify-addresses-and-domains.md).
+ Augmentation des quotas d'envoi, si vous souhaitez envoyer de grandes quantités d'e-mails. Pour plus d'informations, consultez [Gestion de vos limites d'envoi Amazon SES](manage-sending-quotas.md).

## Méthodes d'envoi d'e-mails via SMTP
<a name="send-email-methods"></a>

Vous pouvez envoyer des e-mails via SMTP par l'une des méthodes suivantes :
+ Pour configurer ces logiciels compatibles avec SMTP de façon à envoyer des e-mails via l'interface SMTP Amazon SES, consultez [Envoi d'e-mails via Amazon SES à l'aide de packages logiciels](send-email-smtp-software-package.md).
+ Pour programmer une application de façon à envoyer des e-mails via Amazon SES, consultez [Envoi d'un e-mail via l'interface SMTP Amazon SES par programmation](send-using-smtp-programmatically.md).
+ Pour configurer un serveur de messagerie existant de façon à envoyer tous vos messages sortants via Amazon SES, consultez [Intégration d'Amazon SES à votre serveur de messagerie existant](send-email-smtp-existing-server.md).
+ Pour interagir avec l'interface SMTP Amazon SES à l'aide de la ligne de commande, ce qui peut être utile pour les tests, consultez [Test de votre connexion à l'interface SMTP Amazon SES à l'aide de la ligne de commande](send-email-smtp-client-command-line.md).

Pour obtenir la liste des codes de réponse SMTP, consultez [Codes de réponse SMTP renvoyés par Amazon SES](troubleshoot-smtp.md#troubleshoot-smtp-response-codes).

## Informations à fournir pour les e-mails
<a name="smtp-parameters"></a>

Lorsque vous accédez à Amazon SES via l'interface SMTP, votre application cliente SMTP assemble le message de façon à ce que les informations à fournir dépendent de l'application que vous utilisez. Un échange SMTP entre un client et un serveur nécessite au minimum les éléments suivants : 
+ Une adresse source
+ Une adresse de destination
+ Des données de message

Si vous utilisez l'interface SMTP et que le transfert de commentaires est activé, les retours à l'expéditeur, les réclamations et les notifications de livraison sont envoyées à l'adresse de l'expéditeur du message. Toute adresse « Répondre à » que vous spécifiez n'est pas utilisée.



# Obtention des informations d'identification SMTP Amazon SES
<a name="smtp-credentials"></a>

Vous avez besoin des identifiants SMTP d'Amazon SES pour accéder à l'interface SMTP de SES.

Les informations d'identification que vous utilisez pour envoyer des e-mails via l'interface SMTP de SES sont uniques à chaque AWS région. Si vous utilisez l'interface SMTP SES pour envoyer des e-mails dans plusieurs régions, vous devez générer un ensemble d'informations d'identification d'identification SMTP pour chaque région que vous prévoyez d'utiliser.

Votre mot de passe SMTP est différent de votre clé d'accès AWS secrète. Pour en savoir plus sur les informations d'identification, consultez [Types d'informations d'identification Amazon SES](send-email-concepts-credentials.md).

**Note**  
Pour obtenir la liste des points de terminaison SMTP actuellement disponibles, consultez la section Points de [terminaison SMTP](https://docs.aws.amazon.com/general/latest/gr/ses.html#ses_smtp_endpoints) dans le. *Références générales AWS* 

## Obtention d'informations d'identification SMTP SES à l'aide de la console SES
<a name="smtp-credentials-console"></a>

**Exigence**  
Un utilisateur IAM peut créer des informations d'identification SMTP SES, mais la stratégie de l'utilisateur doit disposer d'une autorisation d'utilisation d'IAM, car les informations d'identification SMTP SES sont créées via IAM. Votre stratégie IAM doit vous permettre d'exécuter les actions IAM suivantes : `iam:ListUsers`, `iam:CreateUser`, `iam:CreateAccessKey`, et `iam:PutUserPolicy`. Si vous essayez de créer des informations d'identification SMTP SES à l'aide de la console et que votre utilisateur IAM ne dispose pas de ces autorisations, un message d'erreur indiquant que votre compte n'est *« pas autorisé à exécuter iam* : » s'affiche. ListUsers

**Important**  
Les actions IAM référencées ci-dessus ont le niveau d'accès à la [gestion des autorisations](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_understand-policy-summary-access-level-summaries.html#access_policies_access-level), qui est le niveau IAM le plus élevé, car il donne l'autorisation d'accorder ou de modifier des autorisations de ressources dans le service. Par conséquent, pour améliorer la sécurité de votre AWS compte, il est vivement recommandé de restreindre ou de surveiller régulièrement ces politiques qui incluent la classification des niveaux d'accès à la gestion des autorisations.

**Pour créer vos informations d'identification SMTP**

1. Connectez-vous à la console Amazon SES AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/ses/](https://console.aws.amazon.com/ses/).

1. Choisissez **SMTP settings (Paramètres SMTP)** dans le panneau de navigation de gauche pour ouvrir la page des **paramètres du protocole SMTP (Simple Mail Transfer Protocol)**.

1. Choisissez **Create SMTP Credentials (Création des informations d'identification SMTP)** en haut à droite : la console IAM s'ouvre.

1. (Facultatif) Si vous devez afficher, modifier ou supprimer des utilisateurs SMTP que vous avez déjà créés, choisissez **Manage my existing SMTP credentials (Gérer mes informations d'identification SMTP existantes)** en bas à droite : la console IAM s'ouvre. Les détails relatifs à la gestion des informations d'identification SMTP sont fournis en suivant ces procédures.

1. Pour **Créer un utilisateur pour SMTP**, saisissez un nom d'utilisateur SMTP dans le champ **Nom d'utilisateur**. Vous pouvez également utiliser la valeur par défaut qui est fourni dans ce champ. Lorsque vous avez terminé, sélectionnez **Créer un utilisateur** dans le coin inférieur droit.

1. Sélectionnez **Afficher** sous *Mot de passe SMTP* – vos informations d'identification SMTP s'affichent à l'écran.

1. Téléchargez ces informations d'identification en sélectionnant **Télécharger le fichier .csv** ou copiez-les et stockez-les en lieu sûr, car vous ne pourrez plus les afficher ou les enregistrer après avoir fermé cette boîte de dialogue.

1. Choisissez **Revenir à la console SES**.

Vous pouvez afficher la liste des informations d'identification SMTP que vous avez créées à l'aide de cette procédure dans la console IAM sous **Access management (Gestion des accès)** et en choisissant **Users (Utilisateurs)** puis en utilisant la barre de recherche pour trouver tous les utilisateurs auxquels vous avez affecté des informations d'identification SMTP.

Vous pouvez également utiliser la console IAM pour supprimer des utilisateurs SMTP existants. Pour en savoir plus sur la suppression d'utilisateurs, consulte z[Gestion des utilisateurs IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_manage.html) dans le *Guide de mise en route IAM*.

Si vous souhaitez modifier votre mot de passe SMTP, supprimez votre utilisateur SMTP existant dans la console IAM. Ensuite, effectuez les procédures ci-dessus pour générer un nouvel ensemble d'informations d'identification SMTP.

## Obtention des informations d'identification SMTP SES en convertissant les informations d'identification existantes AWS
<a name="smtp-credentials-convert"></a>

Si vous avez configuré un utilisateur à l'aide de l'interface IAM, vous pouvez déduire les informations d'identification SMTP SES de l'utilisateur à partir de ses AWS informations d'identification.

**Important**  
N'utilisez pas d' AWS informations d'identification temporaires pour obtenir des informations d'identification SMTP. L'interface SMTP SES ne prend pas en charge les informations d'identification SMTP qui ont été générées à partir d'informations d'identification de sécurité temporaires. 

**Pour permettre à l'utilisateur IAM d'envoyer des e-mails à l'aide de l'interface SMTP SES**

1. Dérivez les informations d'identification SMTP de l'utilisateur à partir de ses AWS informations d'identification en utilisant l'algorithme fourni dans cette section en suivant ces procédures.

   Comme vous partez des AWS informations d'identification, le nom d'utilisateur SMTP est identique à l'ID de la clé AWS d'accès. Il vous suffit donc de générer le mot de passe SMTP.

1. Connectez-vous à la console IAM AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)l'adresse.

1. Sous **Gestion des accès**, sélectionnez **Politiques**, puis **Créer une politique**.

1. Dans l'**éditeur de politiques**, sélectionnez **JSON** et supprimez tout exemple de code dans l'éditeur.

1. Collez la politique d'autorisation suivante dans l'éditeur :

------
#### [ JSON ]

****  

   ```
   {
   "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
   "Effect": "Allow",
               "Action": "ses:SendRawEmail",
               "Resource": "*"
           }
       ]
   }
   ```

------

1. Sélectionnez **Suivant** et entrez `AmazonSesSendingAccess` dans le champ **Nom de la politique**, puis **Créer une politique**.

1. Sous **Gestion des accès**, sélectionnez **Groupes d'utilisateurs**, puis **Créer un groupe**.

1. Entrez `AWSSESSendingGroupDoNotRename` dans le champ **Nom du groupe d'utilisateurs**.

1. Ajoutez des utilisateurs SMTP au groupe en les sélectionnant dans le tableau **Ajouter des utilisateurs au groupe**.

1. Joignez la `AmazonSesSendingAccess` politique créée précédemment en la sélectionnant dans le tableau **Joindre des politiques d'autorisation**, puis en cliquant sur **Créer un groupe d'utilisateurs**.

Pour plus d'informations sur l'utilisation de SES avec IAM, consultez [Gestion des identités et des accès dans Amazon SES](control-user-access.md).

**Note**  
Bien que vous puissiez générer des informations d'identification SMTP SES pour tout utilisateur IAM, nous vous recommandons de créer un utilisateur IAM distinct lorsque vous générez vos informations d'identification SMTP. Pour en savoir plus sur les raisons pour lesquelles il est recommandé de créer des utilisateurs à des fins spécifiques, consultez [Bonnes pratiques IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/IAMBestPractices.html).

Le pseudocode suivant montre l'algorithme qui convertit une clé d'accès AWS secrète en mot de passe SMTP SES.

```
 1. // Modify this variable to include your AWS secret access key
 2. key = "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY";
 3.             
 4. // Modify this variable to refer to the AWS Region that you want to use to send email.
 5. region = "us-west-2";
 6.             
 7. // The values of the following variables should always stay the same.
 8. date = "11111111";
 9. service = "ses";
10. terminal = "aws4_request";
11. message = "SendRawEmail";
12. version = 0x04;
13. 
14. kDate = HmacSha256(date, "AWS4" + key);
15. kRegion = HmacSha256(region, kDate);
16. kService = HmacSha256(service, kRegion);
17. kTerminal = HmacSha256(terminal, kService);
18. kMessage = HmacSha256(message, kTerminal);
19. signatureAndVersion = Concatenate(version, kMessage);
20. smtpPassword = Base64(signatureAndVersion);
```

Certains langages de programmation incluent des bibliothèques que vous pouvez utiliser pour convertir une clé d'accès secrète IAM en mot de passe SMTP. Cette section inclut un exemple de code que vous pouvez utiliser pour convertir une clé d'accès AWS secrète en mot de passe SMTP SES à l'aide de Python.

**Note**  
L'exemple suivant utilise des **f-strings** qui ont été introduites dans Python 3.6 ; si vous utilisez une version plus ancienne, elles ne fonctionneront pas.
Dans l'exemple suivant, la liste de SMTP\$1REGIONS n'est qu'un exemple : votre liste réelle de régions peut être plus ou moins longue en fonction des régions dans lesquelles vous prévoyez d'envoyer des e-mails, car vous aurez besoin d'informations d'identification SMTP pour chacune d'elles. Région AWS

------
#### [ Python ]

```
#!/usr/bin/env python3

import hmac
import hashlib
import base64
import argparse

SMTP_REGIONS = [
    "us-east-2",  # US East (Ohio)
    "us-east-1",  # US East (N. Virginia)
    "us-west-2",  # US West (Oregon)
    "ap-south-1",  # Asia Pacific (Mumbai)
    "ap-northeast-2",  # Asia Pacific (Seoul)
    "ap-southeast-1",  # Asia Pacific (Singapore)
    "ap-southeast-2",  # Asia Pacific (Sydney)
    "ap-northeast-1",  # Asia Pacific (Tokyo)
    "ca-central-1",  # Canada (Central)
    "eu-central-1",  # Europe (Frankfurt)
    "eu-west-1",  # Europe (Ireland)
    "eu-west-2",  # Europe (London)
    "eu-south-1",  # Europe (Milan)
    "eu-north-1",  # Europe (Stockholm)
    "sa-east-1",  # South America (Sao Paulo)
    "us-gov-west-1",  # AWS GovCloud (US)
    "us-gov-east-1",  # AWS GovCloud (US)
]

# These values are required to calculate the signature. Do not change them.
DATE = "11111111"
SERVICE = "ses"
MESSAGE = "SendRawEmail"
TERMINAL = "aws4_request"
VERSION = 0x04


def sign(key, msg):
    return hmac.new(key, msg.encode("utf-8"), hashlib.sha256).digest()


def calculate_key(secret_access_key, region):
    if region not in SMTP_REGIONS:
        raise ValueError(f"The {region} Region doesn't have an SMTP endpoint.")

    signature = sign(("AWS4" + secret_access_key).encode("utf-8"), DATE)
    signature = sign(signature, region)
    signature = sign(signature, SERVICE)
    signature = sign(signature, TERMINAL)
    signature = sign(signature, MESSAGE)
    signature_and_version = bytes([VERSION]) + signature
    smtp_password = base64.b64encode(signature_and_version)
    return smtp_password.decode("utf-8")


def main():
    parser = argparse.ArgumentParser(
        description="Convert a Secret Access Key to an SMTP password."
    )
    parser.add_argument("secret", help="The Secret Access Key to convert.")
    parser.add_argument(
        "region",
        help="The AWS Region where the SMTP password will be used.",
        choices=SMTP_REGIONS,
    )
    args = parser.parse_args()
    print(calculate_key(args.secret, args.region))


if __name__ == "__main__":
    main()
```

Pour obtenir votre mot de passe SMTP à l'aide de ce script, enregistrez le code précédent en tant que `smtp_credentials_generate.py`. Exécutez la ligne de commande suivante au moment de l'invite :

```
python path/to/smtp_credentials_generate.py wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY us-east-1
```

Dans la commande précédente, procédez comme suit :
+ Remplacez *path/to/* par le chemin d'accès à l'emplacement où vous avez enregistré`smtp_credentials_generate.py`.
+ *wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY*Remplacez-la par la clé d'accès secrète que vous souhaitez convertir en mot de passe SMTP.
+ *us-east-1*Remplacez-le par la AWS région dans laquelle vous souhaitez utiliser les informations d'identification SMTP.

Lorsque ce script s'exécute correctement, la seule sortie est votre mot de passe SMTP.

------

## Migration d'un utilisateur SMTP d'une politique en ligne existante vers une politique de groupe (recommandation de sécurité)
<a name="migrate-inline-policy-to-group"></a>

**Important**  
Si vous avez créé des informations d'identification SMTP SES avant le 6 septembre 2024, une politique intégrée et une balise ont été associées à votre utilisateur SMTP. SES s'éloigne des politiques intégrées et vous encourage à faire de même en tant que recommandation de sécurité.

Avant de migrer un utilisateur SMTP d'une politique en ligne existante vers une stratégie de groupe, vous devez d'abord créer un groupe d'utilisateurs IAM avec la politique d'autorisations SES qui remplacera la politique en ligne. Si vous avez déjà créé ce groupe d'utilisateurs IAM, ou s'il a été créé automatiquement pour les informations d'identification SMTP que vous avez créées à partir du 6 septembre 2024, vous pouvez passer directement à l'*étape 10* des procédures suivantes.

**Pour migrer d'une politique en ligne existante vers un groupe géré**

1. Connectez-vous à la console IAM AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)l'adresse.

1. Sous **Gestion des accès**, sélectionnez **Politiques**, puis **Créer une politique**.

1. Dans l'**éditeur de politiques**, sélectionnez **JSON** et supprimez tout exemple de code dans l'éditeur.

1. Collez la politique d'autorisation suivante dans l'éditeur :

------
#### [ JSON ]

****  

   ```
   {
   "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
   "Effect": "Allow",
               "Action": "ses:SendRawEmail",
               "Resource": "*"
           }
       ]
   }
   ```

------

1. Sélectionnez **Suivant** et entrez `AmazonSesSendingAccess` dans le champ **Nom de la politique**, puis **Créer une politique**.

1. Sous **Gestion des accès**, sélectionnez **Groupes d'utilisateurs**, puis **Créer un groupe**.

1. Entrez `AWSSESSendingGroupDoNotRename` dans le champ **Nom du groupe d'utilisateurs**.

1. Ajoutez des utilisateurs SMTP au groupe en les sélectionnant dans le tableau **Ajouter des utilisateurs au groupe**.

1. Joignez la `AmazonSesSendingAccess` politique créée précédemment en la sélectionnant dans le tableau **Joindre des politiques d'autorisation**, puis en cliquant sur **Créer un groupe d'utilisateurs**.

   Maintenant que vous avez créé le groupe d'utilisateurs IAM avec la politique d'autorisations SES, vous pouvez faire migrer un utilisateur SMTP de sa politique en ligne actuelle vers cette politique de groupe, comme expliqué dans les étapes restantes.

1. Sous **Gestion des accès**, choisissez **Utilisateurs**, puis sélectionnez l'utilisateur SMTP que vous souhaitez migrer.

1. Sélectionnez l'onglet **Groupes** et choisissez **Ajouter un utilisateur aux groupes**.

1. Sélectionnez le `AWSSESSendingGroupDoNotRename` groupe suivi de **Ajouter un utilisateur à un ou** plusieurs groupes.

1. Sélectionnez l'onglet **Autorisations** et vérifiez que deux lignes sont répertoriées dans `AmazonSesSendingAccess` la colonne **Nom de la politique**, l'une avec *Inline* et l'autre avec *Group `AWSSESSendingGroupDoNotRename`* répertorié dans la colonne **Attached via**.

1. Sélectionnez uniquement la ligne qui figure `AmazonSesSendingAccess` dans la colonne **Nom de la politique** et *Inline* dans la colonne **Attached via**, suivie de **Supprimer** et de confirmer avec **Supprimer la politique**.

   Vérifiez que la ligne contenant le *groupe `AWSSESSendingGroupDoNotRename`* dans la colonne **Attached via** est conservée.

1. Sélectionnez l'onglet **Tags**, puis **Manage tags**.

1. Sélectionnez **Supprimer** à côté de la ligne figurant *InvokedBy*dans la colonne **Clé** et *SESConsole*dans la colonne **Valeur**, puis **Enregistrer les modifications**.

**Important**  
La `AmazonSesSendingAccess` politique (soit en ligne, soit en tant que stratégie de groupe, soit les deux) doit rester attachée à l'utilisateur SMTP pour s'assurer que son envoi n'est pas impacté. Ne supprimez la politique intégrée qu'une fois que la stratégie de groupe est attachée à votre utilisateur. 

# Connexion à un point de terminaison SMTP Amazon SES
<a name="smtp-connect"></a>

Pour envoyer un e-mail à l'aide de l'interface SMTP Amazon SES, vous devez vous connecter à un point de terminaison SMTP. Pour obtenir la liste complète des points de terminaison SMTP Amazon SES, veuillez consulter [Points de terminaison et quotas Amazon Simple Email Service](https://docs.aws.amazon.com/general/latest/gr/ses.html) dans le document *Références générales AWS*.

Le point de terminaison SMTP Amazon SES nécessite que toutes les connexions soient chiffrées à l'aide du protocole TLS (Transport Layer Security). (Notez que le protocole TLS est souvent désigné par le nom de son prédécesseur, le protocole SSL.) Amazon SES prend en charge deux mécanismes d'établissement d'une connexion à chiffrement TLS : STARTTLS et TLS Wrapper. Consultez la documentation de votre logiciel pour déterminer s'il prend en charge STARTTLS, TLS Wrapper ou les deux.

Amazon Elastic Compute Cloud (Amazon EC2) limite par défaut le trafic des e-mails sur le port 25. Pour éviter les délais d'expiration lors de l'envoi d'e-mails via le point de terminaison SMTP à partir d'EC2, remplissez une [Demande de suppression des limites d'envoi d'e-mails](https://aws-portal.amazon.com/gp/aws/html-forms-controller/contactus/ec2-email-limit-rdns-request) pour supprimer la limite. Vous pouvez également envoyer des e-mails à l'aide d'un autre port ou utiliser un [point de terminaison d'un VPC Amazon](send-email-set-up-vpc-endpoints.md).

Pour des problèmes de connexion SMTP, consultez [Problèmes SMTP](troubleshoot-smtp.md).

## STARTTLS
<a name="smtp-connect-starttls"></a>

STARTTLS est un moyen de mettre à niveau une connexion non chiffrée en connexion chiffrée. Il existe différentes versions de STARTTLS selon les protocoles. La version SMTP est définie dans [RFC 3207](https://www.ietf.org/rfc/rfc3207.txt).

Pour configurer une connexion STARTTLS, le client SMTP se connecte au point de terminaison SMTP Amazon SES sur le port 25, 587 ou 2587, émet une commande EHLO et attend que le serveur annonce qu'il prend en charge l'extension SMTP STARTTLS. Le client émet ensuite la commande STARTTLS afin de lancer la négociation TLS. Une fois la négociation terminée, le client émet une commande EHLO via la nouvelle connexion chiffrée et la session SMTP se poursuit normalement.

## TLS Wrapper
<a name="smtp-connect-tlswrapper"></a>

TLS Wrapper (également connu sous le nom de SMTPS ou de protocole de négociation) est un moyen de lancer une connexion chiffrée sans commencer par établir une connexion non chiffrée. Avec TLS Wrapper, le point de terminaison SMTP Amazon SES n'effectue pas de négociation TLS : c'est la responsabilité du client de se connecter au point de terminaison à l'aide de TLS et de continuer à utiliser TLS pour la totalité de la conversation. TLS Wrapper est un protocole plus ancien, mais de nombreux clients continuent de le prendre en charge.

Pour configurer une connexion TLS Wrapper, le client SMTP se connecte au point de terminaison SMTP Amazon SES sur le port 465 ou 2465. Le serveur présente son certificat, le client émet une commande EHLO et la session SMTP se poursuit normalement.

# Envoi d'e-mails via Amazon SES à l'aide de packages logiciels
<a name="send-email-smtp-software-package"></a>

Il existe un certain nombre de packages logiciels commerciaux ou open source qui prennent en charge l'envoi d'e-mails via SMTP. Voici quelques exemples :
+ Plates-formes de création de blogs
+ Agrégateurs RSS
+ Logiciel de gestion de liste
+ Systèmes de flux de travail

Vous pouvez configurer ces logiciels compatibles avec SMTP de façon à envoyer des e-mails via l'interface SMTP Amazon SES. Pour obtenir des instructions sur la configuration de SMTP pour un package logiciel spécifique, consultez la documentation du logiciel concerné.

La procédure suivante montre comment configurer l'envoi Amazon SES dans JIRA, une solution de suivi des problèmes connue. Avec cette configuration, JIRA peut avertir les utilisateurs par e-mail dès qu'un problème de logiciel change de statut.

**Pour configurer JIRA de façon à envoyer un e-mail à l'aide d'Amazon SES**

1. À l'aide de votre navigateur Web, connectez-vous à JIRA avec des informations d'identification de l'administrateur.

1. Dans la fenêtre du navigateur, choisissez **Administration (Administration)**.

1. Dans le menu **System (Système)**, choisissez **Mail (e-mail)**.

1. Sur la page **Mail administration (Administration des e-mails)**, choisissez **Mail Servers (Serveurs des e-mails)**.

1. Choisissez **Configure new SMTP mail server (Configurer un nouveau serveur de messagerie SMTP)**.

1. Sur l'écran **Add SMTP Mail Server (Ajouter un serveur de messagerie SMTP)**, remplissez les champs suivants :

   1. **Name (Nom)** – Nom descriptif pour ce serveur.

   1. **From address (Adresse d'origine)** – Adresse à partir de laquelle l'e-mail de retour à l'expéditeur sera envoyé. Vous devez vérifier cette adresse e-mail avec Amazon SES avant de pouvoir l'utiliser pour envoyer des messages. Pour en savoir plus sur la vérification, consultez [Identités vérifiées dans Amazon SES](verify-addresses-and-domains.md).

   1. **Email prefix (Préfixe de l'e-mail)** – Chaîne que JIRA ajoute à chaque ligne d'objet avant l'envoi.

   1. **Protocol (Protocole)** – Choisissez **SMTP**.
**Note**  
Si vous ne pouvez pas vous connecter à Amazon SES à l'aide de ce paramètre, essayez **SECURE\$1SMTP**.

   1. **Host Name (Nom d'hôte)** – Pour obtenir la liste des points de terminaison SMTP Amazon SES, consultez [Connexion à un point de terminaison SMTP Amazon SES](smtp-connect.md). Par exemple, si vous souhaitez utiliser le point de terminaison Amazon SES dans la région USA Ouest (Oregon), le nom d'hôte est *email-smtp.us-west-2.amazonaws.com*.

   1. **SMTP port**—25, 587 ou 2587 (pour vous connecter à l'aide de STARTTLS), ou 465 ou 2465 (pour vous connecter à l'aide de TLS Wrapper).

   1. **TLS** – Activez la case à cocher.

   1. **User name (Nom d'utilisateur)** – Votre nom d'utilisateur SMTP.

   1. **Password (Mot de passe)** – Votre mot de passe SMTP.

   Vous pouvez voir les paramètres pour TLS Wrapper dans l'image suivante.  
![\[SMTP email configuration for JIRA (Configuration d'e-mails SMTP pour JIRA)\]](http://docs.aws.amazon.com/fr_fr/ses/latest/dg/images/SMTP_jira.png)

1. Choisissez **Test Connection (Connexion test)**. Si l'e-mail de test envoyé par JIRA via Amazon SES arrive correctement, cela indique que votre configuration est terminée.

# Envoi d'un e-mail via l'interface SMTP Amazon SES par programmation
<a name="send-using-smtp-programmatically"></a>

Pour envoyer un e-mail à l'aide de l'interface SMTP Amazon SES, vous pouvez utiliser un langage de programmation, un serveur de messagerie ou une application compatible avec SMTP. Avant de commencer, complétez les tâches dans [Configuration d'Amazon Simple Email Service](setting-up.md). Vous aurez également besoin d'obtenir les informations supplémentaires suivantes : 
+ Vos informations d'identification Amazon SMTP SES, qui vous permettent de vous connecter au point de terminaison Amazon SMTP SES. Pour obtenir vos informations d'identification SMTP Amazon SES, consultez [Obtention des informations d'identification SMTP Amazon SES](smtp-credentials.md). 
**Important**  
Vos informations d'identification SMTP sont différentes de vos AWS informations d'identification. Pour en savoir plus sur les informations d'identification, consultez [Types d'informations d'identification Amazon SES](send-email-concepts-credentials.md).
+ Adresse du point de terminaison SMTP. Pour obtenir la liste des points de terminaison SMTP Amazon SES, consultez [Connexion à un point de terminaison SMTP Amazon SES](smtp-connect.md).
+ Le numéro de port de l'interface SMTP Amazon SES, qui dépend de la méthode de connexion. Pour plus d'informations, consultez [Connexion à un point de terminaison SMTP Amazon SES](smtp-connect.md).

## Exemples de code
<a name="send-email-smtp-code-examples"></a>

Vous pouvez accéder à l'interface SMTP Amazon SES à l'aide d'un langage de programmation compatible avec SMTP. Vous fournissez le nom d'hôte et le numéro de port SMTP Amazon SES, ainsi que vos informations d'identification SMTP, puis vous utilisez les fonctions SMTP génériques du langage de programmation pour envoyer l'e-mail.

Amazon Elastic Compute Cloud (Amazon EC2) limite par défaut le trafic des e-mails sur le port 25. Pour éviter les délais d'expiration lors de l'envoi d'e-mails via le point de terminaison SMTP à partir d'Amazon EC2, vous pouvez demander la suppression de ces restrictions. Pour plus d'informations, consultez [Comment supprimer la restriction sur le port 25 de mon instance ou AWS Lambda fonction Amazon EC2](https://aws.amazon.com/premiumsupport/knowledge-center/ec2-port-25-throttle/) ? dans le AWS Knowledge Center.

Les exemples de code de cette section pour Java et PHP utilisent le port 587 pour éviter ce problème. 

**Note**  
Dans ces didacticiels, vous vous envoyez un e-mail afin de vérifier si vous l'avez reçu. Pour d'autres essais ou pour des tests de charge, utilisez le simulateur de boîte aux lettres Amazon SES. Les e-mails envoyés au simulateur de boîte aux lettres ne sont pas pris en compte dans votre quota d'envoi et vos taux de retours à l'expéditeur et de réclamations. Pour plus d'informations, consultez [Utilisation manuelle du simulateur de boîte aux lettres](send-an-email-from-console.md#send-email-simulator).

**Sélectionnez un langage de programmation pour afficher l'exemple correspondant à cette langue:**

**Avertissement**  
Amazon SES déconseille d'utiliser des informations d'identification statiques. Reportez-vous [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html)à pour savoir comment améliorer votre niveau de sécurité en supprimant les informations d'identification codées en dur de votre code source. Ce didacticiel est uniquement fourni dans le but de tester l'interface SMTP d'Amazon SES dans un environnement hors production.

------
#### [ Java ]

Cet exemple utilise l'[IDE Eclipse](http://www.eclipse.org/) et l'[JavaMail API](https://github.com/javaee/javamail/releases) pour envoyer des e-mails via Amazon SES à l'aide de l'interface SMTP.

Avant d'effectuer la procédure suivante, effectuez les tâches dans [Configuration d'Amazon Simple Email Service](setting-up.md).

**Pour envoyer un e-mail à l'aide de l'interface SMTP Amazon SES avec Java**

1. Dans un navigateur Web, accédez à la [JavaMail GitHub page](https://github.com/javaee/javamail/releases). Sous **Assets**, choisissez **javax.mail.jar pour télécharger la dernière** version de. JavaMail
**Important**  
Ce didacticiel nécessite JavaMail la version 1.5 ou ultérieure. Ces procédures ont été testées à l'aide de JavaMail la version 1.6.1.

1. **Dans un navigateur Web, rendez-vous sur la [ GitHub page d'activation de Jakarta et, sous JavaBeans Activation](https://github.com/eclipse-ee4j/jaf/releases) [Framework 1.2.1 Final Release](https://github.com/eclipse-ee4j/jaf/releases/tag/1.2.1), téléchargez le fichier jakarta.activation.jar**

1. Créez un projet Eclipse en procédant comme suit :

   1. Démarrez Eclipse.

   1. Dans Eclipse, choisissez **File (Fichier)**, **New (Nouveau)**, puis **Java Project**.

   1. Dans la boîte de dialogue **Create a Java Project (Créer un projet Java)**, saisissez un nom de projet, puis choisissez **Next (Suivant).**

   1. Dans la boîte de dialogue **Java Settings (Paramètres Java)**, choisissez l'onglet **Libraries (Bibliothèques)**.

   1. ****Sélectionnez **Classpath** et ajoutez les deux fichiers jar externes **javax.mail.jar et jakarta.activation.jar à l'aide du bouton Ajouter un fichier** externe. JARs****

   1. Choisissez **Ajouter un élément externe JARs**.

   1. Accédez au dossier dans lequel vous avez effectué le téléchargement JavaMail. Choisissez le fichier `javax.mail.jar`, puis **Open (Ouvrir)**.

   1. Dans la boîte de dialogue **Java Settings (Paramètres Java)**, choisissez **Finish (Terminer)**.

1. Dans la fenêtre **Package Explorer (Explorateur de paquets)** d'Eclipse, développez votre projet.

1. Sous votre projet, cliquez avec le bouton droit sur le répertoire **src**, puis choisissez **New (Nouveau)** et **Class (Classe)**.

1. Dans la boîte de dialogue **New Java Class (Nouvelle classe Java)**, dans le champ **Name (Nom)**, entrez `AmazonSESSample` et choisissez **Finish (Terminer)**.

1. Remplacez l'intégralité du contenu du **SESSamplefichier .java d'Amazon** par le code suivant :

   ```
     1. import java.util.Properties;
     2. 
     3. import javax.mail.Message;
     4. import javax.mail.Session;
     5. import javax.mail.Transport;
     6. import javax.mail.internet.InternetAddress;
     7. import javax.mail.internet.MimeMessage;
     8. 
     9. public class AmazonSESSample {
    10. 
    11.     // Replace sender@example.com with your "From" address.
    12.     // This address must be verified.
    13.     static final String FROM = "sender@example.com";
    14.     static final String FROMNAME = "Sender Name";
    15.     
    16.     // Replace recipient@example.com with a "To" address. If your account 
    17.     // is still in the sandbox, this address must be verified.
    18.     static final String TO = "recipient@example.com";
    19.     
    20.     // Replace smtp_username with your Amazon SES SMTP user name.
    21.     static final String SMTP_USERNAME = "smtp_username";
    22.       
    23.     // The name of the Configuration Set to use for this message.
    24.     // If you comment out or remove this variable, you will also need to
    25.     // comment out or remove the header below.
    26.     static final String CONFIGSET = "ConfigSet";
    27.     
    28.     // Amazon SES SMTP host name. This example uses the US West (Oregon) region.
    29.     // See https://docs.aws.amazon.com/ses/latest/DeveloperGuide/regions.html#region-endpoints
    30.     // for more information.
    31.     static final String HOST = "email-smtp.us-west-2.amazonaws.com";
    32.     
    33.     // The port you will connect to on the Amazon SES SMTP endpoint. 
    34.     static final int PORT = 587;
    35.     
    36.     static final String SUBJECT = "Amazon SES test (SMTP interface accessed using Java)";
    37.     
    38.     static final String BODY = String.join(
    39.             System.getProperty("line.separator"),
    40.             "<h1>Amazon SES SMTP Email Test</h1>",
    41.             "<p>This email was sent with Amazon SES using the ", 
    42.             "<a href='https://github.com/javaee/javamail'>Javamail Package</a>",
    43.             " for <a href='https://www.java.com'>Java</a>."
    44.         );
    45. 
    46.     public static void main(String[] args) throws Exception {
    47. 
    48.         // Create a Properties object to contain connection configuration information.
    49.         Properties props = System.getProperties();
    50.         props.put("mail.transport.protocol", "smtp");
    51.         props.put("mail.smtp.port", PORT); 
    52.         props.put("mail.smtp.starttls.enable", "true");
    53.         props.put("mail.smtp.auth", "true");
    54. 
    55.         // Create a Session object to represent a mail session with the specified properties. 
    56.         Session session = Session.getDefaultInstance(props);
    57. 
    58.         // Create a message with the specified information. 
    59.         MimeMessage msg = new MimeMessage(session);
    60.         msg.setFrom(new InternetAddress(FROM,FROMNAME));
    61.         msg.setRecipient(Message.RecipientType.TO, new InternetAddress(TO));
    62.         msg.setSubject(SUBJECT);
    63.         msg.setContent(BODY,"text/html");
    64.         
    65.         // Add a configuration set header. Comment or delete the 
    66.         // next line if you are not using a configuration set
    67.         msg.setHeader("X-SES-CONFIGURATION-SET", CONFIGSET);
    68.             
    69.         // Create a transport.
    70.         Transport transport = session.getTransport();
    71. 
    72.         // Get the password 
    73.         String SMTP_PASSWORD = fetchSMTPPasswordFromSecureStorage();
    74.                     
    75.         // Send the message.
    76.         try
    77.         {
    78.             System.out.println("Sending...");
    79.             
    80.             // Connect to Amazon SES using the SMTP username and password you specified above.
    81.             transport.connect(HOST, SMTP_USERNAME, SMTP_PASSWORD);
    82.             
    83.             // Send the email.
    84.             transport.sendMessage(msg, msg.getAllRecipients());
    85.             System.out.println("Email sent!");
    86.         }
    87.         catch (Exception ex) {
    88.             System.out.println("The email was not sent.");
    89.             System.out.println("Error message: " + ex.getMessage());
    90.         }
    91.         finally
    92.         {
    93.             // Close and terminate the connection.
    94.             transport.close();
    95.         }
    96.     }
    97. 
    98.     static String fetchSMTPPasswordFromSecureStorage() {
    99.         /* IMPLEMENT THIS METHOD */
   100.         // For example, you might fetch it from a secure location or AWS Secrets Manager: https://aws.amazon.com/secrets-manager/
   101.     }
   102. }
   ```

1. Dans **Amazon SESSample .java**, remplacez les adresses e-mail suivantes par vos propres valeurs :
**Important**  
Les adresses e-mail sont sensibles à la casse. Assurez-vous que les adresses sont exactement les mêmes que celles que vous avez vérifiées.
   + *sender@example.com*— Remplacez par votre adresse e-mail « De ». Vous devez vérifier cette adresse avant d'exécuter ce programme. Pour de plus amples informations, veuillez consulter [Identités vérifiées dans Amazon SES](verify-addresses-and-domains.md).
   + *recipient@example.com*— Remplacez par votre adresse e-mail « À ». Si votre compte est encore dans l'environnement de test (sandbox), vous devez vérifier cette adresse avant de l'utiliser. Pour de plus amples informations, veuillez consulter [Demande d'accès à la production (sortie du sandbox d'Amazon SES)](request-production-access.md).

1. Dans **Amazon SESSample .java**, remplacez les valeurs suivantes par vos propres valeurs :
   + *smtp\$1username*— Remplacez par votre identifiant de nom d'utilisateur SMTP. Notez que les informations d'identification de votre nom d'utilisateur SMTP sont une chaîne alphanumérique de 20 caractères, et pas un nom intelligible.
   + *smtp\$1password*— ``fetchSMTPPasswordFromSecureStorage`` Implémente pour récupérer le mot de passe.

1. (Facultatif) Si vous souhaitez utiliser un point de terminaison SMTP Amazon SES dans un Région AWS autre endroit*email-smtp.us-west-2.amazonaws.com*, remplacez la valeur de la variable par le point `HOST` de terminaison que vous souhaitez utiliser. Pour connaître la liste des régions dans lesquelles Amazon SES est disponible, consultez [Amazon Simple Email Service (Amazon SES)](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region) dans le document *Références générales AWS*.

1. (Facultatif) – Si vous souhaitez utiliser un jeu de configurations lors de l'envoi de cet e-mail, remplacez la valeur de la variable *ConfigSet* par le nom du jeu de configurations. Pour en savoir plus sur les jeux de configuration, consultez [Utilisation des jeux de configuration dans Amazon SES](using-configuration-sets.md).

1. Enregistrez le **SESSamplefichier .java d'Amazon.**

1. Pour créer le projet, choisissez **Project (Projet)**, puis **Build Project (Créer un projet)**. (Si cette option est désactivée, cela peut signifier que la génération automatique est activée.)

1. Pour démarrer le programme et envoyer l'e-mail, choisissez **Run (Exécuter)**, puis à nouveau **Run (Exécuter)**.

1. Vérifiez la sortie. Si l'e-mail a été envoyé avec succès, la console affiche *« E-mail envoyé \$1 »* Dans le cas contraire, un message d'erreur s'affiche.

1. Connectez-vous au client de messagerie de l'adresse du destinataire. Vous verrez le message que vous avez envoyé.

------
#### [ PHP  ]

Cet exemple utilise la PHPMailer classe pour envoyer des e-mails via Amazon SES à l'aide de l'interface SMTP. 

Avant d'effectuer la procédure suivante, effectuez les tâches dans [Configuration d'Amazon Simple Email Service](setting-up.md). En plus de configurer Amazon SES, vous devez remplir les conditions préalables suivantes pour envoyer des e-mails avec PHP :

**Prérequis :**
+ **Installer PHP** — PHP est disponible sur [http://php.net/downloads.php](https://php.net/downloads.php). Après avoir installé PHP, ajoutez le chemin d'accès à PHP dans vos variables d'environnement afin de pouvoir exécuter PHP à partir de n'importe quelle invite de commande.
+ **Installation du gestionnaire de dépendances Composer** : après avoir installé le gestionnaire de dépendances Composer, vous pouvez télécharger et installer la PHPMailer classe et ses dépendances. Pour installer Composer, suivez les instructions d'installation sur [https://getcomposer.org/download](https://getcomposer.org/download).
+ **Installer la PHPMailer classe** — Après avoir installé Composer, exécutez la commande suivante pour l'installer PHPMailer : 

  ```
  path/to/composer require phpmailer/phpmailer
  ```

  Dans la commande précédente, remplacez *path/to/* par le chemin où vous avez installé Composer.

**Pour envoyer un e-mail à l'aide de l'interface SMTP Amazon SES avec PHP**

1. Créez un fichier nommé **amazon-ses-smtp-sample.php.** Ouvrez le fichier dans un éditeur de texte et collez le code suivant :

   ```
    1. <?php
    2. 
    3. // Import PHPMailer classes into the global namespace
    4. // These must be at the top of your script, not inside a function
    5. use PHPMailer\PHPMailer\PHPMailer;
    6. use PHPMailer\PHPMailer\Exception;
    7. 
    8. // If necessary, modify the path in the require statement below to refer to the
    9. // location of your Composer autoload.php file.
   10. require 'vendor/autoload.php';
   11. 
   12. // Replace sender@example.com with your "From" address.
   13. // This address must be verified with Amazon SES.
   14. $sender = 'sender@example.com';
   15. $senderName = 'Sender Name';
   16. 
   17. // Replace recipient@example.com with a "To" address. If your account
   18. // is still in the sandbox, this address must be verified.
   19. $recipient = 'recipient@example.com';
   20. 
   21. // Replace smtp_username with your Amazon SES SMTP user name.
   22. $usernameSmtp = 'smtp_username';
   23. 
   24. // Specify a configuration set. If you do not want to use a configuration
   25. // set, comment or remove the next line.
   26. $configurationSet = 'ConfigSet';
   27. 
   28. // If you're using Amazon SES in a region other than US West (Oregon),
   29. // replace email-smtp.us-west-2.amazonaws.com with the Amazon SES SMTP
   30. // endpoint in the appropriate region.
   31. $host = 'email-smtp.us-west-2.amazonaws.com';
   32. $port = 587;
   33. 
   34. // The subject line of the email
   35. $subject = 'Amazon SES test (SMTP interface accessed using PHP)';
   36. 
   37. // The plain-text body of the email
   38. $bodyText =  "Email Test\r\nThis email was sent through the
   39.     Amazon SES SMTP interface using the PHPMailer class.";
   40. 
   41. // The HTML-formatted body of the email
   42. $bodyHtml = '<h1>Email Test</h1>
   43.     <p>This email was sent through the
   44.     <a href="https://aws.amazon.com/ses">Amazon SES</a> SMTP
   45.     interface using the <a href="https://github.com/PHPMailer/PHPMailer">
   46.     PHPMailer</a> class.</p>';
   47. 
   48. $mail = new PHPMailer(true);
   49. 
   50. try {
   51.     // Specify the SMTP settings.
   52.     $mail->isSMTP();
   53.     $mail->setFrom($sender, $senderName);
   54.     $mail->Username   = $usernameSmtp;
   55.     $mail->Password   = fetchSMTPPasswordFromSecureStorage();
   56.     $mail->Host       = $host;
   57.     $mail->Port       = $port;
   58.     $mail->SMTPAuth   = true;
   59.     $mail->SMTPSecure = 'tls';
   60.     $mail->addCustomHeader('X-SES-CONFIGURATION-SET', $configurationSet);
   61. 
   62.     // Specify the message recipients.
   63.     $mail->addAddress($recipient);
   64.     // You can also add CC, BCC, and additional To recipients here.
   65. 
   66.     // Specify the content of the message.
   67.     $mail->isHTML(true);
   68.     $mail->Subject    = $subject;
   69.     $mail->Body       = $bodyHtml;
   70.     $mail->AltBody    = $bodyText;
   71.     $mail->Send();
   72.     echo "Email sent!" , PHP_EOL;
   73. } catch (phpmailerException $e) {
   74.     echo "An error occurred. {$e->errorMessage()}", PHP_EOL; //Catch errors from PHPMailer.
   75. } catch (Exception $e) {
   76.     echo "Email not sent. {$mail->ErrorInfo}", PHP_EOL; //Catch errors from Amazon SES.
   77. }
   78. function fetchSMTPPasswordFromSecureStorage() {
   79. /* IMPLEMENT THIS METHOD */
   80. // For example, you might fetch it from a secure location or AWS Secrets Manager: https://aws.amazon.com/secrets-manager/
   81. }
   82. 
   83. ?>
   ```

1. Dans le **amazon-ses-smtp-samplefichier .php**, remplacez les valeurs suivantes par vos propres valeurs :
   + *sender@example.com*— Remplacez par une adresse e-mail que vous avez vérifiée auprès d'Amazon SES. Pour de plus amples informations, veuillez consulter [Identités vérifiées](verify-addresses-and-domains.md). Les adresses e-mail d'Amazon SES sont sensibles à la casse. Assurez-vous que l'adresse que vous saisissez est exactement la même que celle que vous avez vérifiée.
   + *recipient@example.com*— Remplacez par l'adresse du destinataire. Si votre compte est encore dans l'environnement de test (sandbox), vous devez vérifier cette adresse avant de l'utiliser. Pour plus d'informations, consultez [Demande d'accès à la production (sortie du sandbox d'Amazon SES)](request-production-access.md). Assurez-vous que l'adresse que vous saisissez est exactement la même que celle que vous avez vérifiée.
   + *smtp\$1username*— Remplacez-le par votre nom d'utilisateur SMTP, que vous avez obtenu sur la page des [paramètres SMTP](https://console.aws.amazon.com/ses/home?#smtp-settings:) de la console Amazon SES. Ce n'est **pas** le même que votre ID de clé d'accès AWS . Notez que les informations d'identification de votre nom d'utilisateur SMTP sont une chaîne alphanumérique de 20 caractères, et pas un nom intelligible.
   + *smtp\$1password*— ``fetchSMTPPasswordFromSecureStorage`` Implémente pour récupérer le mot de passe.
   + (Facultatif) *ConfigSet* — Si vous souhaitez utiliser un ensemble de configuration lors de l'envoi de cet e-mail, remplacez cette valeur par le nom du jeu de configuration. Pour en savoir plus sur les jeux de configurations, consultez [Utilisation des jeux de configuration dans Amazon SES](using-configuration-sets.md).
   + (Facultatif) *email-smtp.us-west-2.amazonaws.com* — Si vous souhaitez utiliser un point de terminaison SMTP Amazon SES dans une région autre que l'ouest des États-Unis (Oregon), remplacez-le par le point de terminaison SMTP Amazon SES de la région que vous souhaitez utiliser. Pour obtenir la liste des points de terminaison SMTP URLs pour Régions AWS lesquels Amazon SES est disponible, consultez [Amazon Simple Email Service (Amazon SES](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region)) dans le. *Références générales AWS*

1. Enregistrez le **amazon-ses-smtp-samplefichier .php.**

1. Pour exécuter le programme, ouvrez une invite de commande dans le même répertoire que **amazon-ses-smtp-sample.php**, puis tapez**php amazon-ses-smtp-sample.php**.

1. Vérifiez la sortie. Si l'e-mail a été envoyé avec succès, la console affiche *« E-mail envoyé \$1 »* Dans le cas contraire, un message d'erreur s'affiche.

1. Connectez-vous au client de messagerie de l'adresse du destinataire. Vous verrez le message que vous avez envoyé.

------

# Intégration d'Amazon SES à votre serveur de messagerie existant
<a name="send-email-smtp-existing-server"></a>

Si vous administrez actuellement votre propre serveur de messagerie, vous pouvez utiliser le point de terminaison SMTP Amazon SES pour envoyer tous vos e-mails sortants à Amazon SES. Il n'est pas nécessaire de modifier vos clients et applications de messagerie existants ; le passage à Amazon SES sera transparent pour eux.

Plusieurs agents de transfert de courrier (MTAs) prennent en charge l'envoi d'e-mails via des relais SMTP. Cette section fournit des conseils généraux sur la façon de configurer certains e-mails courants pour envoyer des e-mails MTAs à l'aide de l'interface SMTP d'Amazon SES.

Le point de terminaison SMTP Amazon SES nécessite que toutes les connexions soient chiffrées à l'aide du protocole TLS (Transport Layer Security).

**Topics**
+ [

# Intégration d'Amazon SES à Postfix
](postfix.md)
+ [

# Intégration d'Amazon SES à Sendmail
](send-email-sendmail.md)
+ [

# Intégration d'Amazon SES au serveur SMTP IIS de Microsoft Windows Server
](send-email-windows-server.md)

# Intégration d'Amazon SES à Postfix
<a name="postfix"></a>

Postfix est une alternative à l'agent MTA (Message Transfert Agent) de Sendmail couramment utilisé. Pour en savoir plus sur Postfix, consultez [http://www.postfix.org](http://www.postfix.org). Les procédures présentées dans cette rubrique fonctionnent avec Linux, macOS ou Unix.

**Note**  
Postfix est une application tierce qui n'est ni développée ni prise en charge par Amazon Web Services. Les procédures décrites dans cette section sont fournies à titre informatif seulement et peuvent être modifiées sans préavis.

## Conditions préalables
<a name="send-email-postfix-prereqs"></a>

Avant d'exécuter les procédures fournies dans cette section, vous devez effectuer les tâches suivantes :
+ Désinstallez l'application Sendmail si elle est installée sur votre système. La procédure d'exécution de cette étape varie en fonction du système d'exploitation que vous utilisez.
**Important**  
Les références à *sendmail* suivantes sont liées à la commande Postfix `sendmail` et non à l’application Sendmail.
+ Installez Postfix. La procédure d'exécution de cette étape varie en fonction du système d'exploitation que vous utilisez.
+ Installez un package d'authentification SASL. La procédure d'exécution de cette étape varie en fonction du système d'exploitation que vous utilisez. Par exemple, si vous utilisez un système RedHat basé, vous devez installer le `cyrus-sasl-plain` package. Si vous utilisez un système basé sur Debian ou Ubuntu, vous devez installer le package `libsasl2-modules`.
+ Vérifiez l'adresse e-mail ou le domaine que vous utiliserez pour envoyer les e-mails. Pour plus d'informations, consultez [Création d'une identité d'adresse e-mail](creating-identities.md#verify-email-addresses-procedure).
+ Si votre compte est toujours dans l'environnement de test (sandbox), vous ne pouvez envoyer des e-mails qu'aux adresses e-mail vérifiées. Pour plus d'informations, consultez [Demande d'accès à la production (sortie du sandbox d'Amazon SES)](request-production-access.md).

## Configuration de Postfix
<a name="send-email-postfix"></a>

Terminez la procédure suivante afin de configurer votre serveur de messagerie pour envoyer des e-mails via Amazon SES en utilisant Postfix.

**Pour configurer Postfix**

1. Sur la ligne de commande, entrez la commande suivante :

   ```
   sudo postconf -e "relayhost = [email-smtp.us-west-2.amazonaws.com]:587" \
   "smtp_sasl_auth_enable = yes" \
   "smtp_sasl_security_options = noanonymous" \
   "smtp_sasl_password_maps = hash:/etc/postfix/sasl_passwd" \
   "smtp_use_tls = yes" \
   "smtp_tls_security_level = secure" \
   "smtp_tls_note_starttls_offer = yes"
   ```
**Note**  
Si vous utilisez Amazon SES dans une AWS région autre que l'ouest des États-Unis (Oregon), remplacez *email-smtp.us-west-2.amazonaws.com* la commande précédente par le point de terminaison SMTP de la région appropriée. Pour de plus amples informations, veuillez consulter [Régions et Amazon SES](regions.md).

1. Ouvrez le fichier `/etc/postfix/master.cf` dans un éditeur de texte. Recherchez l'entrée suivante :

   ```
   -o smtp_fallback_relay=
   ```

   Si vous recherchez cette entrée, placez-la en commentaire en insérant un caractère `#` (dièse) en début de ligne. Enregistrez et fermez le fichier .

   Si cette entrée n'est pas présente, passez à l'étape suivante.

1. Ouvrez le fichier `/etc/postfix/sasl_passwd` dans un éditeur de texte. Si le fichier n'existe pas déjà, créez-le.

1. Ajoutez la ligne suivante à `/etc/postfix/sasl_passwd` :

   ```
   [email-smtp.us-west-2.amazonaws.com]:587 SMTPUSERNAME:SMTPPASSWORD
   ```
**Note**  
Remplacez *SMTPUSERNAME* et *SMTPPASSWORD* par vos identifiants de connexion SMTP. Vos informations d'identification de connexion SMTP ne sont pas les mêmes que votre ID de clé d'accès AWS et votre clé d'accès secrète. Pour en savoir plus sur les informations d'identification, consultez [Obtention des informations d'identification SMTP Amazon SES](smtp-credentials.md).  
Si vous utilisez Amazon SES dans une AWS région autre que l'ouest des États-Unis (Oregon), remplacez *email-smtp.us-west-2.amazonaws.com* dans l'exemple précédent par le point de terminaison SMTP de la région appropriée. Pour de plus amples informations, veuillez consulter [Régions et Amazon SES](regions.md).

   Enregistrez et fermez `sasl_passwd`.

1. À l'invite de commande, tapez la commande suivante pour créer un fichier de base de données hashmap contenant vos informations d'identification SMTP :

   ```
   sudo postmap hash:/etc/postfix/sasl_passwd
   ```

1. (Facultatif) Les fichiers `/etc/postfix/sasl_passwd` et `/etc/postfix/sasl_passwd.db` que vous avez créés au cours des étapes précédentes ne sont pas chiffrés. Ces fichiers contenant vos informations d'identification SMTP, nous vous recommandons d'en modifier les autorisations et la propriété afin d'en restreindre l'accès. Pour restreindre l'accès à ces fichiers :

   1. Dans une invite de commande, entrez la commande suivante pour modifier la propriété des fichiers :

      ```
      sudo chown root:root /etc/postfix/sasl_passwd /etc/postfix/sasl_passwd.db
      ```

   1. Dans une invite de commande, entrez la commande suivante pour modifier les autorisations des fichiers pour que seul l'utilisateur racine puisse lire ou écrire dans ces fichiers :

      ```
      sudo chmod 0600 /etc/postfix/sasl_passwd /etc/postfix/sasl_passwd.db
      ```

1. Indiquez à Postfix où trouver le certificat d'une autorité de certification (nécessaire pour vérifier le certificat de serveur Amazon SES). La commande que vous utilisez dans cette étape varie en fonction de votre système d'exploitation.
   + Si vous utilisez Amazon Linux, Red Hat Enterprise Linux ou une distribution connexe, saisissez la commande suivante : 

     ```
     sudo postconf -e 'smtp_tls_CAfile = /etc/ssl/certs/ca-bundle.crt'
     ```
   + Si vous utilisez Ubuntu ou une distribution connexe, saisissez la commande suivante :

     ```
     sudo postconf -e 'smtp_tls_CAfile = /etc/ssl/certs/ca-certificates.crt'
     ```
   + Si vous utilisez macOS, vous pouvez générer le certificat à partir de l'utilitaire Keychain de votre système. Pour générer le certificat, tapez la commande suivante sur la ligne de commande :

     ```
     sudo security find-certificate -a -p /System/Library/Keychains/SystemRootCertificates.keychain | sudo tee /etc/ssl/certs/ca-bundle.crt > /dev/null
     ```

     Une fois le certificat généré, tapez la commande suivante :

     ```
     sudo postconf -e 'smtp_tls_CAfile = /etc/ssl/certs/ca-bundle.crt'
     ```

1. Tapez la commande suivante pour démarrer le serveur Postfix (ou pour recharger les paramètres de configuration si le serveur est déjà en cours d'exécution) :

   ```
   sudo postfix start; sudo postfix reload
   ```

1. Envoyez un e-mail de test en saisissant ce qui suit sur la ligne de commande, en appuyant sur Entrée après chaque ligne. Remplacez *sender@example.com* par votre adresse e-mail From. L'adresse d'expédition doit être vérifiée pour une utilisation avec Amazon SES. Remplacez *recipient@example.com* par l'adresse de destination. Si votre compte est encore dans l'environnement de test (sandbox), l'adresse du destinataire doit également être vérifiée. Enfin, la dernière ligne du message doit contenir uniquement un point (.), sans autre contenu.

   ```
   sendmail -f sender@example.com recipient@example.com
   From: Sender Name <sender@example.com>
   Subject: Amazon SES Test                
   This message was sent using Amazon SES.                
   .
   ```

1. Vérifiez la boîte aux lettres associée à l'adresse du destinataire. Si l'e-mail n'arrive pas, vérifiez le dossier des courriers indésirables. Si vous ne trouvez toujours pas l'e-mail, vérifiez le journal de messagerie de votre système (généralement situé dans `/var/log/maillog`) pour en savoir plus.

## Exemple d'utilisation avancée
<a name="send-email-postfix-advanced"></a>

Cet exemple montre comment envoyer un e-mail qui utilise un [jeu de configurations](using-configuration-sets.md) et l'encodage MIME en plusieurs parties pour envoyer une version en texte brut et une version HTML du message avec une pièce jointe. Il inclut également une [balise de lien](faqs-metrics.md#sending-metric-faqs-clicks-q5), qui peut être utilisée pour classer les événements de clic. Le contenu de l'e-mail étant spécifié dans un fichier externe, vous n'avez pas à entrer manuellement les commandes dans la session Postfix.

**Pour envoyer un e-mail MIME en plusieurs parties avec Postfix**

1. Dans un éditeur de texte, créez un fichier nommé `mime-email.txt`.

1. Dans le fichier texte, collez le contenu suivant, en remplaçant les valeurs en rouge par les valeurs appropriées de votre compte :

   ```
   X-SES-CONFIGURATION-SET: ConfigSet
   From:Sender Name <sender@example.com>
   Subject:Amazon SES Test
   MIME-Version: 1.0
   Content-Type: multipart/mixed; boundary="YWVhZDFlY2QzMGQ2N2U0YTZmODU"
   
   --YWVhZDFlY2QzMGQ2N2U0YTZmODU
   Content-Type: multipart/alternative; boundary="3NjM0N2QwMTE4MWQ0ZTg2NTYxZQ"
   
   --3NjM0N2QwMTE4MWQ0ZTg2NTYxZQ
   Content-Type: text/plain; charset=UTF-8
   Content-Transfer-Encoding: quoted-printable
   
   Amazon SES Test
   
   This message was sent from Amazon SES using the SMTP interface.
   
   For more information, see:
   http://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-smtp.html
   
   --3NjM0N2QwMTE4MWQ0ZTg2NTYxZQ
   Content-Type: text/html; charset=UTF-8
   Content-Transfer-Encoding: quoted-printable
   
   <html>
     <head>
   </head>
     <body>
       <h1>Amazon SES Test</h1>
         <p>This message was sent from Amazon SES using the SMTP interface.</p>
         <p>For more information, see
         <a ses:tags="samplekey0:samplevalue0;samplekey1:samplevalue1;" 
         href="http://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-smtp.html">
         Using the Amazon SES SMTP Interface to Send Email</a> in the <em>Amazon SES
         Developer Guide</em>.</p>
     </body>
   </html>
   --3NjM0N2QwMTE4MWQ0ZTg2NTYxZQ--
   --YWVhZDFlY2QzMGQ2N2U0YTZmODU
   Content-Type: application/octet-stream
   MIME-Version: 1.0
   Content-Transfer-Encoding: base64
   Content-Disposition: attachment; filename="customers.txt"
   
   SUQsRmlyc3ROYW1lLExhc3ROYW1lLENvdW50cnkKMzQ4LEpvaG4sU3RpbGVzLENh
   bmFkYQo5MjM4OSxKaWUsTGl1LENoaW5hCjczNCxTaGlybGV5LFJvZHJpZ3VleixV
   bml0ZWQgU3RhdGVzCjI4OTMsQW5heWEsSXllbmdhcixJbmRpYQ==
   --YWVhZDFlY2QzMGQ2N2U0YTZmODU--
   ```

   Enregistrez et fermez le fichier .

1. Sur la ligne de commande, entrez la commande suivante. Remplacez *sender@example.com* par votre adresse e-mail et remplacez *recipient@example.com* par l'adresse e-mail du destinataire.

   ```
   sendmail -f sender@example.com recipient@example.com < mime-email.txt
   ```

   Si la commande s'exécute correctement, elle se termine sans fournir de sortie.

1. Vérifiez que vous avez bien reçu l'e-mail dans votre boîte de réception. Si le message n'a pas été remis, vérifiez le journal de messagerie dans votre système.

# Intégration d'Amazon SES à Sendmail
<a name="send-email-sendmail"></a>

Sendmail a été lancé au début des années 1980 et a été continuellement amélioré depuis. Il s'agit d'un agent de transfert de messages (Message Transfert Agent, MTA) flexible et configurable avec une grande communauté d'utilisateurs. Sendmail a été racheté par Proofpoint en 2013, mais ce dernier continue à proposer une version open source de Sendmail. Vous pouvez télécharger la [version open source de Sendmail](https://www.proofpoint.com/us/open-source-email-solution) à partir du site web de Proofpoint, ou via un gestionnaire de paquets pour la plupart des distributions Linux.

Les instructions disponibles dans cette section vous expliquent comment configurer Sendmail pour envoyer un e-mail via Amazon SES. Cette procédure a été testée sur un serveur Ubuntu 18.04.2 LTS.

**Note**  
Sendmail est une application tierce qui n'est ni développée ni prise en charge par Amazon Web Services. Les procédures décrites dans cette section sont fournies à titre informatif seulement et peuvent être modifiées sans préavis.

## Conditions préalables
<a name="send-email-sendmail-prerequisites"></a>

Avant de commencer la procédure décrite dans cette section, vous devez effectuer les étapes suivantes :
+ Installez le paquet Sendmail sur votre serveur. 
**Note**  
Selon la distribution du système d'exploitation que vous utilisez, vous devrez peut-être également installer les paquets suivants : `sendmail-cf`, `m4` et `cyrus-sasl-plain`.
+ Validez une identité à utiliser pour votre adresse d'expédition. Pour plus d'informations, consultez [Création d'une identité d'adresse e-mail](creating-identities.md#verify-email-addresses-procedure).

  Si votre compte se trouve dans l'environnement de test (sandbox) Amazon SES, vous devez également valider les adresses auxquelles vous envoyez des e-mails. Pour plus d'informations, consultez [Demande d'accès à la production (sortie du sandbox d'Amazon SES)](request-production-access.md).

Si vous utilisez Amazon SES pour envoyer des e-mails à partir d'une instance Amazon EC2, vous devez également effectuer les étapes suivantes :
+ Vous devrez peut-être attribuer une adresse IP élastique à votre instance Amazon EC2 pour que les services de messagerie entrante acceptent votre e-mail. Pour plus d'informations, consultez les [adresses IP élastiques Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) dans le guide de l'utilisateur *Amazon EC2*.
+ Amazon Elastic Compute Cloud (Amazon EC2) limite par défaut le trafic des e-mails sur le port 25. Pour éviter les délais d'expiration lors de l'envoi d'e-mails via le point de terminaison SMTP à partir d'Amazon EC2, vous pouvez demander la suppression de ces restrictions. Pour plus d'informations, consultez [Comment supprimer la restriction sur le port 25 de mon instance ou AWS Lambda fonction Amazon EC2](https://aws.amazon.com/premiumsupport/knowledge-center/ec2-port-25-throttle/) ? dans le AWS Knowledge Center.

  Vous pouvez également modifier la procédure de cette section pour utiliser le port 587 plutôt que le port 25.

## Configuration de Sendmail
<a name="send-email-sendmail-procedure"></a>

Effectuez les étapes décrites dans cette section pour configurer Sendmail de façon à envoyer des e-mails à l'aide d'Amazon SES.

**Important**  
La procédure décrite dans cette section part du principe que vous souhaitez utiliser Amazon SES dans l'ouest des États-Unis (Oregon) Région AWS. Si vous voulez utiliser une autre région, remplacez toutes les instances *email-smtp.us-west-2.amazonaws.com* dans ces instructions par le point de terminaison SMTP de la région souhaitée. Pour obtenir la liste des points de terminaison SMTP URLs pour Régions AWS lesquels Amazon SES est disponible, consultez [Amazon Simple Email Service (Amazon SES](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region)) dans le. *Références générales AWS*

**Pour configurer Sendmail**

1. Dans un éditeur de fichier, ouvrez le fichier `/etc/mail/authinfo`. Si le fichier n'existe pas, créez-le.

   Ajoutez la ligne suivante à*/etc/mail/authinfo*:

   ```
   AuthInfo:email-smtp.us-west-2.amazonaws.com "U:root" "I:smtpUsername" "P:smtpPassword" "M:PLAIN"
   ```

   Dans l’exemple précédent, apportez les modifications suivantes :
   + *email-smtp.us-west-2.amazonaws.com*Remplacez-le par le point de terminaison SMTP Amazon SES que vous souhaitez utiliser.
   + *smtpUsername*Remplacez-le par votre nom d'utilisateur SMTP Amazon SES.
   + *smtpPassword*Remplacez-le par votre mot de passe SMTP Amazon SES.
**Note**  
Vos identifiants de connexion SMTP sont différents de votre identifiant de clé d' AWS accès et de votre clé d'accès secrète. Pour en savoir plus sur l'obtention de vos informations d'identification de connexion SMTP, consultez [Obtention des informations d'identification SMTP Amazon SES](smtp-credentials.md).

   Lorsque vous avez terminé, enregistrez `authinfo`.

1. En ligne de commande, entrez la commande suivante pour générer le fichier `/etc/mail/authinfo.db` :

   ```
   sudo sh -c 'makemap hash /etc/mail/authinfo.db < /etc/mail/authinfo'
   ```

1. En ligne de commande, entrez la commande suivante pour ajouter la prise en charge des relais vers le point de terminaison SMTP Amazon SES.

   ```
   sudo sh -c 'echo "Connect:email-smtp.us-west-2.amazonaws.com RELAY" >> /etc/mail/access'
   ```

   Dans la commande précédente, remplacez *email-smtp.us-west-2.amazonaws.com* par l'adresse du point de terminaison SMTP Amazon SES que vous souhaitez utiliser.

1. Sur la ligne de commande, tapez la commande suivante pour régénérer*/etc/mail/access.db* :

   ```
   sudo sh -c 'makemap hash /etc/mail/access.db < /etc/mail/access'
   ```

1. En ligne de commande, entrez la commande suivante pour créer des sauvegardes des fichiers `sendmail.cf` et `sendmail.mc` :

   ```
   sudo sh -c 'cp /etc/mail/sendmail.cf /etc/mail/sendmail_cf.backup && cp /etc/mail/sendmail.mc /etc/mail/sendmail_mc.backup'
   ```

1. Ajoutez les lignes suivantes au fichier*/etc/mail/sendmail.mc* avant toute `MAILER()` définition.

   ```
   define(`SMART_HOST', `email-smtp.us-west-2.amazonaws.com')dnl
   define(`RELAY_MAILER_ARGS', `TCP $h 25')dnl
   define(`confAUTH_MECHANISMS', `LOGIN PLAIN')dnl
   FEATURE(`authinfo', `hash -o /etc/mail/authinfo.db')dnl
   MASQUERADE_AS(`example.com')dnl
   FEATURE(masquerade_envelope)dnl
   FEATURE(masquerade_entire_domain)dnl
   ```

   Dans le texte précédent, procédez comme suit :
   + *email-smtp.us-west-2.amazonaws.com*Remplacez-le par le point de terminaison SMTP Amazon SES que vous souhaitez utiliser.
   + *example.com*Remplacez-le par le domaine que vous souhaitez utiliser pour envoyer des e-mails.

   Lorsque vous avez terminé, enregistrez le fichier.
**Note**  
Amazon EC2 limite les communications du port 25 par défaut. Si vous utilisez Sendmail pour envoyer des e-mails à partir d'une instance Amazon EC2, vous devez remplir le [formulaire de demande de suppression des limites d'envoi d'e-mail](https://aws-portal.amazon.com/gp/aws/html-forms-controller/contactus/ec2-email-limit-rdns-request).

1. En ligne de commande, tapez la commande suivante pour rendre *sendmail.cf* accessible en écriture :

   ```
   sudo chmod 666 /etc/mail/sendmail.cf
   ```

1. En ligne de commande, tapez la commande suivante pour regénérer *sendmail.cf* :

   ```
   sudo sh -c 'm4 /etc/mail/sendmail.mc > /etc/mail/sendmail.cf'
   ```
**Note**  
Si vous rencontrez des erreurs telles que « Commande introuvable » et « Fichier ou répertoire introuvable », assurez-vous que les paquets `sendmail-cf` et `m4` sont installés sur votre système.

1. En ligne de commande, tapez la commande suivante pour réinitialiser les autorisations de *sendmail.cf* de façon qu'il soit accessible en lecture seule :

   ```
   sudo chmod 644 /etc/mail/sendmail.cf
   ```

1. En ligne de commande, tapez la commande suivante pour redémarrer Sendmail :

   ```
   sudo /etc/init.d/sendmail restart
   ```

   *Selon la version de Linux ou de Sendmail, si ce qui précède ne fonctionne pas, essayez ce qui suit :*

   ```
   sudo su service sendmail restart
   ```

1. Effectuez les étapes suivantes pour envoyer un e-mail de test :

   1. En ligne de commande, entrez la commande suivante.

      ```
      /usr/sbin/sendmail -vf sender@example.com recipient@example.com
      ```

      Remplacez *sender@example.com* par votre adresse e-mail From. Remplacez *recipient@example.com* par l'adresse de destination. Une fois que vous avez terminé, appuyez sur Enter.

   1. Entrez le contenu de message suivant. Appuyez sur Enter à la fin de chaque ligne.

      ```
      From: sender@example.com
      To: recipient@example.com
      Subject: Amazon SES test email
      
      This is a test message sent from Amazon SES using Sendmail.
      ```

      Lorsque vous avez fini d'entrer le contenu de l'e-mail, appuyez sur Ctrl\$1D pour l'envoyer.

1. Vérifiez le client du destinataire de l'e-mail pour l'e-mail. Si vous ne trouvez pas l'e-mail, vérifiez le dossier des courriers indésirables. S'il ne s'y trouve pas non plus, vérifiez le journal Sendmail sur votre serveur de messagerie. Le journal se trouve souvent dans*/var/log/mail.log* ou*/var/log/maillog*. 

# Intégration d'Amazon SES au serveur SMTP IIS de Microsoft Windows Server
<a name="send-email-windows-server"></a>

Vous pouvez configurer le serveur SMTP IIS de Microsoft Windows Server de façon à envoyer des e-mails via Amazon SES. Ces instructions ont été rédigées à l'aide de Microsoft Windows Server 2022 sur une instance Amazon EC2. Vous pouvez utiliser la même configuration sur Microsoft Windows Server 2016.

**Note**  
Windows Server est une application tierce qui n'est ni développée ni prise en charge par Amazon Web Services. Les procédures décrites dans cette section sont fournies à titre informatif seulement et peuvent être modifiées sans préavis.

**Pour intégrer le serveur SMTP IIS de Microsoft Windows Server à Amazon SES**

1. Tout d'abord, configurez Microsoft Windows Server 2022 en suivant les instructions suivantes.

   1. Depuis la [console de gestion Amazon EC2](https://console.aws.amazon.com/ec2/home), lancez une nouvelle instance Amazon EC2 Microsoft Windows Server 2022 Base.

   1. Connectez-vous à l'instance et connectez-vous à l'aide de l'option Bureau à distance en suivant les instructions de [Démarrer avec les instances Windows Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2Win_GetStarted.html).

   1. Lancez le tableau de bord du gestionnaire de serveur.

   1. Installez le rôle **Serveur Web**. Assurez-vous d'inclure les **outils de compatibilité de gestion IIS 10** (une option sous la case à cocher **du serveur Web**).

   1. Installez la fonctionnalité **Serveur SMTP**.

1. Ensuite, configurez le service IIS SMTP en suivant les instructions ci-dessous.

   1. Revenez au tableau de bord du gestionnaire de serveur.

   1. Dans le menu **Outils**, choisissez **Internet Information Services (IIS) 10.0 Manager**.

   1. Cliquez avec le bouton droit de la souris sur **Serveur virtuel SMTP n° 1**, puis sélectionnez **Propriétés**.

   1. Sous l'onglet **Accès**, sous **Restrictions de relais**, choisissez **Relais**.

   1. Dans la boîte de dialogue **Restrictions de relais**, choisissez **Ajouter**.

   1. Sous **Ordinateur unique**, entrez **127.0.0.1** pour l'adresse IP. Vous disposez maintenant d'un accès à ce serveur pour transmettre des e-mails à Amazon SES via le service SMTP IIS.

      Dans cette procédure, nous supposons que vos e-mails sont générés sur ce serveur. Si l'application qui génère l'e-mail est exécutée sur un serveur distinct, vous devez accorder l'accès de relais pour ce serveur dans SMTP IIS.
**Note**  
Pour étendre le relais SMTP à des sous-réseaux privés, pour **Relay Restriction (Restriction de relais)**, utilisez **Single Computer (Ordinateur unique)** 127.0.0.1 et **Group of Computers (Groupe d'ordinateurs)** 172.1.1.0 - 255.255.255.0, dans la section masque réseau (netmask). Pour **Connection (Connexion)**, utilisez **Ordinateur unique** 127.0.0.1 et **Group of Computers (Groupe d'ordinateurs)** 172.1.1.0 - 255.255.255.0, dans la section masque réseau (netmask).

1. Enfin, configurez le serveur de façon à envoyer des e-mails via Amazon SES en suivant les instructions ci-dessous.

   1. Revenez à la boîte de dialogue **(SMTP Virtual Server \$11 Properties) Propriétés du serveur virtuel SMTP n° 1**, puis choisissez l'onglet **Delivery (Remise)**.

   1. Sous l'onglet **Delivery (Remise)**, choisissez **Outbound Security (Sécurité sortante)**.

   1. Sélectionnez **Basic Authentication** (Authentification de base), puis saisissez vos informations d'identification SMTP Amazon SES. Vous pouvez obtenir ces informations d'identification à partir de la console Amazon SES à l'aide de la procédure [Obtention des informations d'identification SMTP Amazon SES](smtp-credentials.md).
**Important**  
Vos informations d'identification SMTP ne sont pas identiques à votre identifiant de clé AWS d'accès et à votre clé d'accès secrète. N'essayez pas d'utiliser vos AWS informations d'identification pour vous authentifier auprès du point de terminaison SMTP. Pour en savoir plus sur les informations d'identification, consultez [Types d'informations d'identification Amazon SES](send-email-concepts-credentials.md).

   1. Assurez-vous que **TLS encryption (Chiffrement TLS)** est sélectionné.

   1. Revenez à l'onglet **Delivery (Remise)**.

   1. Choisissez **Outbound Connections (Connexions sortantes)**.

   1. Dans la boîte de dialogue **Outbound Connections (Connexions sortantes)**, assurez-vous que le port est 25 ou 587. 

   1. Choisir **Advanced** (Avancé).

   1. Pour le nom **Smart host (Hôte intelligent)**, entrez le point de terminaison Amazon SES que vous utiliserez (par exemple, *email-smtp.us-west-2.amazonaws.com*). Pour obtenir la liste des terminaux URLs sur Régions AWS lesquels Amazon SES est disponible, consultez [Amazon Simple Email Service (Amazon SES)](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region) dans le *Références générales AWS*.

   1. Revenez au tableau de bord du gestionnaire de serveur.

   1. Sur le tableau de bord du gestionnaire de serveur, cliquez avec le bouton droit de la souris sur **Serveur virtuel SMTP n° 1**, puis redémarrez le service de façon à récupérer la nouvelle configuration.

   1. Envoyez un e-mail via ce serveur. Vous pouvez examiner les en-têtes de message afin de confirmer que celui-ci a été remis via Amazon SES.

# Test de votre connexion à l'interface SMTP Amazon SES à l'aide de la ligne de commande
<a name="send-email-smtp-client-command-line"></a>

Vous pouvez utilisez les méthodes décrites dans cette section depuis la ligne de commande pour tester votre connexion au point de terminaison SMTP Amazon SES, valider vos informations d'identification SMTP et résoudre les problèmes de connexion. Ces procédures utilisent des outils et des bibliothèques qui sont inclus avec la plupart des systèmes d'exploitation courants.

Pour plus d'informations sur la résolution des problèmes de connexion SMTP, veuillez consulter [Problèmes SMTP Amazon SES](troubleshoot-smtp.md).

## Conditions préalables
<a name="send-email-smtp-client-command-line-prereqs"></a>

Lorsque vous vous connectez à l'interface SMTP Amazon SES, vous devez fournir un ensemble d'informations d'identification SMTP. Ces informations d'identification SMTP sont différentes de vos informations d' AWS identification standard. Les deux types d'informations d'identification ne sont pas interchangeables. Pour en savoir plus sur l'obtention de vos informations d'identification SMTP, consultez [Obtention des informations d'identification SMTP Amazon SES](smtp-credentials.md).

## Test de votre connexion à l'interface SMTP Amazon SES
<a name="send-email-smtp-client-command-line-testing"></a>

Vous pouvez utiliser la ligne de commande pour tester votre connexion à l'interface SMTP Amazon SES sans vous authentifier ni envoyer de messages. Cette procédure est utile pour résoudre les problèmes de connectivité de base. Si votre connexion de test échoue, consultez [Problèmes SMTP](troubleshoot-smtp.md).

Cette section inclut des procédures pour tester votre connexion à l'aide d'OpenSSL (qui est inclus dans la plupart des distributions Linux, macOS et Unix, et est également disponible pour Windows) et de `Test-NetConnection` l'applet de commande (incluse PowerShell dans les versions les plus récentes de Windows).

------
#### [ Linux, macOS, or Unix ]

Il existe deux façons de se connecter à l'interface SMTP Amazon SES avec OpenSSL : à l'aide du protocole SSL explicite sur le port 587 ou à l'aide du protocole SSL implicite sur le port 465.

**Pour vous connecter à l'interface SMTP à l'aide du protocole SSL explicite**
+ Sur la ligne de commande, tapez la commande suivante afin de vous connecter au serveur SMTP Amazon SES :

  ```
  openssl s_client -crlf -quiet -starttls smtp -connect email-smtp.us-west-2.amazonaws.com:587
  ```

  Dans la commande précédente, remplacez *email-smtp.us-west-2.amazonaws.com* par l'URL du point de terminaison SMTP Amazon SES pour votre AWS région. Pour de plus amples informations, veuillez consulter [Régions et Amazon SES](regions.md).

  Si la connexion est réussie, vous obtenez une sortie similaire à ce qui suit :

  ```
  depth=2 C = US, O = Amazon, CN = Amazon Root CA 1
  verify return:1
  depth=1 C = US, O = Amazon, OU = Server CA 1B, CN = Amazon
  verify return:1
  depth=0 CN = email-smtp.us-west-2.amazonaws.com
  verify return:1
  250 Ok
  ```

  La connexion se ferme automatiquement au bout de 10 secondes d'inactivité.

Vous pouvez également utiliser le protocole SSL implicite pour vous connecter à l'interface SMTP via le port 465.

**Pour vous connecter à l'interface SMTP à l'aide du protocole SSL implicite**
+ Sur la ligne de commande, tapez la commande suivante afin de vous connecter au serveur SMTP Amazon SES :

  ```
  openssl s_client -crlf -quiet -connect email-smtp.us-west-2.amazonaws.com:465
  ```

  Dans la commande précédente, remplacez *email-smtp.us-west-2.amazonaws.com* par l'URL du point de terminaison SMTP Amazon SES pour votre AWS région. Pour de plus amples informations, veuillez consulter [Régions et Amazon SES](regions.md).

  Si la connexion est réussie, vous obtenez une sortie similaire à ce qui suit :

  ```
  depth=2 C = US, O = Amazon, CN = Amazon Root CA 1
  verify return:1
  depth=1 C = US, O = Amazon, OU = Server CA 1B, CN = Amazon
  verify return:1
  depth=0 CN = email-smtp.us-west-2.amazonaws.com
  verify return:1
  220 email-smtp.amazonaws.com ESMTP SimpleEmailService-d-VCSHDP1YZ A1b2C3d4E5f6G7h8I9j0
  ```

  La connexion se ferme automatiquement au bout de 10 secondes d'inactivité.

------
#### [ PowerShell ]

Vous pouvez utiliser l'NetConnectionapplet [de commande Test-in](https://docs.microsoft.com/en-us/powershell/module/nettcpip/test-netconnection) PowerShell pour vous connecter au serveur SMTP Amazon SES.

**Note**  
L'applet de commande `Test-NetConnection` peut déterminer si votre ordinateur peut se connecter au point de terminaison SMTP Amazon SES. Toutefois, il ne teste pas si votre ordinateur peut établir une connexion SSL implicite ou explicite au point de terminaison SMTP. Pour tester une connexion SSL, vous pouvez installer OpenSSL pour Windows pour envoyer un e-mail de test.

**Pour vous connecter à l'interface SMTP à l'aide de l'applet de commande `Test-NetConnection`**
+ Dans PowerShell, entrez la commande suivante pour vous connecter au serveur SMTP Amazon SES :

  ```
  Test-NetConnection -Port 587 -ComputerName email-smtp.us-west-2.amazonaws.com
  ```

  Dans la commande précédente, remplacez *email-smtp.us-west-2.amazonaws.com* par l'URL du point de terminaison SMTP Amazon SES pour votre AWS région, puis *587* par le numéro de port. Pour en savoir plus sur les points de terminaison régionaux dans Amazon SES, consultez [Régions et Amazon SES](regions.md).

  Si la connexion aboutit, vous voyez une sortie similaire à l'exemple suivant :

  ```
  ComputerName     : email-smtp.us-west-2.amazonaws.com
  RemoteAddress    : 198.51.100.126
  RemotePort       : 587
  InterfaceAlias   : Ethernet
  SourceAddress    : 203.0.113.46
  TcpTestSucceeded : True
  ```

------

## Utilisation de la ligne de commande pour envoyer un e-mail via l'interface SMTP Amazon SES
<a name="send-email-using-openssl"></a>

Vous pouvez également utiliser la ligne de commande pour envoyer des messages à l'aide de l'interface SMTP Amazon SES. Cette procédure est utile pour tester les informations d'identification SMTP et tester la capacité de destinataires spécifiques à recevoir des messages que vous envoyez via Amazon SES.

------
#### [ Linux, macOS, or Unix ]

Lorsqu'un expéditeur d'e-mails se connecte à un serveur SMTP, le client émet un ensemble standard de demandes et le serveur répond à chaque demande avec une réponse standard. Cette série de demandes et de réponses est nommée *conversation SMTP*. Lorsque vous vous connectez au serveur SMTP Amazon SES à l'aide d'OpenSSL, le serveur attend une conversation SMTP.

Lorsque vous utilisez OpenSSL pour vous connecter à l'interface SMTP, vous devez encoder vos informations d'identification SMTP à l'aide de l'encodage base64. Cette section inclut les procédures d'encodage de vos informations d'identification à l'aide de base64.

**Pour envoyer un e-mail à partir de la ligne de commande à l'aide de l'interface SMTP**

1. Entrez ce qui suit sur la ligne de commande et remplacez-le *email-smtp.us-west-2.amazonaws.com* par l'URL du point de terminaison SMTP Amazon SES correspondant à votre Région AWS. Pour plus d'informations, consultez[Régions et Amazon SES](regions.md). :

   ```
    1. #!/bin/bash
    2. 
    3. # Prompt user to provide following information
    4. read -p "Configuration set: " CONFIGSET
    5. read -p "Enter SMTP username: " SMTPUsername
    6. read -p "Enter SMTP password: " SMTPPassword
    7. read -p "Sender email address: " MAILFROM
    8. read -p "Receiver email address: " RCPT
    9. read -p "Email subject: " SUBJECT
   10. read -p "Message to send: " DATA
   11. 
   12. echo
   13. 
   14. # Encode SMTP username and password using base64
   15. EncodedSMTPUsername=$(echo -n "$SMTPUsername" | openssl enc -base64)
   16. EncodedSMTPPassword=$(echo -n "$SMTPPassword" | openssl enc -base64)
   17. 
   18. # Construct the email
   19. Email="EHLO example.com
   20. AUTH LOGIN
   21. $EncodedSMTPUsername
   22. $EncodedSMTPPassword
   23. MAIL FROM: $MAILFROM
   24. RCPT TO: $RCPT
   25. DATA
   26. X-SES-CONFIGURATION-SET: $CONFIGSET
   27. From: $MAILFROM
   28. To: $RCPT
   29. Subject: $SUBJECT
   30. 
   31. $DATA
   32. .
   33. QUIT"
   34. 
   35. echo "$Email" | openssl s_client -crlf -quiet -starttls smtp -connect email-smtp.us-west-2.amazonaws.com:587
   ```

1. À l'invite correspondant à chaque variable, entrez vos valeurs.

1. 
   + Pour envoyer en utilisant le protocole SSL implicite sur le port 465, utilisez :

     ```
     openssl s_client -crlf -quiet -connect email-smtp.us-west-2.amazonaws.com:465
     ```

   Si le message est accepté par Amazon SES, vous voyez une sortie similaire à l'exemple suivant :

   ```
   250 Ok 01010160d7de98d8-21e57d9a-JZho-416c-bbe1-8ebaAexample-000000
   ```

   La chaîne de nombres et de texte qui suit `250 Ok` est l'ID de message de l'e-mail.
**Note**  
La connexion se ferme automatiquement au bout de 10 secondes d'inactivité.

------
#### [ PowerShell ]

Vous pouvez utiliser le [Net.Mail. SmtpClient](https://docs.microsoft.com/en-us/dotnet/api/system.net.mail.smtpclient?view=netframework-4.8)classe pour envoyer un e-mail en utilisant un protocole SSL explicite sur le port 587.

**Note**  
La classe `Net.Mail.SmtpClient` est officiellement obsolète, et Microsoft vous recommande d'utiliser des bibliothèques tierces. Ce code est destiné uniquement à des fins de test et ne doit pas être utilisé pour les charges de travail de production.

**Pour envoyer un e-mail à PowerShell l'aide d'un protocole SSL explicite**

1. Dans un éditeur de texte, créez un fichier. Collez le code suivant dans le fichier :

   ```
   function SendEmail($Server, $Port, $Sender, $Recipient, $Subject, $Body) {
       $Credentials = [Net.NetworkCredential](Get-Credential)
   
       $SMTPClient = New-Object Net.Mail.SmtpClient($Server, $Port)
       $SMTPClient.EnableSsl = $true
       $SMTPClient.Credentials = New-Object System.Net.NetworkCredential($Credentials.Username, $Credentials.Password);
   
       try {
           Write-Output "Sending message..."
           $SMTPClient.Send($Sender, $Recipient, $Subject, $Body)
           Write-Output "Message successfully sent to $($Recipient)"
       } catch [System.Exception] {
           Write-Output "An error occurred:"
           Write-Error $_
       }
   }
   
   function SendTestEmail(){
       $Server = "email-smtp.us-west-2.amazonaws.com"
       $Port = 587
   
       $Subject = "Test email sent from Amazon SES"
       $Body = "This message was sent from Amazon SES using PowerShell (explicit SSL, port 587)."
   
       $Sender = "sender@example.com"
       $Recipient = "recipient@example.com"
   
       SendEmail $Server $Port $Sender $Recipient $Subject $Body
   }
   
   SendTestEmail
   ```

   Lorsque vous avez terminé, enregistrez le fichier sous `SendEmail.ps1`.

1. Modifiez le fichier créé lors de l'étape précédente comme suit :
   + Remplacez *sender@example.com* par l'adresse e-mail à partir de laquelle vous souhaitez envoyer le message.
   + Remplacez *recipient@example.com* par l'adresse e-mail à laquelle vous souhaitez envoyer le message.
   + *email-smtp.us-west-2.amazonaws.com*Remplacez-le par l'URL du point de terminaison SMTP Amazon SES de votre AWS région. Pour de plus amples informations, veuillez consulter [Régions et Amazon SES](regions.md).

1. Dans PowerShell, entrez la commande suivante :

   ```
   .\path\to\SendEmail.ps1
   ```

   Dans la commande précédente, remplacez *path\$1to\$1SendEmail.ps1* par le chemin du fichier que vous avez créé à l'étape 1.

1. Lorsque vous y êtes invité, entrez votre nom d'utilisateur et votre mot de passe SMTP.

Vous pouvez également utiliser le [System.Web.Mail. SmtpMail](https://docs.microsoft.com/en-us/dotnet/api/system.web.mail.smtpmail?view=netframework-4.8)classe pour envoyer un e-mail en utilisant le protocole SSL implicite sur le port 465.

**Note**  
La classe `System.Web.Mail.SmtpMail` est officiellement obsolète, et Microsoft vous recommande d'utiliser des bibliothèques tierces. Ce code est destiné uniquement à des fins de test et ne doit pas être utilisé pour les charges de travail de production.

**Pour envoyer un e-mail à PowerShell l'aide du protocole SSL implicite**

1. Dans un éditeur de texte, créez un fichier. Collez le code suivant dans le fichier :

   ```
   [System.Reflection.Assembly]::LoadWithPartialName("System.Web") > $null
   
   function SendEmail($Server, $Port, $Sender, $Recipient, $Subject, $Body) {
       $Credentials = [Net.NetworkCredential](Get-Credential)
   
       $mail = New-Object System.Web.Mail.MailMessage
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpserver", $Server)
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpserverport", $Port)
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpusessl", $true)
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendusername", $Credentials.UserName)
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendpassword", $Credentials.Password)
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpconnectiontimeout", $timeout / 1000)
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendusing", 2)
       $mail.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpauthenticate", 1)
   
       $mail.From = $Sender
       $mail.To = $Recipient
       $mail.Subject = $Subject
       $mail.Body = $Body
   
       try {
           Write-Output "Sending message..."
           [System.Web.Mail.SmtpMail]::Send($mail)
           Write-Output "Message successfully sent to $($Recipient)"
       } catch [System.Exception] {
           Write-Output "An error occurred:"
           Write-Error $_
       }
   }
   
   function SendTestEmail(){
       $Server = "email-smtp.us-west-2.amazonaws.com"
       $Port = 465
       
       $Subject = "Test email sent from Amazon SES"
       $Body = "This message was sent from Amazon SES using PowerShell (implicit SSL, port 465)."
   
       $Sender = "sender@example.com"
       $Recipient = "recipient@example.com"
   
       SendEmail $Server $Port $Sender $Recipient $Subject $Body
   }
   
   SendTestEmail
   ```

   Lorsque vous avez terminé, enregistrez le fichier sous `SendEmail.ps1`.

1. Modifiez le fichier créé lors de l'étape précédente comme suit :
   + Remplacez *sender@example.com* par l'adresse e-mail à partir de laquelle vous souhaitez envoyer le message.
   + Remplacez *recipient@example.com* par l'adresse e-mail à laquelle vous souhaitez envoyer le message.
   + *email-smtp.us-west-2.amazonaws.com*Remplacez-le par l'URL du point de terminaison SMTP Amazon SES de votre AWS région. Pour de plus amples informations, veuillez consulter [Régions et Amazon SES](regions.md).

1. Dans PowerShell, entrez la commande suivante :

   ```
   .\path\to\SendEmail.ps1
   ```

   Dans la commande précédente, remplacez *path\$1to\$1SendEmail.ps1* par le chemin du fichier que vous avez créé à l'étape 1.

1. Lorsque vous y êtes invité, entrez votre nom d'utilisateur et votre mot de passe SMTP.

------

# Utilisation de l'API Amazon SES pour envoyer un e-mail
<a name="send-email-api"></a>

Pour envoyer un e-mail de production via Amazon SES, vous pouvez utiliser l'interface protocole SMTP (Simple Mail Transfer Protocol) ou l'API Amazon SES. Pour en savoir plus sur l'interface SMTP, consultez [Utilisation de l'interface SMTP d'Amazon SES pour envoyer des e-mails](send-email-smtp.md). Cette section décrit l'envoi d'e-mails à l'aide de l'API. 

Lorsque vous envoyez un e-mail à l'aide de l'API Amazon SES, vous spécifiez le contenu du message et Amazon SES compose un e-mail MIME pour vous. Vous pouvez également assembler l'e-mail vous-même afin d'avoir un contrôle total sur le contenu du message. Pour de plus amples informations sur l'utilisation de l'API, veuillez consulter la [Référence d'API Amazon Simple Email Service](https://docs.aws.amazon.com/ses/latest/APIReference/). Pour obtenir la liste des points de terminaison URLs pour Régions AWS lesquels Amazon SES est disponible, consultez la section [Points de terminaison et quotas Amazon Simple Email Service](https://docs.aws.amazon.com/general/latest/gr/ses.html) dans le *Références générales AWS*.

Vous pouvez appeler l'API des manières suivantes :
+ **Effectuer des demandes HTTPS directes –** Il s'agit de la méthode la plus avancée, car vous devez manuellement gérer l'authentification et la signature de vos demandes, ainsi que la création des demandes. Pour en savoir plus sur l'API Amazon SES, consultez la page [Welcome (Bienvenue)](https://docs.aws.amazon.com/ses/latest/APIReference-V2/Welcome.html) dans *API v2 Reference (référence API v2)*.
+ **Utilisez un AWS SDK :**AWS SDKs simplifiez l'accès APIs à plusieurs AWS services, notamment Amazon SES. Lorsque vous utilisez un kit SDK, il s'occupe de l'authentification, de la signature des demandes, de la logique de nouvelle tentative, de la gestion des erreurs et d'autres fonctions de bas niveau, afin de vous permettre de vous concentrer sur le développement des applications qui raviront vos clients.
+ **Utiliser une interface de ligne de commande – ** L'[AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) est l'outil de ligne de commande pour Amazon SES. Nous proposons également les [AWS outils PowerShell pour](https://aws.amazon.com/powershell/) ceux qui écrivent des scripts dans l' PowerShellenvironnement.

Que vous accédiez à l'API Amazon SES directement ou indirectement par le biais d'un AWS SDK, AWS Command Line Interface ou des AWS outils pour PowerShell, l'API Amazon SES vous permet d'envoyer un e-mail de deux manières différentes, en fonction du degré de contrôle que vous souhaitez avoir sur la composition du message électronique :
+ **Mis en forme – **Amazon SES compose et envoie un e-mail correctement mis en forme. Vous devez uniquement indiquer les adresses d'expédition et de destination, un objet et le corps du message. Amazon SES se charge de tout le reste. Pour plus d'informations, consultez [Envoi d'e-mails formatés à l'aide de l'API Amazon SES](send-email-formatted.md).
+ **Brut – **Vous composez et envoyez manuellement un e-mail, en spécifiant vos propres en-têtes d'e-mail et types MIME. Si vous avez l'habitude de mettre en forme vos e-mails, l'interface brute vous donne plus de contrôle sur la composition de votre message. Pour plus d'informations, consultez [Envoi d'e-mails bruts à l'aide de l'API Amazon SES v2](send-email-raw.md).

**Topics**
+ [

# Envoi d'e-mails formatés à l'aide de l'API Amazon SES
](send-email-formatted.md)
+ [

# Envoi d'e-mails bruts à l'aide de l'API Amazon SES v2
](send-email-raw.md)
+ [

# Utiliser des modèles pour envoyer des e-mails personnalisés à l'aide de l'API Amazon SES
](send-personalized-email-api.md)
+ [

# Envoi d'e-mails via Amazon SES à l'aide d'un AWS SDK
](send-an-email-using-sdk-programmatically.md)
+ [

# Encodages de contenu pris en charge par Amazon SES
](content-encodings.md)

# Envoi d'e-mails formatés à l'aide de l'API Amazon SES
<a name="send-email-formatted"></a>

Vous pouvez envoyer un e-mail formaté en utilisant AWS Management Console ou en appelant l'API Amazon SES directement via une application, ou indirectement via un AWS SDK, le AWS Command Line Interface, ou le. AWS Tools for Windows PowerShell

L'API Amazon SES fournit l'action `SendEmail`, qui vous permet de créer et d'envoyer un e-mail formaté. `SendEmail` nécessite une adresse From :, une adresse To :, un objet de message et un corps de message-texte, HTML ou les deux). Pour plus d'informations, consultez [SendEmail](https://docs.aws.amazon.com/ses/latest/APIReference/API_SendEmail.html)(Référence d'API) ou [SendEmail](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendEmail.html)(Référence d'API v2).

**Note**  
La chaîne de l'adresse e-mail doit être au format ASCII 7 bits. Si vous souhaitez effectuer un envoi vers ou à partir d'adresses e-mail qui contiennent des caractères Unicode dans la partie domaine de l'adresse, vous devez encoder le domaine à l'aide de Punycode. Pour en savoir plus, consultez [RFC 3492](https://tools.ietf.org/html/rfc3492).

Pour obtenir des exemples sur la façon de composer un message formaté à l'aide de différents langages de programmation, consultez [Exemples de code](send-an-email-using-sdk-programmatically.md#send-an-email-using-sdk-programmatically-examples).

Pour accéder à des astuces sur la manière d'augmenter la vitesse d'envoi des e-mails lorsque vous effectuez plusieurs appels à `SendEmail`, consultez [Accroissement du débit avec Amazon SES](troubleshoot-throughput-problems.md).

# Envoi d'e-mails bruts à l'aide de l'API Amazon SES v2
<a name="send-email-raw"></a>

Vous pouvez utiliser l'`SendEmail`opération Amazon SES API v2 avec le type de contenu spécifié `raw` pour envoyer des messages personnalisés à vos destinataires en utilisant le format d'e-mail brut.

## À propos des champs d'en-tête d'e-mail
<a name="send-email-raw-headers"></a>

Le protocole SMTP (SMTP) spécifie la façon dont les e-mails doivent être envoyés en définissant l'enveloppe et certains paramètres des e-mails, mais il ne s'occupe pas du contenu du message. En revanche, le format IMF ([RFC 5322](https://www.ietf.org/rfc/rfc5322.txt)) définit la manière dont le message sera composé.

Avec la spécification IMF, chaque e-mail est composé d'un en-tête et d'un corps. L'en-tête est composé des métadonnées du message et le corps contient le message lui-même. Pour en savoir plus sur les en-têtes et corps d'e-mail, consultez [Format d'e-mail dans Amazon SES](send-email-concepts-email-format.md).

## Utilisation de la construction de messages MIME de courrier électronique bruts
<a name="send-email-raw-mime"></a>

Le protocole SMTP a été initialement conçu pour envoyer des messages électroniques qui ne comportent que des caractères ASCII 7 bits. Cette spécification rend SMTP insuffisant pour les codages de texte non ASCII (par exemple, en Unicode), les contenus binaires ou les pièces jointes. Le standard MIME (Multipurpose Internet Mail Extensions standard) a été développé pour permettre d'envoyer beaucoup d'autres types de contenus à l'aide de SMTP.

Le standard MIME fonctionne en divisant le corps du message en plusieurs parties, puis en indiquant ce qui doit être fait avec chaque partie. Par exemple, une partie du corps de l'e-mail peut être un texte brut, tandis qu'une autre sera en HTML. En outre, le standard MIME autorise les e-mails à contenir une ou plusieurs pièces jointes. Les destinataires des messages peuvent consulter les pièces jointes depuis leurs clients de messagerie ou ils peuvent enregistrer les pièces jointes.

L'en-tête du message et le contenu sont séparés par une ligne vide. Chaque partie de l'e-mail est séparée par une limite, une chaîne de caractères qui indique le début et la fin de chaque partie.

Le message en plusieurs parties de l'exemple suivant contient un texte et une partie HTML, et une pièce jointe. La pièce jointe doit être placée juste en dessous des [en-têtes de pièce jointe](#send-email-mime-encoding-files) et est le plus souvent encodée en `base64`, comme indiqué dans cet exemple.

```
 1. From: "Sender Name" <sender@example.com>
 2. To: recipient@example.com
 3. Subject: Customer service contact info
 4. Content-Type: multipart/mixed;
 5.     boundary="a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a"
 6. 
 7. --a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a
 8. Content-Type: multipart/alternative;
 9.     boundary="sub_a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a"
10. 
11. --sub_a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a
12. Content-Type: text/plain; charset=iso-8859-1
13. Content-Transfer-Encoding: quoted-printable
14. 
15. Please see the attached file for a list of customers to contact.
16. 
17. --sub_a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a
18. Content-Type: text/html; charset=iso-8859-1
19. Content-Transfer-Encoding: quoted-printable
20. 
21. <html>
22. <head></head>
23. <body>
24. <h1>Hello!</h1>
25. <p>Please see the attached file for a list of customers to contact.</p>
26. </body>
27. </html>
28. 
29. --sub_a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a--
30. 
31. --a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a
32. Content-Type: text/plain; name="customers.txt"
33. Content-Description: customers.txt
34. Content-Disposition: attachment;filename="customers.txt";
35.     creation-date="Sat, 05 Aug 2017 19:35:36 GMT";
36. Content-Transfer-Encoding: base64
37. 
38. SUQsRmlyc3ROYW1lLExhc3ROYW1lLENvdW50cnkKMzQ4LEpvaG4sU3RpbGVzLENhbmFkYQo5MjM4
39. OSxKaWUsTGl1LENoaW5hCjczNCxTaGlybGV5LFJvZHJpZ3VleixVbml0ZWQgU3RhdGVzCjI4OTMs
40. QW5heWEsSXllbmdhcixJbmRpYQ==
41. 
42. --a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a--
```

Le type de contenu pour le message est `multipart/mixed`, ce qui indique que le message est composé de nombreuses parties (dans cet exemple, un corps et une pièce jointe) et que le client destinataire doit gérer chaque partie séparément.

Une deuxième partie qui utilise le type de contenu `multipart/alternative` est imbriquée dans le corps. Ce type de contenu indique que chaque partie contient des versions alternatives du même contenu (dans ce cas, une version texte et une version HTML). Si le client de messagerie du destinataire peut afficher du contenu HTML, il affiche alors la version HTML du corps du message. Si le client de messagerie du destinataire ne peut pas afficher de contenu HTML, il affiche alors la version texte brut du corps du message.

Les deux versions du message contiendront également une pièce jointe (dans ce cas, un petit fichier texte qui contient des noms de client).

Lorsque vous imbriquez une partie MIME au sein d'une autre partie, comme dans cet exemple, la partie imbriquée doit utiliser un paramètre `boundary` distinct du paramètre `boundary` de la partie principale. Ces limites doivent être des chaînes de caractères uniques. Pour définir une limite entre des parties MIME, tapez deux tirets (--) suivis par la chaîne de limite. À la fin d'une partie MIME, placez deux tirets au début et à la fin de la chaîne de limite.

**Note**  
Un message ne peut pas comporter plus de 500 parties MIME.

### Encodage MIME
<a name="send-email-mime-encoding"></a>

Pour maintenir la compatibilité avec des systèmes plus anciens, Amazon SES respecte la restriction ASCII 7 bits de SMTP telle que définie dans [RFC 2821](https://tools.ietf.org/html/rfc2821). Si vous souhaitez envoyer du contenu qui contient des caractères non ASCII, vous devez encoder ces caractères dans un format qui utilise des caractères ASCII 7 bits.

#### Adresses e-mail
<a name="send-email-mime-encoding-addresses"></a>

La chaîne de l'adresse e-mail doit être au format ASCII 7 bits. Si vous souhaitez effectuer un envoi vers ou à partir d'adresses e-mail qui contiennent des caractères Unicode dans la partie domaine de l'adresse, vous devez encoder le domaine à l'aide de Punycode. La syntaxe Punycode n'est pas autorisée dans la partie locale de l'adresse e-mail (c'est-à-dire, la partie qui précède le signe @) ni dans le « nom d'expéditeur convivial ». Si vous souhaitez utiliser des caractères Unicode dans le nom « friendly from », vous devez encoder le nom « friendly from » en utilisant la syntaxe des mots codés MIME, comme décrit dans cette section. Pour en savoir plus sur Punycode, consultez [RFC 3492](http://tools.ietf.org/html/rfc3492).

**Note**  
Cette règle ne s'applique qu'aux adresses e-mail que vous spécifiez dans l'enveloppe de message, non dans les en-têtes de message. Lorsque vous utilisez l'`SendEmail`opération Amazon SES API v2, les adresses que vous spécifiez dans les `Destinations` paramètres `Source` et définissent respectivement l'expéditeur et les destinataires de l'enveloppe.

#### En-têtes d'e-mail
<a name="send-email-mime-encoding-headers"></a>

Pour encoder un message d'en-tête, utilisez la syntaxe encodée MIME. La syntaxe encodée MIME utilise le format suivant :

```
=?charset?encoding?encoded-text?=
```

La valeur de `encoding` peut être `Q` ou `B`. Si la valeur de codage est `Q`, la valeur `encoded-text` doit utiliser l'encodage Q. Si la valeur de codage est `B`, la valeur de `encoded-text` doit utiliser l'encodage base64.

Par exemple, si vous voulez utiliser la chaîne « Як ти поживаєш? » dans la ligne d'objet d'un e-mail, vous pouvez utiliser l'un des encodages suivants :
+ **Encodage Q**

  ```
  =?utf-8?Q?=D0=AF=D0=BA_=D1=82=D0=B8_=D0=BF=D0=BE=D0=B6=D0=B8=D0=B2=D0=B0=D1=94=D1=88=3F?=
  ```
+ **Encodage Base64**

  ```
  =?utf-8?B?0K/QuiDRgtC4INC/0L7QttC40LLQsNGU0Yg/?=
  ```

Pour en savoir plus sur l'encodage Q, consultez [RFC 2047](https://tools.ietf.org/html/rfc2047). Pour en savoir plus sur l'encodage base64, consultez [RFC 2045](https://tools.ietf.org/html/rfc2045).

#### Corps du message
<a name="send-email-mime-encoding-body"></a>

Pour encoder le corps d'un message, vous pouvez utiliser l'encodage des guillemets imprimables ou l'encodage base64. Ensuite, utilisez l'en-tête `Content-Transfer-Encoding` pour indiquer le schéma d'encodage utilisé.

Par exemple, supposons que le corps de votre message contienne le texte suivant : 

१९७२ मे रे टॉमलिंसन ने पहला ई-मेल संदेश भेजा \$1 रे टॉमलिंसन ने ही सर्वप्रथम @ चिन्ह का चयन किया और इन्ही को ईमेल का आविष्कारक माना जाता है

Si vous choisissez d'encoder ce texte en utilisant l'encodage base64, commencez par spécifier l'en-tête suivant :

```
Content-Transfer-Encoding: base64
```

Ensuite, dans la section du corps de l'e-mail, incluez le texte codé en base64 :

```
4KWn4KWv4KWt4KWoIOCkruClhyDgpLDgpYcg4KSf4KWJ4KSu4KSy4KS/4KSC4KS44KSoIOCkqOCl
hyDgpKrgpLngpLLgpL4g4KSILeCkruClh+CksiDgpLjgpILgpKbgpYfgpLYg4KSt4KWH4KSc4KS+
IHwg4KSw4KWHIOCkn+ClieCkruCksuCkv+CkguCkuOCkqCDgpKjgpYcg4KS54KWAIOCkuOCksOCl
jeCkteCkquCljeCksOCkpeCkriBAIOCkmuCkv+CkqOCljeCkuSDgpJXgpL4g4KSa4KSv4KSoIOCk
leCkv+Ckr+CkviDgpJTgpLAg4KSH4KSo4KWN4KS54KWAIOCkleCliyDgpIjgpK7gpYfgpLIg4KSV
4KS+IOCkhuCkteCkv+Ckt+CljeCkleCkvuCksOCklSDgpK7gpL7gpKjgpL4g4KSc4KS+4KSk4KS+
IOCkueCliAo=
```

**Note**  
Dans certains cas, vous pouvez utiliser le `Content-Transfer-Encoding` 8 bits dans les messages que vous envoyez à l'aide d'Amazon SES. Toutefois, si Amazon SES doit apporter de modifications à vos messages (par exemple, lorsque vous utilisez le [suivi des ouvertures et des clics](faqs-metrics.md)), le contenu codé en 8 bits peut ne pas s'afficher correctement quand il arrive dans les boîtes de réception de vos destinataires. Pour cette raison, vous devez toujours encoder le contenu qui n'est pas au format ASCII 7 bits.

#### Attachement de fichiers
<a name="send-email-mime-encoding-files"></a>

Pour attacher un fichier à un e-mail, vous devez encoder la pièce jointe à l'aide de l'encodage base64. Les pièces jointes sont généralement placées dans les parties de message MIME dédiées, qui incluent les en-têtes suivants :
+ **Content-Type** : type de fichier de la pièce jointe. Voici des exemples de déclarations Content-Type MIME courantes :
  + **Fichier en texte brut** : `Content-Type: text/plain; name="sample.txt"`
  + **Document Microsoft Word** : `Content-Type: application/msword; name="document.docx"`
  + **Image JPG** : `Content-Type: image/jpeg; name="photo.jpeg"`
+ **Content-Disposition** : spécifie la façon dont le client de messagerie du destinataire doit gérer le contenu. Pour les pièces jointes, cette valeur est `Content-Disposition: attachment`.
+ **Content-Transfer-Encoding** : schéma ayant été utilisé pour encoder la pièce jointe. Pour les pièces jointes, cette valeur est presque toujours `base64`.
+ **La pièce jointe encodée** : vous devez encoder la pièce jointe proprement dite et l'inclure dans le corps, sous les en-têtes de pièces jointes, comme [indiqué dans l'exemple](#send-email-raw-mime).

Amazon SES accepte la plupart des types de fichiers courants. Pour obtenir une liste des types de fichiers qu'Amazon SES n'accepte pas, reportez-vous à la section [Types de pièces jointes SES non pris en charge](attachments.md#mime-types).

## Envoi d'e-mails bruts à l'aide de l'API Amazon SES v2
<a name="send-email-raw-api"></a>

L'API Amazon SES v2 fournit l'`SendEmail`action, qui vous permet de composer et d'envoyer un e-mail dans le format que vous spécifiez lorsque vous définissez le type de contenu sur simple, brut ou modélisé. Pour une description complète, voir [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendEmail.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendEmail.html). L'exemple suivant indiquera le type de contenu à utiliser `raw` pour envoyer un message en utilisant le format d'e-mail brut.

**Note**  
Pour accéder à des astuces sur la manière d'augmenter la vitesse d'envoi des e-mails lorsque vous effectuez plusieurs appels à `SendEmail`, consultez [Accroissement du débit avec Amazon SES](troubleshoot-throughput-problems.md).

Le corps du message doit contenir un message brut formaté correctement, avec les champs d'en-tête et le codage de corps de message appropriés. Bien qu'il soit possible de composer le message brut manuellement au sein d'une application, il est nettement plus facile de le faire à l'aide de bibliothèques de messagerie existantes. 

------
#### [ Java ]

L'exemple de code suivant montre comment utiliser la [JavaMail](https://javaee.github.io/javamail/)bibliothèque et [AWS SDK pour Java](https://aws.amazon.com/sdk-for-java)comment composer et envoyer un e-mail brut.

```
  1. package com.amazonaws.samples;
  2. 
  3. import java.io.ByteArrayOutputStream;
  4. import java.io.IOException;
  5. import java.io.PrintStream;
  6. import java.nio.ByteBuffer;
  7. import java.util.Properties;
  8. 
  9. // JavaMail libraries. Download the JavaMail API 
 10. // from https://javaee.github.io/javamail/
 11. import javax.activation.DataHandler;
 12. import javax.activation.DataSource;
 13. import javax.activation.FileDataSource;
 14. import javax.mail.Message;
 15. import javax.mail.MessagingException;
 16. import javax.mail.Session;
 17. import javax.mail.internet.AddressException;
 18. import javax.mail.internet.InternetAddress;
 19. import javax.mail.internet.MimeBodyPart;
 20. import javax.mail.internet.MimeMessage;
 21. import javax.mail.internet.MimeMultipart;
 22. 
 23. // AWS SDK libraries. Download the AWS SDK pour Java // from https://aws.amazon.com/sdk-for-java
 24. import com.amazonaws.regions.Regions;
 25. import com.amazonaws.services.simpleemail.AmazonSimpleEmailService;
 26. import com.amazonaws.services.simpleemail.AmazonSimpleEmailServiceClientBuilder;
 27. import com.amazonaws.services.simpleemail.model.RawMessage;
 28. import com.amazonaws.services.simpleemail.model.SendRawEmailRequest;
 29. 
 30. public class AmazonSESSample {
 31. 
 32. 	// Replace sender@example.com with your "From" address.
 33. 	// This address must be verified with Amazon SES.
 34. 	private static String SENDER = "Sender Name <sender@example.com>";
 35. 
 36. 	// Replace recipient@example.com with a "To" address. If your account 
 37. 	// is still in the sandbox, this address must be verified.
 38. 	private static String RECIPIENT = "recipient@example.com";
 39. 
 40. 	// Specify a configuration set. If you do not want to use a configuration
 41. 	// set, comment the following variable, and the 
 42. 	// ConfigurationSetName=CONFIGURATION_SET argument below.
 43. 	private static String CONFIGURATION_SET = "ConfigSet";
 44. 
 45. 	// The subject line for the email.
 46. 	private static String SUBJECT = "Customer service contact info";
 47. 
 48. 	// The full path to the file that will be attached to the email.
 49. 	// If you're using Windows, escape backslashes as shown in this variable.
 50. 	private static String ATTACHMENT = "C:\\Users\\sender\\customers-to-contact.xlsx";
 51. 
 52. 	// The email body for recipients with non-HTML email clients.
 53. 	private static String BODY_TEXT = "Hello,\r\n"
 54.                                         + "Please see the attached file for a list "
 55.                                         + "of customers to contact.";
 56. 
 57. 	// The HTML body of the email.
 58. 	private static String BODY_HTML = "<html>"
 59.                                         + "<head></head>"
 60.                                         + "<body>"
 61.                                         + "<h1>Hello!</h1>"
 62.                                         + "<p>Please see the attached file for a "
 63.                                         + "list of customers to contact.</p>"
 64.                                         + "</body>"
 65.                                         + "</html>";
 66. 
 67.     public static void main(String[] args) throws AddressException, MessagingException, IOException {
 68.             	
 69.     	Session session = Session.getDefaultInstance(new Properties());
 70.         
 71.         // Create a new MimeMessage object.
 72.         MimeMessage message = new MimeMessage(session);
 73.         
 74.         // Add subject, from and to lines.
 75.         message.setSubject(SUBJECT, "UTF-8");
 76.         message.setFrom(new InternetAddress(SENDER));
 77.         message.setRecipients(Message.RecipientType.TO, InternetAddress.parse(RECIPIENT));
 78. 
 79.         // Create a multipart/alternative child container.
 80.         MimeMultipart msg_body = new MimeMultipart("alternative");
 81.         
 82.         // Create a wrapper for the HTML and text parts.        
 83.         MimeBodyPart wrap = new MimeBodyPart();
 84.         
 85.         // Define the text part.
 86.         MimeBodyPart textPart = new MimeBodyPart();
 87.         textPart.setContent(BODY_TEXT, "text/plain; charset=UTF-8");
 88.                 
 89.         // Define the HTML part.
 90.         MimeBodyPart htmlPart = new MimeBodyPart();
 91.         htmlPart.setContent(BODY_HTML,"text/html; charset=UTF-8");
 92.                 
 93.         // Add the text and HTML parts to the child container.
 94.         msg_body.addBodyPart(textPart);
 95.         msg_body.addBodyPart(htmlPart);
 96.         
 97.         // Add the child container to the wrapper object.
 98.         wrap.setContent(msg_body);
 99.         
100.         // Create a multipart/mixed parent container.
101.         MimeMultipart msg = new MimeMultipart("mixed");
102.         
103.         // Add the parent container to the message.
104.         message.setContent(msg);
105.         
106.         // Add the multipart/alternative part to the message.
107.         msg.addBodyPart(wrap);
108.         
109.         // Define the attachment
110.         MimeBodyPart att = new MimeBodyPart();
111.         DataSource fds = new FileDataSource(ATTACHMENT);
112.         att.setDataHandler(new DataHandler(fds));
113.         att.setFileName(fds.getName());
114.         
115.         // Add the attachment to the message.
116.         msg.addBodyPart(att);
117. 
118.         // Try to send the email.
119.         try {
120.             System.out.println("Attempting to send an email through Amazon SES "
121.                               +"using the AWS SDK for Java...");
122. 
123.             // Instantiate an Amazon SES client, which will make the service 
124.             // call with the supplied AWS credentials.
125.             AmazonSimpleEmailService client = 
126.                     AmazonSimpleEmailServiceClientBuilder.standard()
127.                     // Replace US_WEST_2 with the AWS Region you're using for
128.                     // Amazon SES.
129.                     .withRegion(Regions.US_WEST_2).build();
130.             
131.             // Print the raw email content on the console
132.             PrintStream out = System.out;
133.             message.writeTo(out);
134. 
135.             // Send the email.
136.             ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
137.             message.writeTo(outputStream);
138.             RawMessage rawMessage = 
139.             		new RawMessage(ByteBuffer.wrap(outputStream.toByteArray()));
140. 
141.             SendRawEmailRequest rawEmailRequest = 
142.             		new SendRawEmailRequest(rawMessage)
143.             		    .withConfigurationSetName(CONFIGURATION_SET);
144.             
145.             client.sendRawEmail(rawEmailRequest);
146.             System.out.println("Email sent!");
147.         // Display an error if something goes wrong.
148.         } catch (Exception ex) {
149.           System.out.println("Email Failed");
150.             System.err.println("Error message: " + ex.getMessage());
151.             ex.printStackTrace();
152.         }
153.     }
154. }
```

------
#### [ Python ]

L'exemple de code suivant montre comment utiliser les packages [Python email.mime ](https://docs.python.org/3.8/library/email.mime.html) et le kit [AWS SDK pour Python (Boto)](https://aws.amazon.com/sdk-for-python) pour composer et envoyer un e-mail brut.

```
 1. import json
 2. import boto3
 3. from botocore.exceptions import ClientError
 4. from email.mime.multipart import MIMEMultipart
 5. from email.mime.text import MIMEText
 6. from email.mime.application import MIMEApplication
 7. import os
 8. 
 9. def boto3_rawemailv2():
10.     SENDER = "Sender <sender@example.com>"
11.     RECIPIENT = "recipient@example.com"
12.     CONFIGURATION_SET = "ConfigSet"
13.     AWS_REGION = "us-east-1"
14.     SUBJECT = "Customer service contact info"
15.     ATTACHMENT = "path/to/customers-to-contact.xlsx"
16.     BODY_TEXT = "Hello,\r\nPlease see the attached file for a list of customers to contact."
17. 
18.     # The HTML body of the email.
19.     BODY_HTML = """\
20.     <html>
21.     <head/>
22.     <body>
23.     <h1>Hello!</h1>
24.     <p>Please see the attached file for a list of customers to contact.</p>
25.     </body>
26.     </html>
27.     """
28. 
29.     # The character encoding for the email.
30.     CHARSET = "utf-8"
31.     msg = MIMEMultipart('mixed')
32.     # Add subject, from and to lines.
33.     msg['Subject'] = SUBJECT 
34.     msg['From'] = SENDER 
35.     msg['To'] = RECIPIENT
36.     
37.     # Create a multipart/alternative child container.
38.     msg_body = MIMEMultipart('alternative')
39.     
40.     # Encode the text and HTML content and set the character encoding. This step is
41.     # necessary if you're sending a message with characters outside the ASCII range.
42.     textpart = MIMEText(BODY_TEXT.encode(CHARSET), 'plain', CHARSET)
43.     htmlpart = MIMEText(BODY_HTML.encode(CHARSET), 'html', CHARSET)
44.     
45.     # Add the text and HTML parts to the child container.
46.     msg_body.attach(textpart)
47.     msg_body.attach(htmlpart)
48.     
49.     # Define the attachment part and encode it using MIMEApplication.
50.     att = MIMEApplication(open(ATTACHMENT, 'rb').read())
51.     
52.     # Add a header to tell the email client to treat this part as an attachment,
53.     # and to give the attachment a name.
54.     att.add_header('Content-Disposition','attachment',filename=os.path.basename(ATTACHMENT))
55.     
56.     # Attach the multipart/alternative child container to the multipart/mixed
57.     # parent container.
58.     msg.attach(msg_body)
59.     msg.attach(att)
60. 
61.     #changes start from here
62.     strmsg = str(msg)
63.     body = bytes (strmsg, 'utf-8')
64. 
65. 
66. 
67.     
68.     client = boto3.client('sesv2')
69.     response = client.send_email(
70.     FromEmailAddress=SENDER,
71.     Destination={
72.         'ToAddresses': [RECIPIENT]
73.     },
74.     Content={
75.         'Raw': {
76.             'Data': body
77.         }
78.     }
79.     )
80.     print(response)
81. boto3_rawemailv2 ()
```

------

# Utiliser des modèles pour envoyer des e-mails personnalisés à l'aide de l'API Amazon SES
<a name="send-personalized-email-api"></a>

Dans Amazon SES, vous pouvez envoyer un modèle d'e-mail en utilisant un *modèle enregistré* ou en utilisant un modèle *intégré.*
+ **Modèle stocké** : fait référence à la [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Template.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Template.html)ressource créée et enregistrée dans SES à l'aide de l'`CreateEmailTemplate`opération de l'API Amazon SES v2. Le modèle contient l'objet et le corps de l'e-mail contenant des variables (espaces réservés) conformes au contenu écrit. Le nom du modèle stocké et les données dynamiques associées aux variables d'espace réservé du modèle sont fournis lors de l'appel des opérations d'API `SendEmail` ou de l'API `SendBulkEmail` v2.

  *Les modèles enregistrés* peuvent être facilement réutilisés et peuvent vous faire économiser du temps et des efforts lors de l'envoi de types d'e-mails similaires. Au lieu de créer chaque e-mail à partir de zéro, il vous suffit de créer la structure de base et le design une seule fois, puis de simplement mettre à jour le contenu dynamique du modèle.
+ **Modèle intégré** — La `Template` ressource n'est pas utilisée, mais l'objet et le corps de l'e-mail contenant des variables (espaces réservés) intégrés au contenu écrit, ainsi que les valeurs de ces variables d'espace réservé, sont fournis lors de l'appel des opérations de l'API `SendEmail` ou `SendBulkEmail` de l'API v2.

  *Les modèles intégrés* rationalisent le processus d'envoi d'e-mails en masse en éliminant le besoin de gérer les ressources des modèles dans votre compte SES et simplifient le processus d'intégration en vous permettant d'inclure le contenu du modèle directement dans la logique de votre application. Ils ne sont pas pris en compte dans la limite de 20 000 modèles par. Région AWS

Les limites suivantes s'appliquent lors de l'utilisation de *modèles enregistrés* :
+ Vous pouvez créer jusqu'à 20 000 modèles d'e-mails dans chacun Région AWS.
+ Chaque modèle peut avoir une taille maximale de 500 Ko, parties texte et HTML incluses.

La limite suivante s'applique lors de l'utilisation de *modèles intégrés* :
+ La taille de chaque fichier JSON d'entrée peut atteindre 1 Mo, y compris les parties texte et HTML.

Ce qui suit s'applique à la fois aux modèles *stockés* et aux *modèles en ligne* :
+ Il n'y a aucune limite quant au nombre de variables de remplacement pouvant être utilisées.
+ Vous pouvez envoyer un e-mail à un maximum de 50 objets de destination lors de chaque appel à l'`SendBulkEmail`opération. L'[https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Destination.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Destination.html)objet peut contenir plusieurs destinataires définis dans **ToAddresses**CcAddresses****, et **BccAddresses**. Le nombre de destinations que vous pouvez contacter en un seul appel à l'API v2 peut être limité par le taux d'envoi maximal de votre compte. Pour de plus amples informations, veuillez consulter [Gestion de vos limites d'envoi Amazon SES](manage-sending-quotas.md).

Ce chapitre inclut des procédures avec des exemples d'utilisation à la fois de *modèles stockés* et de *modèles intégrés*.

**Note**  
Les procédures de cette section supposent aussi que vous avez déjà installé et configuré l' AWS CLI. Pour plus d'informations sur l'installation et la configuration du AWS CLI, consultez le [guide de AWS Command Line Interface l'utilisateur](https://docs.aws.amazon.com/cli/latest/userguide/).

## (Facultatif) Partie 1 : Configuration des notifications d'événements d'échec de rendu
<a name="send-personalized-email-set-up-notifications"></a>

 Si vous envoyez un e-mail qui contient un contenu de personnalisation non valide, Amazon SES peut initialement accepter le message, mais ne pourra pas le remettre. C'est pourquoi, si vous envisagez d'envoyer un e-mail personnalisé, vous devez configurer SES pour envoyer des notifications d'échec de rendu via Amazon SNS. Lorsque vous recevez une notification d'événement d'échec d'affichage, vous pouvez identifier le message qui comportait un contenu non valide, corriger les problèmes et renvoyer le message.

La procédure décrite dans cette section est facultative, mais vivement recommandée.

**Pour configurer des notifications d'événement d'échec d'affichage**

1. Créer une rubrique Amazon SNS. Pour obtenir les procédures, veuillez consulter [Création d'une rubrique](https://docs.aws.amazon.com/sns/latest/dg/sns-create-subscribe-endpoint-to-topic.html) dans le *Guide du développeur Amazon Simple Notification Service*.

1. Abonnez-vous à la rubrique Amazon SNS. Par exemple, si vous voulez recevoir des notifications d'événement d'échec d'affichage par e-mail, abonnez un point de terminaison de messagerie (votre adresse e-mail) à la rubrique.

   Pour obtenir des procédures, veuillez consulter [Abonnement à une rubrique](https://docs.aws.amazon.com/sns/latest/dg/SubscribeTopic.html) dans le *Guide du développeur Amazon Simple Notification Service*.

1. Suivez les procédures de [Configurer une destination d'événement Amazon SNS pour la publication d'événements](event-publishing-add-event-destination-sns.md) pour configurer vos jeux de configuration afin de publier des notifications d'événement d'échec d'affichage dans votre rubrique Amazon SNS.

## (Facultatif) Partie 2 : Création d'un modèle d'e-mail
<a name="send-personalized-email-create-template"></a>

Si vous avez l'intention d'utiliser un *modèle stocké*, cette section explique comment utiliser l'opération API [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_CreateEmailTemplate.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_CreateEmailTemplate.html)SES v2 pour créer le modèle. Vous pouvez ignorer cette étape si vous souhaitez utiliser un *modèle intégré*.

Cette procédure suppose que vous avez déjà installé et configuré l' AWS CLI. Pour plus d'informations sur l'installation et la configuration du AWS CLI, consultez le [guide de AWS Command Line Interface l'utilisateur](https://docs.aws.amazon.com/cli/latest/userguide/).

**Pour créer le modèle**

1. Dans un éditeur de texte, créez un nouveau fichier et collez le code suivant pour le personnaliser selon vos besoins.

   ```
   {
       "TemplateName": "MyTemplate",
       "TemplateContent": {
           "Subject": "Greetings, {{name}}!",
           "Text": "Dear {{name}},\r\nYour favorite animal is {{favoriteanimal}}.",
           "Html": "<h1>Hello {{name}},</h1><p>Your favorite animal is {{favoriteanimal}}.</p>"
       }
   }
   ```

   Ce code contient les propriétés suivantes :
   + **TemplateName**— Le nom de la `Template` ressource. Lorsque vous envoyez l'e-mail, vous faites référence à ce nom.
   + **TemplateContent**— Un conteneur pour les attributs suivants :
     + **Objet** : ligne d'objet de l'e-mail. Cette propriété peut contenir des balises de remplacement. Celles-ci utilisent le format suivant : `{{tagname}}`. Lorsque vous envoyez l'e-mail, vous pouvez attribuer une valeur à `tagname` pour chaque destination.
     + **Html** — Le corps HTML de l'e-mail. Cette propriété peut contenir des balises de remplacement. L'exemple précédent contient deux balises : `{{name}}` et `{{favoriteanimal}}`.
     + **Texte** — Le corps du texte de l'e-mail. Les destinataires dont les clients de messagerie n'affichent pas de contenu HTML verront cette version de l'e-mail. Cette propriété peut également contenir des étiquettes de remplacement.

1. Personnalisez l'exemple précédent pour l'adapter à vos besoins, puis enregistrez le fichier sous *mytemplate.json*.

1. Sur la ligne de commande, tapez la commande suivante pour créer un nouveau modèle à l'aide de l'opération d'API [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_CreateEmailTemplate.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_CreateEmailTemplate.html)v2 :

   ```
   aws sesv2 create-email-template --cli-input-json file://mytemplate.json
   ```

## Partie 3 : Envoi de l'e-mail personnalisé
<a name="send-personalized-email-api-operations"></a>

Vous pouvez utiliser les deux opérations d'API SES v2 suivantes pour envoyer des e-mails à l'aide de *modèles stockés* ou de *modèles intégrés* :
+ L'[https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendEmail.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendEmail.html)opération est utile pour envoyer un e-mail personnalisé à un seul objet de destination. L'[https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Destination.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Destination.html)objet API v2 peut contenir les *BccAddresses*propriétés *ToAddresses*CcAddresses**, et. Ils peuvent être utilisés dans n'importe quelle combinaison et peuvent contenir une ou plusieurs adresses e-mail qui recevront le même e-mail.
+ L'[https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendBulkEmail.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendBulkEmail.html)opération est utile pour envoyer des e-mails uniques à plusieurs objets de destination en un seul appel à l'API v2.

Cette section fournit des exemples d'utilisation du modèle AWS CLI d'e-mail à l'aide de ces deux opérations d'envoi.

### Envoi d'un modèle d'e-mail à un seul objet de destination
<a name="send-templated-email-single-destination"></a>

Vous pouvez utiliser cette [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendEmail.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendEmail.html)opération pour envoyer un e-mail à un ou plusieurs destinataires définis dans un seul objet de destination. Toutes les destinataires de l'objet [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Destination.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Destination.html) recevront le même e-mail.

**Pour envoyer un modèle d'e-mail à un seul objet de destination**

1. Selon que vous souhaitez utiliser un *modèle enregistré ou un modèle* *intégré*, sélectionnez l'exemple de code correspondant à coller dans un éditeur de texte, en le personnalisant selon vos besoins.

------
#### [ Stored template code example ]

   Notez que le modèle que vous avez créé à l'*MyTemplate*étape précédente est référencé comme valeur du `TemplateName` paramètre.

   ```
   {
       "FromEmailAddress": "Mary Major <mary.major@example.com>",
       "Destination": {
           "ToAddresses": [
               "alejandro.rosalez@example.com", "jimmy.jet@example.com"
           ]
       },
       "Content": {
           "Template": {
               "TemplateName": "MyTemplate",
               "TemplateData": "{ \"name\":\"Alejandro\", \"favoriteanimal\": \"alligator\" }"
           }
       },
       "ConfigurationSetName": "ConfigSet"
   }
   ```

   Ce code contient les propriétés suivantes :
   + **FromEmailAddress**— L'adresse e-mail de l'expéditeur.
   + **Destination** : objet contenant les destinataires des e-mails définis dans les *BccAddresses*propriétés *ToAddresses*CcAddresses**, et. Ils peuvent être utilisés dans n'importe quelle combinaison et peuvent contenir une ou plusieurs adresses e-mail qui recevront le même e-mail.
   + **TemplateName**— Le nom de la `Template` ressource à appliquer à l'e-mail.
   + **TemplateData**— Chaîne JSON échappée contenant des paires clé-valeur. Les clés correspondent aux variables définies dans les `TemplateContent` propriétés du modèle stocké, par exemple`{{name}}`. Les valeurs représentent le contenu qui remplace les variables.
   + **ConfigurationSetName**— Le nom du jeu de configuration à utiliser lors de l'envoi de l'e-mail.
**Note**  
Nous vous recommandons d'utiliser un jeu de configurations qui est configuré pour publier les événements d'échec d'affichage dans Amazon SNS. Pour de plus amples informations, veuillez consulter [(Facultatif) Partie 1 : Configuration des notifications d'événements d'échec de rendu](#send-personalized-email-set-up-notifications).

------
#### [ Inline template code example ]

   Notez que les `TemplateContent` propriétés (qui devraient normalement être définies dans un *modèle stocké*) sont définies *en ligne* avec la `TemplateData` propriété qui en fait un modèle *en ligne*.

   ```
   {
       "FromEmailAddress": "Mary Major <mary.major@example.com>",
       "Destination": {
           "ToAddresses": [
               "alejandro.rosalez@example.com", "jimmy.jet@example.com"
           ]
       },
       "Content": {
           "Template": {
               "TemplateContent": {
                   "Subject": "Greetings, {{name}}!",
                   "Text": "Dear {{name}},\r\nYour favorite animal is {{favoriteanimal}}.",
                   "Html": "<h1>Hello {{name}},</h1><p>Your favorite animal is {{favoriteanimal}}.</p>"
               },
               "TemplateData": "{ \"name\":\"Alejandro\", \"favoriteanimal\": \"alligator\" }"
           }
       },
       "ConfigurationSetName": "ConfigSet"
   }
   ```

   Ce code contient les propriétés suivantes :
   + **FromEmailAddress**— L'adresse e-mail de l'expéditeur.
   + **Destination** : objet contenant les destinataires des e-mails définis dans les *BccAddresses*propriétés *ToAddresses*CcAddresses**, et. Ils peuvent être utilisés dans n'importe quelle combinaison et peuvent contenir une ou plusieurs adresses e-mail qui recevront le même e-mail.
   + **TemplateContent**— Un conteneur pour les attributs suivants :
     + **Objet** : ligne d'objet de l'e-mail. Cette propriété peut contenir des balises de remplacement. Celles-ci utilisent le format suivant : `{{tagname}}`. Lorsque vous envoyez l'e-mail, vous pouvez attribuer une valeur à `tagname` pour chaque destination.
     + **Html** — Le corps HTML de l'e-mail. Cette propriété peut contenir des balises de remplacement. L'exemple précédent contient deux balises : `{{name}}` et `{{favoriteanimal}}`.
     + **Texte** — Le corps du texte de l'e-mail. Les destinataires dont les clients de messagerie n'affichent pas de contenu HTML verront cette version de l'e-mail. Cette propriété peut également contenir des étiquettes de remplacement.
   + **TemplateData**— Chaîne JSON échappée contenant des paires clé-valeur. Les clés correspondent aux variables définies dans les `TemplateContent` propriétés de ce fichier, par exemple`{{name}}`. Les valeurs représentent le contenu qui remplace les variables.
   + **ConfigurationSetName**— Le nom du jeu de configuration à utiliser lors de l'envoi de l'e-mail.
**Note**  
Nous vous recommandons d'utiliser un jeu de configurations qui est configuré pour publier les événements d'échec d'affichage dans Amazon SNS. Pour de plus amples informations, veuillez consulter [(Facultatif) Partie 1 : Configuration des notifications d'événements d'échec de rendu](#send-personalized-email-set-up-notifications).

------

1. Personnalisez l'exemple précédent pour l'adapter à vos besoins, puis enregistrez le fichier sous *myemail.json*.

1. Sur la ligne de commande, tapez la commande API v2 suivante pour envoyer l'e-mail :

   ```
   aws sesv2 send-email --cli-input-json file://myemail.json
   ```

### Envoi d'un modèle d'e-mail à plusieurs objets de destination
<a name="send-templated-email-multiple-destinations"></a>

Vous pouvez utiliser cette [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendBulkEmail.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendBulkEmail.html)opération pour envoyer un e-mail à plusieurs objets de destination en un seul appel à l'API SES v2. SES envoie un e-mail unique au ou aux destinataires de chaque [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Destination.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Destination.html)objet.

**Pour envoyer un modèle d'e-mail à plusieurs objets de destination**

1. Selon que vous souhaitez utiliser un *modèle enregistré ou un modèle* *intégré*, sélectionnez l'exemple de code correspondant à coller dans un éditeur de texte, en le personnalisant selon vos besoins.

------
#### [ Stored template code example ]

   Notez que le modèle que vous avez créé à l'*MyTemplate*étape précédente est référencé comme valeur du `TemplateName` paramètre.

   ```
   {
       "FromEmailAddress": "Mary Major <mary.major@example.com>",
       "DefaultContent": {
           "Template": {
               "TemplateName": "MyTemplate",
               "TemplateData": "{ \"name\":\"friend\", \"favoriteanimal\":\"unknown\" }"
           }
       },
       "BulkEmailEntries": [
           {
               "Destination": {
                   "ToAddresses": [
                       "anaya.iyengar@example.com"
                   ]
               },
               "ReplacementEmailContent": {
                   "ReplacementTemplate": {
                       "ReplacementTemplateData": "{ \"name\":\"Anaya\", \"favoriteanimal\":\"angelfish\" }"
                   }
               }
           },
           {
               "Destination": {
                   "ToAddresses": [
                       "liu.jie@example.com"
                   ]
               },
               "ReplacementEmailContent": {
                   "ReplacementTemplate": {
                       "ReplacementTemplateData": "{ \"name\":\"Liu\", \"favoriteanimal\":\"lion\" }"
                   }
               }
           },
           {
               "Destination": {
                   "ToAddresses": [
                       "shirley.rodriguez@example.com"
                   ]
               },
               "ReplacementEmailContent": {
                   "ReplacementTemplate": {
                       "ReplacementTemplateData": "{ \"name\":\"Shirley\", \"favoriteanimal\":\"shark\" }"
                   }
               }
           },
           {
               "Destination": {
                   "ToAddresses": [
                       "richard.roe@example.com"
                   ]
               },
               "ReplacementEmailContent": {
                   "ReplacementTemplate": {
                       "ReplacementTemplateData": "{}"
                   }
               }
           }
       ],
       "ConfigurationSetName": "ConfigSet"
   }
   ```

   Ce code contient les propriétés suivantes :
   + **FromEmailAddress**— L'adresse e-mail de l'expéditeur.
   + **DefaultContent**— Un objet JSON contenant les `TemplateData` objets `TemplateName` et. 
   + **TemplateName**— Le nom de la `Template` ressource à appliquer à l'e-mail.
   + **TemplateData**— Contient des paires clé-valeur qui seront utilisées si l'`ReplacementEmailContent`objet contient un objet JSON vide dans la `ReplacementTemplateData` propriété. `{}`
   + **BulkEmailEntries**— Tableau contenant un ou plusieurs `Destination` objets.
   + **Destination** : objet contenant les destinataires des e-mails définis dans les *BccAddresses*propriétés *ToAddresses*CcAddresses**, et. Ils peuvent être utilisés dans n'importe quelle combinaison et peuvent contenir une ou plusieurs adresses e-mail qui recevront le même e-mail.
   + **ReplacementTemplateData**— Chaîne JSON échappée contenant des paires clé-valeur. Les clés correspondent aux variables du modèle, par exemple`{{name}}`. Les valeurs représentent le contenu qui remplace les variables de l'e-mail. (Si la chaîne JSON est vide, indiquée par`{}`, les paires clé-valeur définies dans la `TemplateData` propriété de l'`DefaultContent`objet seront utilisées.)
   + **ConfigurationSetName**— Le nom du jeu de configuration à utiliser lors de l'envoi de l'e-mail.
**Note**  
Nous vous recommandons d'utiliser un jeu de configurations qui est configuré pour publier les événements d'échec d'affichage dans Amazon SNS. Pour de plus amples informations, veuillez consulter [(Facultatif) Partie 1 : Configuration des notifications d'événements d'échec de rendu](#send-personalized-email-set-up-notifications).

------
#### [ Inline template code example ]

   Notez que les `TemplateContent` propriétés (qui devraient normalement être définies dans un *modèle stocké*) sont définies *en ligne* avec la `TemplateData` propriété qui en fait un modèle *en ligne*.

   ```
   {
       "FromEmailAddress": "Mary Major <mary.major@example.com>",
       "DefaultContent": {
           "Template": {
               "TemplateContent": {
                   "Subject": "Greetings, {{name}}!",
                   "Text": "Dear {{name}},\r\nYour favorite animal is {{favoriteanimal}}.",
                   "Html": "<h1>Hello {{name}},</h1><p>Your favorite animal is {{favoriteanimal}}.</p>"
               },
               "TemplateData": "{ \"name\":\"friend\", \"favoriteanimal\":\"unknown\" }"
           }
       },
       "BulkEmailEntries": [
           {
               "Destination": {
                   "ToAddresses": [
                       "anaya.iyengar@example.com"
                   ]
               },
               "ReplacementEmailContent": {
                   "ReplacementTemplate": {
                       "ReplacementTemplateData": "{ \"name\":\"Anaya\", \"favoriteanimal\":\"angelfish\" }"
                   }
               }
           },
           {
               "Destination": {
                   "ToAddresses": [
                       "liu.jie@example.com"
                   ]
               },
               "ReplacementEmailContent": {
                   "ReplacementTemplate": {
                       "ReplacementTemplateData": "{ \"name\":\"Liu\", \"favoriteanimal\":\"lion\" }"
                   }
               }
           },
           {
               "Destination": {
                   "ToAddresses": [
                       "shirley.rodriguez@example.com"
                   ]
               },
               "ReplacementEmailContent": {
                   "ReplacementTemplate": {
                       "ReplacementTemplateData": "{ \"name\":\"Shirley\", \"favoriteanimal\":\"shark\" }"
                   }
               }
           },
           {
               "Destination": {
                   "ToAddresses": [
                       "richard.roe@example.com"
                   ]
               },
               "ReplacementEmailContent": {
                   "ReplacementTemplate": {
                       "ReplacementTemplateData": "{}"
                   }
               }
           }
       ],
       "ConfigurationSetName": "ConfigSet"
   }
   ```

   Ce code contient les propriétés suivantes :
   + **FromEmailAddress**— L'adresse e-mail de l'expéditeur.
   + **DefaultContent**— Un objet JSON contenant les `TemplateData` objets `TemplateContent` et. 
   + **TemplateContent**— Un conteneur pour les attributs suivants :
     + **Objet** : ligne d'objet de l'e-mail. Cette propriété peut contenir des balises de remplacement. Celles-ci utilisent le format suivant : `{{tagname}}`. Lorsque vous envoyez l'e-mail, vous pouvez attribuer une valeur à `tagname` pour chaque destination.
     + **Html** — Le corps HTML de l'e-mail. Cette propriété peut contenir des balises de remplacement. L'exemple précédent contient deux balises : `{{name}}` et `{{favoriteanimal}}`.
     + **Texte** — Le corps du texte de l'e-mail. Les destinataires dont les clients de messagerie n'affichent pas de contenu HTML verront cette version de l'e-mail. Cette propriété peut également contenir des étiquettes de remplacement.
   + **TemplateData**— Contient des paires clé-valeur qui seront utilisées si l'`ReplacementEmailContent`objet contient un objet JSON vide dans la `ReplacementTemplateData` propriété. `{}`
   + **BulkEmailEntries**— Tableau contenant un ou plusieurs `Destination` objets.
   + **Destination** : objet contenant les destinataires des e-mails définis dans les *BccAddresses*propriétés *ToAddresses*CcAddresses**, et. Ils peuvent être utilisés dans n'importe quelle combinaison et peuvent contenir une ou plusieurs adresses e-mail qui recevront le même e-mail.
   + **ReplacementTemplateData**— Chaîne JSON échappée contenant des paires clé-valeur. Les clés correspondent aux variables définies dans les `TemplateContent` propriétés de ce fichier, par exemple`{{name}}`. Les valeurs représentent le contenu qui remplace les variables de l'e-mail. (Si la chaîne JSON est vide, indiquée par`{}`, les paires clé-valeur définies dans la `TemplateData` propriété de l'`DefaultContent`objet seront utilisées.)
   + **ConfigurationSetName**— Le nom du jeu de configuration à utiliser lors de l'envoi de l'e-mail.
**Note**  
Nous vous recommandons d'utiliser un jeu de configurations qui est configuré pour publier les événements d'échec d'affichage dans Amazon SNS. Pour de plus amples informations, veuillez consulter [(Facultatif) Partie 1 : Configuration des notifications d'événements d'échec de rendu](#send-personalized-email-set-up-notifications).

------

1. Modifiez les valeurs dans le code ci-dessus selon vos besoins, puis enregistrez le fichier sous le nom *mybulkemail.json*.

1. Sur la ligne de commande, tapez la commande API v2 suivante pour envoyer l'e-mail en masse :

   ```
   aws sesv2 send-bulk-email --cli-input-json file://mybulkemail.json
   ```

# Personnalisation avancée des e-mails
<a name="send-personalized-email-advanced"></a>

 Si vous utilisez un *modèle stocké*, c'est-à-dire que vous avez créé une [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Template.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Template.html)ressource dans Amazon SES à l'aide de l'`CreateEmailTemplate`API SES v2, vous pouvez tirer parti du système Handlebars pour créer des modèles qui incluent des fonctionnalités avancées, telles que des attributs imbriqués, l'itération de tableaux, des instructions conditionnelles de base et la création de partiels intégrés. Cette section fournit des exemples de ces fonctions.

Handlebars inclut d'autres fonctions en plus de celles documentées dans la présente section. Pour plus d'informations, veuillez consulter [Built-In Helpers (Assistants intégrés)](https://handlebarsjs.com/guide/builtin-helpers.html) sur [handlebarsjs.com](http://handlebarsjs.com).

**Note**  
SES n'échappe pas le contenu HTML lors du rendu du modèle HTML d'un message. Cela implique que si vous incluez des données saisies par l'utilisateur, par exemple à partir d'un formulaire de contact, vous devrez les échapper du côté du client.

**Topics**
+ [

## Analyse des attributs imbriqués
](#send-personalized-email-advanced-nested)
+ [

## Itération au moyen de listes
](#send-personalized-email-advanced-iterating)
+ [

## Utilisation des instructions conditionnelles de base
](#send-personalized-email-advanced-conditionals)
+ [

## Création de fichiers partiels en ligne
](#send-personalized-email-advanced-inline-partials)

## Analyse des attributs imbriqués
<a name="send-personalized-email-advanced-nested"></a>

Handlebars inclut la prise en charge des chemins imbriqués, ce qui facilite l'organisation de données client complexes, ainsi que la référence à ces données dans vos modèles d'e-mails.

Par exemple, vous pouvez organiser les données des destinataires en plusieurs catégories générales. Au sein de chacune de ces catégories, vous pouvez inclure des informations détaillées. L'exemple de code suivant illustre un exemple de cette structure pour un seul destinataire :

```
{
  "meta":{
    "userId":"51806220607"
  },
  "contact":{
    "firstName":"Anaya",
    "lastName":"Iyengar",
    "city":"Bengaluru",
    "country":"India",
    "postalCode":"560052"
  },
  "subscription":[
    {
      "interest":"Sports"
    },
    {
      "interest":"Travel"
    },
    {
      "interest":"Cooking"
    }
  ]
}
```

Dans vos modèles d'e-mails, vous pouvez vous référer aux attributs imbriqués en fournissant le nom de l'attribut parent, suivi d'un point (.) et du nom de l'attribut pour lequel vous souhaitez inclure la valeur. Par exemple, si vous utilisez la structure de données de l'exemple précédent et que vous souhaitez inclure le prénom de chaque destinataire dans le modèle d'e-mail, incluez le texte suivant dans votre modèle d'e-mail : `Hello {{contact.firstName}}!`

Handlebars peut analyser les chemins imbriqués à plusieurs niveaux de profondeur, ce qui signifie que vous avez une certaine souplesse quant à la façon de structurer les données de votre modèle.

## Itération au moyen de listes
<a name="send-personalized-email-advanced-iterating"></a>

L'assistant `each` itère sur les éléments d'un tableau. Le code suivant est un exemple de modèle d'e-mail utilisant l'assistant `each` pour créer une liste détaillée des centres d'intérêt de chaque destinataire.

```
{
  "Template": {
    "TemplateName": "Preferences",
    "SubjectPart": "Subscription Preferences for {{contact.firstName}} {{contact.lastName}}",
    "HtmlPart": "<h1>Your Preferences</h1>
                 <p>You have indicated that you are interested in receiving 
                   information about the following subjects:</p>
                 <ul>
                   {{#each subscription}}
                     <li>{{interest}}</li>
                   {{/each}}
                 </ul>
                 <p>You can change these settings at any time by visiting 
                    the <a href=https://www.example.com/prefererences/i.aspx?id={{meta.userId}}>
                    Preference Center</a>.</p>",
    "TextPart": "Your Preferences\n\nYou have indicated that you are interested in 
                 receiving information about the following subjects:\n
                 {{#each subscription}}
                   - {{interest}}\n
                 {{/each}}
                 \nYou can change these settings at any time by 
                 visiting the Preference Center at 
                 https://www.example.com/prefererences/i.aspx?id={{meta.userId}}"
  }
}
```

**Important**  
Dans l'exemple de code précédent, les valeurs des attributs `HtmlPart` et `TextPart` comportent des sauts de ligne pour faciliter la lecture de l'exemple. Le fichier JSON de votre modèle ne peut pas contenir de sauts de ligne au sein de ces valeurs. Si vous copiez et collez cet exemple dans votre propre fichier JSON, supprimez les sauts de ligne et les espaces supplémentaires des sections `HtmlPart` et `TextPart` avant de poursuivre.

Une fois le modèle créé, vous pouvez utiliser l'opération `SendEmail` ou `SendBulkEmail` pour envoyer un e-mail aux destinataires à l'aide de ce modèle. Tant que chaque destinataire possède au moins une valeur dans l'objet `Interests`, il reçoit un e-mail incluant la liste détaillée de ses centres d'intérêts. L'exemple suivant illustre un fichier JSON qui peut être utilisé pour envoyer un e-mail à plusieurs destinataires à l'aide du modèle précédent :

```
{
  "Source":"Sender Name <sender@example.com>",
  "Template":"Preferences",
  "Destinations":[
    {
      "Destination":{
        "ToAddresses":[
          "anaya.iyengar@example.com"
        ]
      },
      "ReplacementTemplateData":"{\"meta\":{\"userId\":\"51806220607\"},\"contact\":{\"firstName\":\"Anaya\",\"lastName\":\"Iyengar\"},\"subscription\":[{\"interest\":\"Sports\"},{\"interest\":\"Travel\"},{\"interest\":\"Cooking\"}]}"
      },
    {
      "Destination":{ 
        "ToAddresses":[
          "shirley.rodriguez@example.com"
        ]
      },
      "ReplacementTemplateData":"{\"meta\":{\"userId\":\"1981624758263\"},\"contact\":{\"firstName\":\"Shirley\",\"lastName\":\"Rodriguez\"},\"subscription\":[{\"interest\":\"Technology\"},{\"interest\":\"Politics\"}]}"
    }
  ],
  "DefaultTemplateData":"{\"meta\":{\"userId\":\"\"},\"contact\":{\"firstName\":\"Friend\",\"lastName\":\"\"},\"subscription\":[]}"
}
```

Lorsque vous envoyez un e-mail aux destinataires listés dans l'exemple précédent à l'aide de l'opération `SendBulkEmail`, ceux-ci reçoivent un message semblable à l'exemple illustré dans l'image suivante :

![\[Preferences notification listing Sports, Travel, and Cooking as selected interests.\]](http://docs.aws.amazon.com/fr_fr/ses/latest/dg/images/send-personalized-email-advanced-condition-interest.png)


## Utilisation des instructions conditionnelles de base
<a name="send-personalized-email-advanced-conditionals"></a>

Cette section repose sur l'exemple décrit dans la section précédente. L'exemple de la section précédente utilise l'assistant `each` pour itérer sur une liste de centres d'intérêt. Cependant, les destinataires pour lesquels aucun centre d'intérêt n'est spécifié reçoivent un e-mail avec une liste vide. À l'aide de l'assistant `{{if}}`, vous pouvez formater l'e-mail différemment si un certain attribut est présent dans les données du modèle. Le code suivant utilise l'assistant `{{if}}` pour afficher la liste à puces de la section précédente si le tableau `Subscription` contient des valeurs. Si le tableau est vide, un autre bloc de texte s'affiche.

```
{
  "Template": {
    "TemplateName": "Preferences2",
    "SubjectPart": "Subscription Preferences for {{contact.firstName}} {{contact.lastName}}",
    "HtmlPart": "<h1>Your Preferences</h1>
                 <p>Dear {{contact.firstName}},</p>
                 {{#if subscription}}
                   <p>You have indicated that you are interested in receiving 
                     information about the following subjects:</p>
                     <ul>
                     {{#each subscription}}
                       <li>{{interest}}</li>
                     {{/each}}
                     </ul>
                     <p>You can change these settings at any time by visiting 
                       the <a href=https://www.example.com/prefererences/i.aspx?id={{meta.userId}}>
                       Preference Center</a>.</p>
                 {{else}}
                   <p>Please update your subscription preferences by visiting 
                     the <a href=https://www.example.com/prefererences/i.aspx?id={{meta.userId}}>
                     Preference Center</a>.
                 {{/if}}",
    "TextPart": "Your Preferences\n\nDear {{contact.firstName}},\n\n
                 {{#if subscription}}
                   You have indicated that you are interested in receiving 
                   information about the following subjects:\n
                   {{#each subscription}}
                     - {{interest}}\n
                   {{/each}}
                   \nYou can change these settings at any time by visiting the 
                   Preference Center at https://www.example.com/prefererences/i.aspx?id={{meta.userId}}.
                 {{else}}
                   Please update your subscription preferences by visiting the 
                   Preference Center at https://www.example.com/prefererences/i.aspx?id={{meta.userId}}.
                 {{/if}}"
  }
}
```

**Important**  
Dans l'exemple de code précédent, les valeurs des attributs `HtmlPart` et `TextPart` comportent des sauts de ligne pour faciliter la lecture de l'exemple. Le fichier JSON de votre modèle ne peut pas contenir de sauts de ligne au sein de ces valeurs. Si vous copiez et collez cet exemple dans votre propre fichier JSON, supprimez les sauts de ligne et les espaces supplémentaires des sections `HtmlPart` et `TextPart` avant de poursuivre.

L'exemple suivant illustre un fichier JSON qui peut être utilisé pour envoyer un e-mail à plusieurs destinataires à l'aide du modèle précédent :

```
{
  "Source":"Sender Name <sender@example.com>",
  "Template":"Preferences2",
  "Destinations":[
    {
      "Destination":{
        "ToAddresses":[
          "anaya.iyengar@example.com"
        ]
      },
      "ReplacementTemplateData":"{\"meta\":{\"userId\":\"51806220607\"},\"contact\":{\"firstName\":\"Anaya\",\"lastName\":\"Iyengar\"},\"subscription\":[{\"interest\":\"Sports\"},{\"interest\":\"Cooking\"}]}"
      },
    {
      "Destination":{ 
        "ToAddresses":[
          "shirley.rodriguez@example.com"
        ]
      },
      "ReplacementTemplateData":"{\"meta\":{\"userId\":\"1981624758263\"},\"contact\":{\"firstName\":\"Shirley\",\"lastName\":\"Rodriguez\"}}"
    }
  ],
  "DefaultTemplateData":"{\"meta\":{\"userId\":\"\"},\"contact\":{\"firstName\":\"Friend\",\"lastName\":\"\"},\"subscription\":[]}"
}
```

Dans cet exemple, le destinataire dont les données du modèle incluaient une liste de centres d'intérêt reçoit le même e-mail que l'exemple de la section précédente. Le destinataire dont les données du modèle ne contenaient pas de centre d'intérêt reçoit, néanmoins, un e-mail similaire à l'exemple de l'image suivante :

![\[Email message with header "Your Preferences" and text about updating subscription preferences.\]](http://docs.aws.amazon.com/fr_fr/ses/latest/dg/images/send-personalized-email-advanced-condition-nointerest.png)


## Création de fichiers partiels en ligne
<a name="send-personalized-email-advanced-inline-partials"></a>

Vous pouvez utiliser les fichiers partiels en ligne pour simplifier les modèles incluant des répétitions de chaîne. Par exemple, il est possible de créer un fichier partiel en ligne incluant le prénom du destinataire et, s'il est disponible, son nom de famille, en ajoutant le code suivant au début de votre modèle :

```
{{#* inline \"fullName\"}}{{firstName}}{{#if lastName}} {{lastName}}{{/if}}{{/inline}}\n
```

**Note**  
Le caractère de nouvelle ligne (`\n`) est nécessaire pour séparer le bloc `{{inline}}` du contenu de votre modèle. Le caractère de nouvelle ligne n'apparaît pas dans la sortie finale.

Une fois que vous avez créé le fichier partiel `fullName`, vous pouvez l'inclure n'importe où dans votre modèle en faisant précéder son nom du symbole > (supérieur à) suivi d'un espace, comme dans l'exemple suivant : `{{> fullName}}`. Les fichiers partiels en ligne ne sont pas transférés d'une partie à l'autre de l'e-mail. Par exemple, si vous voulez utiliser le même fichier partiel dans la version HTML et la version texte de l'e-mail, vous devez le définir dans les deux sections `HtmlPart` et `TextPart`.

Vous pouvez également utiliser les fichiers partiels en ligne lors de l'itération sur les tableaux. Vous pouvez utiliser le code suivant pour créer un modèle qui recourt au fichier partiel en ligne `fullName`. Dans cet exemple, le fichier partiel en ligne s'applique à la fois au nom du destinataire et à un tableau des autres noms :

```
{
  "Template": {
    "TemplateName": "Preferences3",
    "SubjectPart": "{{firstName}}'s Subscription Preferences",
    "HtmlPart": "{{#* inline \"fullName\"}}
                   {{firstName}}{{#if lastName}} {{lastName}}{{/if}}
                 {{/inline~}}\n
                 <h1>Hello {{> fullName}}!</h1>
                 <p>You have listed the following people as your friends:</p>
                 <ul>
                 {{#each friends}}
                   <li>{{> fullName}}</li>
                 {{/each}}</ul>",
    "TextPart": "{{#* inline \"fullName\"}}
                   {{firstName}}{{#if lastName}} {{lastName}}{{/if}}
                 {{/inline~}}\n
                 Hello {{> fullName}}! You have listed the following people 
                 as your friends:\n
                 {{#each friends}}
                   - {{> fullName}}\n
                 {{/each}}"
  }
}
```

**Important**  
Dans l'exemple de code précédent, les valeurs des attributs `HtmlPart` et `TextPart` comportent des sauts de ligne pour faciliter la lecture de l'exemple. Le fichier JSON de votre modèle ne peut pas contenir de sauts de ligne au sein de ces valeurs. Si vous copiez et collez cet exemple dans votre propre fichier JSON, supprimez les sauts de ligne et les espaces supplémentaires de ces sections.

# Gestion des modèles d'e-mail
<a name="send-personalized-email-manage-templates"></a>

Outre la [création de modèles d'e-mail](send-personalized-email-api.md), vous pouvez également utiliser l'API Amazon SES v2 pour mettre à jour ou supprimer des modèles existants, pour répertorier tous vos modèles existants ou pour afficher le contenu d'un modèle. 

Cette section contient les procédures d'utilisation du AWS CLI pour effectuer des tâches liées aux modèles SES.

**Note**  
Les procédures de cette section supposent aussi que vous avez déjà installé et configuré l' AWS CLI. Pour plus d'informations sur l'installation et la configuration du AWS CLI, consultez le [guide de AWS Command Line Interface l'utilisateur](https://docs.aws.amazon.com/cli/latest/userguide/).

## Affichage d'une liste de modèles d'e-mail
<a name="send-personalized-email-manage-templates-list"></a>

Vous pouvez utiliser le fonctionnement de l'API [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_ListEmailTemplate.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_ListEmailTemplate.html)SES v2 pour afficher la liste de tous vos modèles d'e-mails existants.

**Pour afficher une liste de modèles d'e-mail**
+ Sur la ligne de commande, entrez la commande suivante :

  ```
  aws sesv2 list-email-templates
  ```

  S'il existe des modèles d'e-mail dans votre compte SES dans la région actuelle, cette commande renvoie une réponse semblable à l'exemple suivant :

  ```
  {
      "TemplatesMetadata": [
          {
              "Name": "SpecialOffers",
              "CreatedTimestamp": "2020-08-05T16:04:12.640Z"
          },
          {
              "Name": "NewsAndUpdates",
              "CreatedTimestamp": "2019-10-03T20:03:34.574Z"
          }
      ]
  }
  ```

  Si vous n'avez pas créé de modèles, la commande renvoie un objet `TemplatesMetadata` sans membre.

## Affichage du contenu d'un modèle d'e-mail spécifique
<a name="send-personalized-email-manage-templates-get"></a>

Vous pouvez utiliser l'opération API [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_GetEmailTemplate.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_GetEmailTemplate.html)SES v2 pour afficher le contenu d'un modèle d'e-mail spécifique.

**Pour afficher le contenu d'un modèle d'e-mail**
+ Sur la ligne de commande, entrez la commande suivante :

  ```
  aws sesv2 get-email-template --template-name MyTemplate
  ```

  Dans la commande précédente, remplacez *MyTemplate* par le nom du modèle que vous souhaitez afficher.

  Si le nom du modèle que vous avez fourni correspond à un modèle existant dans votre compte SES, cette commande renvoie une réponse semblable à l'exemple suivant :

  ```
  {
      "Template": {
          "TemplateName": "TestMessage",
          "SubjectPart": "Amazon SES Test Message",
          "TextPart": "Hello! This is the text part of the message.",
          "HtmlPart": "<html>\n<body>\n<h2>Hello!</h2>\n<p>This is the HTML part of the message.</p></body>\n</html>"
      }
  }
  ```

  Si le nom du modèle que vous avez fourni ne correspond pas à un modèle existant dans votre compte SES, la commande renvoie une `NotFoundException` erreur.

## Suppression d'un modèle d'e-mail
<a name="send-personalized-email-manage-templates-delete"></a>

Vous pouvez utiliser l'opération API [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_DeleteEmailTemplate.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_DeleteEmailTemplate.html)SES v2 pour supprimer un modèle d'e-mail spécifique.

**Pour supprimer un modèle d'e-mail**
+ Sur la ligne de commande, entrez la commande suivante :

  ```
  aws sesv2 delete-email-template --template-name MyTemplate
  ```

  Dans la commande précédente, remplacez *MyTemplate* par le nom du modèle que vous souhaitez supprimer.

  Cette commande ne fournit aucune sortie. Vous pouvez vérifier que le modèle a été supprimé à l'aide de cette [GetTemplate](#send-personalized-email-manage-templates-get)opération.

## Mise à jour d'un modèle d'e-mail
<a name="send-personalized-email-manage-templates-update"></a>

Vous pouvez utiliser l'opération API [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_UpdateEmailTemplate.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_UpdateEmailTemplate.html)SES v2 pour mettre à jour un modèle d'e-mail existant. Par exemple, cette opération est utile si vous souhaitez modifier la ligne d'objet du modèle d'e-mail ou si vous devez modifier le corps du message lui-même.

**Pour mettre à jour un modèle d'e-mail**

1. Utilisez la commande `GetEmailTemplate` pour récupérer le modèle existant en entrant la commande suivante sur la ligne de commande :

   ```
   aws sesv2 get-email-template --template-name MyTemplate
   ```

   Dans la commande précédente, remplacez *MyTemplate* par le nom du modèle que vous souhaitez mettre à jour.

   Si le nom du modèle que vous avez fourni correspond à un modèle existant dans votre compte SES, cette commande renvoie une réponse semblable à l'exemple suivant :

   ```
   {
       "Template": {
           "TemplateName": "TestMessage",
           "SubjectPart": "Amazon SES Test Message",
           "TextPart": "Hello! This is the text part of the message.",
           "HtmlPart": "<html>\n<body>\n<h2>Hello!</h2>\n<p>This is the HTML part of the message.</p></body>\n</html>"
       }
   }
   ```

1. Dans un éditeur de texte, créez un fichier. Collez la sortie de la commande précédente dans le fichier.

1. Modifiez le modèle selon les besoins. Toutes les lignes que vous omettez sont supprimées du modèle. Par exemple, si vous souhaitez uniquement modifier le `SubjectPart` du modèle, vous devez toujours inclure les propriétés `TextPart` et `HtmlPart`.

   Lorsque vous avez terminé, enregistrez le fichier sous `update_template.json`.

1. Sur la ligne de commande, entrez la commande suivante :

   ```
   aws sesv2 update-email-template --cli-input-json file://path/to/update_template.json
   ```

   Dans la commande précédente, remplacez *path/to/update\$1template.json* par le chemin du `update_template.json` fichier que vous avez créé à l'étape précédente.

   Si le modèle est mis à jour avec succès, cette commande ne fournit aucune sortie. Vous pouvez vérifier que le modèle a été mis à jour en utilisant cette [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_GetEmailTemplate.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_GetEmailTemplate.html)opération.

   Si le modèle que vous avez spécifié n'existe pas, cette commande renvoie une erreur `TemplateDoesNotExist`. Si le modèle ne contient pas la propriété `TextPart` ou `HtmlPart` (ou les deux), cette commande renvoie une erreur `InvalidParameterValue`. 

# Envoi d'e-mails via Amazon SES à l'aide d'un AWS SDK
<a name="send-an-email-using-sdk-programmatically"></a>

Vous pouvez utiliser un AWS SDK pour envoyer des e-mails via Amazon SES. AWS SDKs sont disponibles pour plusieurs langages de programmation. Pour plus d'informations, veuillez consulter [Outils pour Amazon Web Services](https://aws.amazon.com/tools/#sdk).

## Conditions préalables
<a name="send-an-email-using-sdk-programmatically-prereqs"></a>

Les conditions préalables suivantes doivent être remplies pour compléter l'un des exemples de code de la section suivante :
+ Si vous ne l'avez pas déjà fait, suivez les étapes dans [Configuration d'Amazon Simple Email Service](setting-up.md).
+ **Vérifiez votre adresse e-mail avec Amazon SES** – Avant de pouvoir envoyer un e-mail à l'aide d'Amazon SES, vous devez vérifier que vous êtes propriétaire de l'adresse e-mail de l'expéditeur. Si votre compte est encore dans l'environnement de test (sandbox) Amazon SES, vous devez également vérifier l'adresse e-mail du destinataire. Nous vous recommandons d'utiliser la console Amazon SES pour vérifier les adresses e-mail. Pour de plus amples informations, veuillez consulter [Création d'une identité d'adresse e-mail](creating-identities.md#verify-email-addresses-procedure). 
+ **Obtenez vos AWS informations d'identification** —Vous avez besoin d'un identifiant de clé d' AWS accès et d'une clé d'accès AWS secrète pour accéder à Amazon SES à l'aide d'un SDK. Vous pouvez trouver vos informations d'identification via la page [Informations d'identification de sécurité](https://console.aws.amazon.com/iam/home?#security_credential) de la AWS Management Console. Pour en savoir plus sur les informations d'identification, consultez [Types d'informations d'identification Amazon SES](send-email-concepts-credentials.md).
+ **Création d'un fichier d'informations d'identification partagé** – Pour que l'exemple de code fourni dans cette section fonctionne correctement, vous devez créer un fichier d'informations d'identification partagé. Pour plus d'informations, consultez [Création d'un fichier d'informations d'identification partagé à utiliser lors de l'envoi d'e-mails via Amazon SES à l'aide d'un AWS SDK](create-shared-credentials-file.md).

## Exemples de code
<a name="send-an-email-using-sdk-programmatically-examples"></a>

**Important**  
Dans les didacticiels suivants, vous vous envoyez un e-mail afin de vérifier si vous l'avez reçu. Pour d'autres essais ou pour des tests de charge, utilisez le simulateur de boîte aux lettres Amazon SES. Les e-mails envoyés au simulateur de boîte aux lettres ne sont pas pris en compte dans votre quota d'envoi et vos taux de retours à l'expéditeur et de réclamations. Pour plus d'informations, consultez [Utilisation manuelle du simulateur de boîte aux lettres](send-an-email-from-console.md#send-email-simulator).

**Topics**

------
#### [ .NET ]

La procédure suivante montre comment envoyer un e-mail via Amazon SES à l'aide de [Visual Studio](https://www.visualstudio.com/) et du AWS SDK pour .NET.

Cette solution a été testée en utilisant les éléments suivants :
+ Microsoft Visual Studio Community 2017, version 15.4.0.
+ Microsoft .NET Framework version 4.6.1.
+ Le package AWSSDK .Core (version 3.3.19), installé à l'aide de. NuGet
+ Le AWSSDK. SimpleEmail package (version 3.3.6.1), installé à l'aide de. NuGet

**Avant de commencer, exécutez les tâches suivantes :**
+ **Installation de Visual Studio** —Visual Studio est disponible à l'adresse [https://www.visualstudio.com/](https://www.visualstudio.com/).

**Pour envoyer un e-mail à l'aide du AWS SDK pour .NET**

1. Créez un projet en procédant comme suit :

   1. Démarrez Visual Studio 2015.

   1. Dans le menu **File (Fichier)**, choisissez **New (Nouveau)**, **Project (Projet)**.

   1. Dans la fenêtre **New Project (Nouveau projet)**, dans le panneau de gauche, développez **Installed (Installations)**, puis **Visual C\$1**.

   1. Dans le panneau de droite, choisissez **Console App (.NET Framework)**.

   1. Pour **Name (Nom)**, tapez **AmazonSESSample**, puis choisissez **OK**.

1.  NuGet À utiliser pour inclure les packages Amazon SES dans votre solution en effectuant les étapes suivantes :

   1. Dans le volet **Explorateur de solutions**, cliquez avec le bouton droit sur votre projet, puis sélectionnez **Gérer les NuGet packages**.

   1. Dans l'SESSampleonglet **NuGet: Amazon**, choisissez **Browse**.

   1. Dans la zone de recherche, saisissez **AWSSDK.SimpleEmail**. 

   1. Choisissez le **AWSSDK. SimpleEmail**package, puis choisissez **Installer**.

   1. Dans la fenêtre **Preview Changes (Prévisualiser les modifications)**, choisissez **OK**.

1. Sous l'onglet **Program.cs**, collez le code suivant :

   ```
    1. using Amazon;
    2. using System;
    3. using System.Collections.Generic;
    4. using Amazon.SimpleEmail;
    5. using Amazon.SimpleEmail.Model;
    6. 
    7. namespace AmazonSESSample 
    8. {
    9.     class Program
   10.     {
   11.         // Replace sender@example.com with your "From" address.
   12.         // This address must be verified with Amazon SES.
   13.         static readonly string senderAddress = "sender@example.com";
   14. 
   15.         // Replace recipient@example.com with a "To" address. If your account
   16.         // is still in the sandbox, this address must be verified.
   17.         static readonly string receiverAddress = "recipient@example.com";
   18. 
   19.         // The configuration set to use for this email. If you do not want to use a
   20.         // configuration set, comment out the following property and the
   21.         // ConfigurationSetName = configSet argument below. 
   22.         static readonly string configSet = "ConfigSet";
   23. 
   24.         // The subject line for the email.
   25.         static readonly string subject = "Amazon SES test (AWS SDK pour .NET)";
   26. 
   27.         // The email body for recipients with non-HTML email clients.
   28.         static readonly string textBody = "Amazon SES Test (.NET)\r\n" 
   29.                                         + "This email was sent through Amazon SES "
   30.                                         + "using the AWS SDK pour .NET.";
   31.         
   32.         // The HTML body of the email.
   33.         static readonly string htmlBody = @"<html>
   34. <head></head>
   35. <body>
   36.   <h1>Amazon SES Test (SDK pour .NET)</h1>
   37.   <p>This email was sent with
   38.     <a href='https://aws.amazon.com/ses/'>Amazon SES</a> using the
   39.     <a href='https://aws.amazon.com/sdk-for-net/'> AWS SDK pour .NET</a>.</p>
   40. </body>
   41. </html>";
   42. 
   43.         static void Main(string[] args)
   44.         {
   45.             // Replace USWest2 with the AWS Region you're using for Amazon SES.
   46.             // Acceptable values are EUWest1, USEast1, and USWest2.
   47.             using (var client = new AmazonSimpleEmailServiceClient(RegionEndpoint.USWest2))
   48.             {
   49.                 var sendRequest = new SendEmailRequest
   50.                 {
   51.                     Source = senderAddress,
   52.                     Destination = new Destination
   53.                     {
   54.                         ToAddresses =
   55.                         new List<string> { receiverAddress }
   56.                     },
   57.                     Message = new Message
   58.                     {
   59.                         Subject = new Content(subject),
   60.                         Body = new Body
   61.                         {
   62.                             Html = new Content
   63.                             {
   64.                                 Charset = "UTF-8",
   65.                                 Data = htmlBody
   66.                             },
   67.                             Text = new Content
   68.                             {
   69.                                 Charset = "UTF-8",
   70.                                 Data = textBody
   71.                             }
   72.                         }
   73.                     },
   74.                     // If you are not using a configuration set, comment
   75.                     // or remove the following line 
   76.                     ConfigurationSetName = configSet
   77.                 };
   78.                 try
   79.                 {
   80.                     Console.WriteLine("Sending email using Amazon SES...");
   81.                     var response = client.SendEmail(sendRequest);
   82.                     Console.WriteLine("The email was sent successfully.");
   83.                 }
   84.                 catch (Exception ex)
   85.                 {
   86.                     Console.WriteLine("The email was not sent.");
   87.                     Console.WriteLine("Error message: " + ex.Message);
   88. 
   89.                 }
   90.             }
   91. 
   92.             Console.Write("Press any key to continue...");
   93.             Console.ReadKey();
   94.         }
   95.     }
   96. }
   ```

1. Dans l'éditeur de code, procédez comme suit :
   + Remplacez *sender@example.com* par l'adresse e-mail « De : ». Cette adresse doit être vérifiée. Pour de plus amples informations, veuillez consulter [Identités vérifiées dans Amazon SES](verify-addresses-and-domains.md).
   + Remplacez *recipient@example.com* par l'adresse « À : ». Si votre compte est encore dans l'environnement de test (sandbox), cette adresse doit également être vérifiée.
   + Remplacez *ConfigSet* par le nom du jeu de configuration à utiliser lors de l'envoi de cet e-mail.
   + *USWest2*Remplacez-le par le nom du Région AWS point de terminaison que vous utilisez pour envoyer des e-mails via Amazon SES. Pour connaître la liste des régions dans lesquelles Amazon SES est disponible, consultez [Amazon Simple Email Service (Amazon SES)](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region) dans le document *Références générales AWS*.

   Lorsque vous avez terminé, enregistrez `Program.cs`.

1. Concevez et exécutez l'application en effectuant les étapes suivantes :

   1. Dans le menu **Build (Créer)**, choisissez **Build Solution (Créer une solution)**.

   1. Dans le menu **Débogage**, choisissez **Démarrer le débogage**. Une fenêtre de la console s'affiche.

1. Vérifiez la sortie de la console. Si l'envoi de l'e-mail aboutit, la console affiche « `The email was sent successfully.` » 

1. Si l'e-mail a été envoyé avec succès, connectez-vous au client de messagerie de l'adresse du destinataire. Vous verrez le message que vous avez envoyé.

------
#### [ Java ]

La procédure suivante explique comment utiliser l'[IDE Eclipse pour les développeurs Java EE](http://www.eclipse.org/), [AWS Toolkit for Eclipse](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/welcome.html)créer un projet AWS SDK et modifier le code Java pour envoyer un e-mail via Amazon SES. 

**Avant de commencer, exécutez les tâches suivantes :**
+ **Installer Eclipse** – Eclipse est disponible à l'adresse [https://www.eclipse.org/downloads](https://www.eclipse.org/downloads). Le code présenté dans ce didacticiel a été testé avec Eclipse Neon.3 (version 4.6.3) et la version 1.8 de l'environnement d'exécution Java.
+ **Installez le AWS Toolkit for Eclipse—Les** instructions pour ajouter le AWS Toolkit for Eclipse à votre installation Eclipse sont disponibles sur [https://aws.amazon.com/eclipse](https://aws.amazon.com/eclipse). Le code inclus dans ce didacticiel a été testé avec la version 2.3.1 du kit AWS Toolkit for Eclipse.

**Pour envoyer un e-mail à l'aide du AWS SDK pour Java**

1. Créez un projet AWS Java dans Eclipse en effectuant les étapes suivantes :

   1. Démarrez Eclipse.

   1. Dans le menu **File (Fichier)**, sélectionnez **New (Nouveau)**, puis **Other (Autre)**. Dans la fenêtre **New (Nouveau)**, développez le dossier **AWS**, puis choisissez **AWS Java Project (Projet Java AWS )**.

   1. Dans la boîte de dialogue **Nouveau projet AWS Java**, procédez comme suit :

      1. Pour **Project name (Nom du projet)**, tapez un nom de projet.

      1. Sous **AWS SDK pour Java Exemples**, sélectionnez **Amazon Simple Email Service JavaMail Sample**.

      1. Choisissez **Finish (Terminer)**.

1. Dans le panneau **Package Explorer (Explorateur de paquets)** d'Eclipse, développez votre projet.

1. Sous votre projet, développez le dossier `src/main/java`, développez le dossier `com.amazon.aws.samples`, puis cliquez deux fois sur `AmazonSESSample.java`.

1. Remplacez la totalité du contenu de `AmazonSESSample.java` par le code suivant :

   ```
    1. package com.amazonaws.samples;
    2. 
    3. import java.io.IOException;
    4. 
    5. import com.amazonaws.regions.Regions;
    6. import com.amazonaws.services.simpleemail.AmazonSimpleEmailService;
    7. import com.amazonaws.services.simpleemail.AmazonSimpleEmailServiceClientBuilder;
    8. import com.amazonaws.services.simpleemail.model.Body;
    9. import com.amazonaws.services.simpleemail.model.Content;
   10. import com.amazonaws.services.simpleemail.model.Destination;
   11. import com.amazonaws.services.simpleemail.model.Message;
   12. import com.amazonaws.services.simpleemail.model.SendEmailRequest; 
   13. 
   14. public class AmazonSESSample {
   15. 
   16.   // Replace sender@example.com with your "From" address.
   17.   // This address must be verified with Amazon SES.
   18.   static final String FROM = "sender@example.com";
   19. 
   20.   // Replace recipient@example.com with a "To" address. If your account
   21.   // is still in the sandbox, this address must be verified.
   22.   static final String TO = "recipient@example.com";
   23. 
   24.   // The configuration set to use for this email. If you do not want to use a
   25.   // configuration set, comment the following variable and the 
   26.   // .withConfigurationSetName(CONFIGSET); argument below.
   27.   static final String CONFIGSET = "ConfigSet";
   28. 
   29.   // The subject line for the email.
   30.   static final String SUBJECT = "Amazon SES test (AWS SDK pour Java)";
   31.   
   32.   // The HTML body for the email.
   33.   static final String HTMLBODY = "<h1>Amazon SES test (AWS SDK pour Java)</h1>"
   34.       + "<p>This email was sent with <a href='https://aws.amazon.com/ses/'>"
   35.       + "Amazon SES</a> using the <a href='https://aws.amazon.com/sdk-for-java/'>" 
   36.       + "AWS SDK for Java</a>";
   37. 
   38.   // The email body for recipients with non-HTML email clients.
   39.   static final String TEXTBODY = "This email was sent through Amazon SES "
   40.       + "using the AWS SDK pour Java.";
   41. 
   42.   public static void main(String[] args) throws IOException {
   43. 
   44.     try {
   45.       AmazonSimpleEmailService client = 
   46.           AmazonSimpleEmailServiceClientBuilder.standard()
   47.           // Replace US_WEST_2 with the AWS Region you're using for
   48.           // Amazon SES.
   49.             .withRegion(Regions.US_WEST_2).build();
   50.       SendEmailRequest request = new SendEmailRequest()
   51.           .withDestination(
   52.               new Destination().withToAddresses(TO))
   53.           .withMessage(new Message()
   54.               .withBody(new Body()
   55.                   .withHtml(new Content()
   56.                       .withCharset("UTF-8").withData(HTMLBODY))
   57.                   .withText(new Content()
   58.                       .withCharset("UTF-8").withData(TEXTBODY)))
   59.               .withSubject(new Content()
   60.                   .withCharset("UTF-8").withData(SUBJECT)))
   61.           .withSource(FROM)
   62.           // Comment or remove the next line if you are not using a
   63.           // configuration set
   64.           .withConfigurationSetName(CONFIGSET);
   65.       client.sendEmail(request);
   66.       System.out.println("Email sent!");
   67.     } catch (Exception ex) {
   68.       System.out.println("The email was not sent. Error message: " 
   69.           + ex.getMessage());
   70.     }
   71.   }
   72. }
   ```

1. Dans `AmazonSESSample.java`, remplacez les éléments suivants par vos propres valeurs :
**Important**  
Les adresses e-mail sont sensibles à la casse. Assurez-vous que les adresses sont exactement les mêmes que celles que vous avez vérifiées.
   + `SENDER@EXAMPLE.COM` – Remplacez par votre adresse e-mail « From ». Vous devez vérifier cette adresse avant d'exécuter ce programme. Pour plus d'informations, consultez [Identités vérifiées dans Amazon SES](verify-addresses-and-domains.md).
   + `RECIPIENT@EXAMPLE.COM` – Remplacez par votre adresse e-mail « To ». Si votre compte est encore dans l'environnement de test (sandbox), vous devez vérifier cette adresse avant de l'utiliser. Pour plus d'informations, consultez [Demande d'accès à la production (sortie du sandbox d'Amazon SES)](request-production-access.md).
   + **(Facultatif) `us-west-2`** – Si vous souhaitez utiliser Amazon SES dans une région autre que USA Ouest (Oregon), remplacez ceci par la région que vous souhaitez utiliser. Pour connaître la liste des régions dans lesquelles Amazon SES est disponible, consultez [Amazon Simple Email Service (Amazon SES)](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region) dans le document *Références générales AWS*.

1. Enregistrez `AmazonSESSample.java`.

1. Pour créer le projet, choisissez **Project (Projet)**, puis **Build Project (Créer un projet)**.
**Note**  
Si cette option est désactivée, la génération automatique est peut-être activée. Dans ce cas, ignorez cette étape.

1. Pour démarrer le programme et envoyer l'e-mail, choisissez **Run (Exécuter)**, puis à nouveau **Run (Exécuter)**.

1. Vérifiez la sortie du panneau de la console dans Eclipse. Si l'envoi de l'e-mail aboutit, la console affiche «`Email sent!`». Dans le cas contraire, elle affiche un message d'erreur.

1. Si l'e-mail a été envoyé avec succès, connectez-vous au client de messagerie de l'adresse du destinataire. Vous verrez le message que vous avez envoyé.

------
#### [ PHP ]

Cette rubrique montre comment utiliser [AWS SDK pour PHP](https://aws.amazon.com/sdk-for-php/) pour envoyer un e-mail via Amazon SES. 

**Avant de commencer, exécutez les tâches suivantes :**
+ **Installer PHP** – PHP est disponible à l'adresse [http://php.net/downloads.php](http://php.net/downloads.php). Ce didacticiel nécessite PHP version 5.5 ou ultérieure. Après avoir installé PHP, ajoutez le chemin d'accès à PHP dans vos variables d'environnement afin de pouvoir exécuter PHP à partir de n'importe quelle invite de commande. Le code inclus dans ce didacticiel a été testé avec PHP 7.2.7.
+ **Installez la AWS SDK pour PHP version 3** —Pour les instructions de téléchargement et d'installation, consultez la [AWS SDK pour PHP documentation](https://docs.aws.amazon.com/aws-sdk-php/v3/guide/getting-started/installation.html). Le code inclus dans ce didacticiel a été testé avec la version 3.64.13 du kit SDK. 

**Pour envoyer un e-mail via Amazon SES à l'aide du AWS SDK pour PHP**

1. Dans un éditeur de texte, créez un fichier nommé `amazon-ses-sample.php`. Collez le code suivant :

   ```
    1. <?php
    2. 
    3. // If necessary, modify the path in the require statement below to refer to the 
    4. // location of your Composer autoload.php file.
    5. require 'vendor/autoload.php';
    6. 
    7. use Aws\Ses\SesClient;
    8. use Aws\Exception\AwsException;
    9. 
   10. // Create an SesClient. Change the value of the region parameter if you're 
   11. // using an AWS Region other than US West (Oregon). Change the value of the
   12. // profile parameter if you want to use a profile in your credentials file
   13. // other than the default.
   14. $SesClient = new SesClient([
   15.     'profile' => 'default',
   16.     'version' => '2010-12-01',
   17.     'region'  => 'us-west-2'
   18. ]);
   19. 
   20. // Replace sender@example.com with your "From" address.
   21. // This address must be verified with Amazon SES.
   22. $sender_email = 'sender@example.com';
   23. 
   24. // Replace these sample addresses with the addresses of your recipients. If
   25. // your account is still in the sandbox, these addresses must be verified.
   26. $recipient_emails = ['recipient1@example.com','recipient2@example.com'];
   27. 
   28. // Specify a configuration set. If you do not want to use a configuration
   29. // set, comment the following variable, and the
   30. // 'ConfigurationSetName' => $configuration_set argument below.
   31. $configuration_set = 'ConfigSet';
   32. 
   33. $subject = 'Amazon SES test (AWS SDK pour PHP)';
   34. $plaintext_body = 'This email was sent with Amazon SES using the AWS SDK for PHP.' ;
   35. $html_body =  '<h1>AWS Amazon Simple Email Service Test Email</h1>'.
   36.               '<p>This email was sent with <a href="https://aws.amazon.com/ses/">'.
   37.               'Amazon SES</a> using the <a href="https://aws.amazon.com/sdk-for-php/">'.
   38.               'AWS SDK pour PHP</a>.</p>';
   39. $char_set = 'UTF-8';
   40. 
   41. try {
   42.     $result = $SesClient->sendEmail([
   43.         'Destination' => [
   44.             'ToAddresses' => $recipient_emails,
   45.         ],
   46.         'ReplyToAddresses' => [$sender_email],
   47.         'Source' => $sender_email,
   48.         'Message' => [
   49.           'Body' => [
   50.               'Html' => [
   51.                   'Charset' => $char_set,
   52.                   'Data' => $html_body,
   53.               ],
   54.               'Text' => [
   55.                   'Charset' => $char_set,
   56.                   'Data' => $plaintext_body,
   57.               ],
   58.           ],
   59.           'Subject' => [
   60.               'Charset' => $char_set,
   61.               'Data' => $subject,
   62.           ],
   63.         ],
   64.         // If you aren't using a configuration set, comment or delete the
   65.         // following line
   66.         'ConfigurationSetName' => $configuration_set,
   67.     ]);
   68.     $messageId = $result['MessageId'];
   69.     echo("Email sent! Message ID: $messageId"."\n");
   70. } catch (AwsException $e) {
   71.     // output error message if fails
   72.     echo $e->getMessage();
   73.     echo("The email was not sent. Error message: ".$e->getAwsErrorMessage()."\n");
   74.     echo "\n";
   75. }
   ```

1. Dans `amazon-ses-sample.php`, remplacez les éléments suivants par vos propres valeurs :
   + **`path_to_sdk_inclusion`**—Remplacez par le chemin requis pour l'inclure AWS SDK pour PHP dans le programme. Pour en savoir plus, consultez la [documentation AWS SDK pour PHP](https://docs.aws.amazon.com/aws-sdk-php/v3/guide/getting-started/basic-usage.html). 
   + **`sender@example.com`** – Remplacez par une adresse e-mail que vous avez vérifiée avec Amazon SES. Pour plus d'informations, consultez [Identités vérifiées](verify-addresses-and-domains.md). Les adresses e-mail d'Amazon SES sont sensibles à la casse. Assurez-vous que l'adresse que vous saisissez est exactement la même que celle que vous avez vérifiée.
   + **`recipient1@example.com`, `recipient2@example.com`** – Remplacez par les adresses des destinataires. Si votre compte est encore dans l'environnement de test (sandbox), les adresses de destination doivent également être vérifiées. Pour plus d'informations, consultez [Demande d'accès à la production (sortie du sandbox d'Amazon SES)](request-production-access.md). Assurez-vous que l'adresse que vous saisissez est exactement la même que celle que vous avez vérifiée.
   + **(Facultatif) `ConfigSet`**– Si vous souhaitez utiliser un jeu de configurations lors de l'envoi de cet e-mail, remplacez cette valeur par le nom du jeu de configurations. Pour en savoir plus sur les jeux de configuration, consultez [Utilisation des jeux de configuration dans Amazon SES](using-configuration-sets.md).
   + **(Facultatif) `us-west-2`** — Si vous souhaitez utiliser Amazon SES dans une région autre que USA Ouest (Oregon), remplacez ceci par la région que vous souhaitez utiliser. Pour connaître la liste des régions dans lesquelles Amazon SES est disponible, consultez [Amazon Simple Email Service (Amazon SES)](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region) dans le document *Références générales AWS*.

1. Enregistrez `amazon-ses-sample.php`.

1. Pour exécuter le programme, ouvrez une invite de commande dans le même répertoire que `amazon-ses-sample.php`, puis entrez la commande suivante :

   ```
   $ php amazon-ses-sample.php
   ```

1. Vérifiez la sortie. Si l'envoi de l'e-mail aboutit, la console affiche «`Email sent!`». Dans le cas contraire, elle affiche un message d'erreur.
**Note**  
Si une erreur « cURL error 60: SSL certificate problem » se produit lorsque vous exécutez le programme, téléchargez la dernière solution groupée d'autorité de certification (CA), comme décrit dans la [documentation AWS SDK pour PHP](https://docs.aws.amazon.com/aws-sdk-php/v3/guide/faq.html#what-do-i-do-about-a-curl-ssl-certificate-error). Ensuite, dans `amazon-ses-sample.php`, ajoutez les lignes suivantes dans le tableau `SesClient::factory`, remplacez `path_of_certs` par le chemin d'accès à la solution groupée d'autorité de certification (CA) téléchargé, et exécutez à nouveau le programme.  

   ```
   1. 'http' => [
   2.    'verify' => 'path_of_certs\ca-bundle.crt'
   3. ]
   ```

1. Connectez-vous au client de messagerie de l'adresse du destinataire. Vous verrez le message que vous avez envoyé.

------
#### [ Ruby ]

Cette rubrique montre comment utiliser [AWS SDK pour Ruby](https://aws.amazon.com/sdk-for-ruby/) pour envoyer un e-mail via Amazon SES. 

**Avant de commencer, exécutez les tâches suivantes :**
+ **Installer Ruby** —Ruby est disponible sur [https://www.ruby-lang. org/en/downloads](https://www.ruby-lang.org/en/downloads/)/. Le code inclus dans ce didacticiel a été testé avec Ruby 1.9.3. Après avoir installé Ruby, ajoutez le chemin d'accès à Ruby dans vos variables d'environnement afin de pouvoir exécuter Ruby à partir de n'importe quelle invite de commande.
+ **Installez le AWS SDK pour Ruby** —Pour obtenir des instructions de téléchargement et d'installation, consultez la section [Installation du AWS SDK pour Ruby](https://docs.aws.amazon.com/sdk-for-ruby/latest/developer-guide/setup-install.html) dans le *guide du AWS SDK pour Ruby développeur*. L'exemple de code inclus dans ce didacticiel a été testé avec la version 2.9.36 du kit AWS SDK pour Ruby.
+ **Création d'un fichier d'informations d'identification partagé** – Pour que l'exemple de code fourni dans cette section fonctionne correctement, vous devez créer un fichier d'informations d'identification partagé. Pour de plus amples informations, veuillez consulter [Création d'un fichier d'informations d'identification partagé à utiliser lors de l'envoi d'e-mails via Amazon SES à l'aide d'un AWS SDK](create-shared-credentials-file.md).

**Pour envoyer un e-mail via Amazon SES à l'aide du AWS SDK pour Ruby**

1. Dans un éditeur de texte, créez un fichier nommé `amazon-ses-sample.rb`. Collez le code suivant dans le fichier :

   ```
    1. require 'aws-sdk'
    2. 
    3. # Replace sender@example.com with your "From" address.
    4. # This address must be verified with Amazon SES.
    5. sender = "sender@example.com"
    6. 
    7. # Replace recipient@example.com with a "To" address. If your account 
    8. # is still in the sandbox, this address must be verified.
    9. recipient = "recipient@example.com"
   10. 
   11. # Specify a configuration set. If you do not want to use a configuration
   12. # set, comment the following variable and the 
   13. # configuration_set_name: configsetname argument below. 
   14. configsetname = "ConfigSet"
   15.   
   16. # Replace us-west-2 with the AWS Region you're using for Amazon SES.
   17. awsregion = "us-west-2"
   18. 
   19. # The subject line for the email.
   20. subject = "Amazon SES test (AWS SDK pour Ruby)"
   21. 
   22. # The HTML body of the email.
   23. htmlbody =
   24.   '<h1>Amazon SES test (AWS SDK pour Ruby)</h1>'\
   25.   '<p>This email was sent with <a href="https://aws.amazon.com/ses/">'\
   26.   'Amazon SES</a> using the <a href="https://aws.amazon.com/sdk-for-ruby/">'\
   27.   'AWS SDK pour Ruby</a>.'
   28. 
   29. # The email body for recipients with non-HTML email clients.  
   30. textbody = "This email was sent with Amazon SES using the AWS SDK pour Ruby."
   31. 
   32. # Specify the text encoding scheme.
   33. encoding = "UTF-8"
   34. 
   35. # Create a new SES resource and specify a region
   36. ses = Aws::SES::Client.new(region: awsregion)
   37. 
   38. # Try to send the email.
   39. begin
   40. 
   41.   # Provide the contents of the email.
   42.   resp = ses.send_email({
   43.     destination: {
   44.       to_addresses: [
   45.         recipient,
   46.       ],
   47.     },
   48.     message: {
   49.       body: {
   50.         html: {
   51.           charset: encoding,
   52.           data: htmlbody,
   53.         },
   54.         text: {
   55.           charset: encoding,
   56.           data: textbody,
   57.         },
   58.       },
   59.       subject: {
   60.         charset: encoding,
   61.         data: subject,
   62.       },
   63.     },
   64.   source: sender,
   65.   # Comment or remove the following line if you are not using 
   66.   # a configuration set
   67.   configuration_set_name: configsetname,
   68.   })
   69.   puts "Email sent!"
   70. 
   71. # If something goes wrong, display an error message.
   72. rescue Aws::SES::Errors::ServiceError => error
   73.   puts "Email not sent. Error message: #{error}"
   74. 
   75. end
   ```

1. Dans `amazon-ses-sample.rb`, remplacez les éléments suivants par vos propres valeurs :
   + **`sender@example.com`** – Remplacez par une adresse e-mail que vous avez vérifiée avec Amazon SES. Pour plus d'informations, consultez [Identités vérifiées](verify-addresses-and-domains.md). Les adresses e-mail d'Amazon SES sont sensibles à la casse. Assurez-vous que l'adresse que vous saisissez est exactement la même que celle que vous avez vérifiée.
   + **`recipient@example.com`**—Remplacez par l'adresse du destinataire. Si votre compte est encore dans l'environnement de test (sandbox), vous devez vérifier cette adresse avant de l'utiliser. Pour plus d'informations, consultez [Demande d'accès à la production (sortie du sandbox d'Amazon SES)](request-production-access.md). Assurez-vous que l'adresse que vous saisissez est exactement la même que celle que vous avez vérifiée.
   + **(Facultatif) `us-west-2`** — Si vous souhaitez utiliser Amazon SES dans une région autre que USA Ouest (Oregon), remplacez ceci par la région que vous souhaitez utiliser. Pour connaître la liste des régions dans lesquelles Amazon SES est disponible, consultez [Amazon Simple Email Service (Amazon SES)](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region) dans le document *Références générales AWS*.

1. Enregistrez `amazon-ses-sample.rb`.

1. Pour exécuter le programme, ouvrez une invite de commande dans le même répertoire que `amazon-ses-sample.rb`, puis entrez **ruby amazon-ses-sample.rb**

1. Vérifiez la sortie. Si l'envoi de l'e-mail aboutit, la console affiche «`Email sent!`». Dans le cas contraire, elle affiche un message d'erreur.

1. Connectez-vous au client de messagerie de l'adresse du destinataire. Vous trouverez le message que vous avez envoyé.

------
#### [ Python ]

Cette rubrique montre comment utiliser [AWS SDK pour Python (Boto)](https://aws.amazon.com/sdk-for-python/) pour envoyer un e-mail via Amazon SES. 

**Avant de commencer, exécutez les tâches suivantes :**
+ **Vérifiez votre adresse e-mail avec Amazon SES** – Avant de pouvoir envoyer un e-mail à l'aide d'Amazon SES, vous devez vérifier que vous êtes propriétaire de l'adresse e-mail de l'expéditeur. Si votre compte est encore dans l'environnement de test (sandbox) Amazon SES, vous devez également vérifier l'adresse e-mail du destinataire. Nous vous recommandons d'utiliser la console Amazon SES pour vérifier les adresses e-mail. Pour de plus amples informations, veuillez consulter [Création d'une identité d'adresse e-mail](creating-identities.md#verify-email-addresses-procedure). 
+ **Obtenez vos AWS informations d'identification** —Vous avez besoin d'un identifiant de clé d' AWS accès et d'une clé d'accès AWS secrète pour accéder à Amazon SES à l'aide d'un SDK. Vous pouvez trouver vos informations d'identification via la page [Informations d'identification de sécurité](https://console.aws.amazon.com/iam/home?#security_credential) de la AWS Management Console. Pour en savoir plus sur les informations d'identification, consultez [Types d'informations d'identification Amazon SES](send-email-concepts-credentials.md).
+ **Installer Python —Python** est disponible sur [https://www.python.org/downloads/](https://www.python.org/downloads/). Le code inclus dans ce didacticiel a été testé avec Python 2.7.6 et Python 3.6.1. Après avoir installé Python, ajoutez le chemin d'accès à Python dans vos variables d'environnement afin de pouvoir exécuter Python à partir de n'importe quelle invite de commande.
+ **Installez le AWS SDK pour Python (Boto)** —Pour obtenir des instructions de téléchargement et d'installation, consultez la [AWS SDK pour Python (Boto) documentation](https://boto3.readthedocs.io/en/latest/guide/quickstart.html#installation). L'exemple de code inclus dans ce didacticiel a été testé avec la version 1.4.4 du kit SDK pour Python.

**Pour envoyer un e-mail via Amazon SES à l'aide du kit SDK pour Python**

1. Dans un éditeur de texte, créez un fichier nommé `amazon-ses-sample.py`. Collez le code suivant dans le fichier :

   ```
    1. import boto3
    2. from botocore.exceptions import ClientError
    3. 
    4. # Replace sender@example.com with your "From" address.
    5. # This address must be verified with Amazon SES.
    6. SENDER = "Sender Name <sender@example.com>"
    7. 
    8. # Replace recipient@example.com with a "To" address. If your account 
    9. # is still in the sandbox, this address must be verified.
   10. RECIPIENT = "recipient@example.com"
   11. 
   12. # Specify a configuration set. If you do not want to use a configuration
   13. # set, comment the following variable, and the 
   14. # ConfigurationSetName=CONFIGURATION_SET argument below.
   15. CONFIGURATION_SET = "ConfigSet"
   16. 
   17. # If necessary, replace us-west-2 with the AWS Region you're using for Amazon SES.
   18. AWS_REGION = "us-west-2"
   19. 
   20. # The subject line for the email.
   21. SUBJECT = "Amazon SES Test (SDK for Python)"
   22. 
   23. # The email body for recipients with non-HTML email clients.
   24. BODY_TEXT = ("Amazon SES Test (Python)\r\n"
   25.              "This email was sent with Amazon SES using the "
   26.              "AWS SDK pour Python (Boto)."
   27.             )
   28.             
   29. # The HTML body of the email.
   30. BODY_HTML = """<html>
   31. <head></head>
   32. <body>
   33.   <h1>Amazon SES Test (SDK for Python)</h1>
   34.   <p>This email was sent with
   35.     <a href='https://aws.amazon.com/ses/'>Amazon SES</a> using the
   36.     <a href='https://aws.amazon.com/sdk-for-python/'> AWS SDK pour Python (Boto)</a>.</p>
   37. </body>
   38. </html>
   39.             """            
   40. 
   41. # The character encoding for the email.
   42. CHARSET = "UTF-8"
   43. 
   44. # Create a new SES resource and specify a region.
   45. client = boto3.client('ses',region_name=AWS_REGION)
   46. 
   47. # Try to send the email.
   48. try:
   49.     #Provide the contents of the email.
   50.     response = client.send_email(
   51.         Destination={
   52.             'ToAddresses': [
   53.                 RECIPIENT,
   54.             ],
   55.         },
   56.         Message={
   57.             'Body': {
   58.                 'Html': {
   59.                     'Charset': CHARSET,
   60.                     'Data': BODY_HTML,
   61.                 },
   62.                 'Text': {
   63.                     'Charset': CHARSET,
   64.                     'Data': BODY_TEXT,
   65.                 },
   66.             },
   67.             'Subject': {
   68.                 'Charset': CHARSET,
   69.                 'Data': SUBJECT,
   70.             },
   71.         },
   72.         Source=SENDER,
   73.         # If you are not using a configuration set, comment or delete the
   74.         # following line
   75.         ConfigurationSetName=CONFIGURATION_SET,
   76.     )
   77. # Display an error if something goes wrong.	
   78. except ClientError as e:
   79.     print(e.response['Error']['Message'])
   80. else:
   81.     print("Email sent! Message ID:"),
   82.     print(response['MessageId'])
   ```

1. Dans `amazon-ses-sample.py`, remplacez les éléments suivants par vos propres valeurs :
   + **`sender@example.com`** – Remplacez par une adresse e-mail que vous avez vérifiée avec Amazon SES. Pour plus d'informations, consultez [Identités vérifiées](verify-addresses-and-domains.md). Les adresses e-mail d'Amazon SES sont sensibles à la casse. Assurez-vous que l'adresse que vous saisissez est exactement la même que celle que vous avez vérifiée.
   + **`recipient@example.com`**—Remplacez par l'adresse du destinataire. Si votre compte est encore dans l'environnement de test (sandbox), vous devez vérifier cette adresse avant de l'utiliser. Pour plus d'informations, consultez [Demande d'accès à la production (sortie du sandbox d'Amazon SES)](request-production-access.md). Assurez-vous que l'adresse que vous saisissez est exactement la même que celle que vous avez vérifiée.
   + **(Facultatif) `us-west-2`** — Si vous souhaitez utiliser Amazon SES dans une région autre que USA Ouest (Oregon), remplacez ceci par la région que vous souhaitez utiliser. Pour connaître la liste des régions dans lesquelles Amazon SES est disponible, consultez [Amazon Simple Email Service (Amazon SES)](https://docs.aws.amazon.com/general/latest/gr/rande.html#ses_region) dans le document *Références générales AWS*.

1. Enregistrez `amazon-ses-sample.py`.

1. Pour exécuter le programme, ouvrez une invite de commande dans le même répertoire que `amazon-ses-sample.py`, puis entrez **python amazon-ses-sample.py**.

1. Vérifiez la sortie. Si l'envoi de l'e-mail aboutit, la console affiche «`Email sent!`». Dans le cas contraire, elle affiche un message d'erreur.

1. Connectez-vous au client de messagerie de l'adresse du destinataire. Vous verrez le message que vous avez envoyé.

------

# Création d'un fichier d'informations d'identification partagé à utiliser lors de l'envoi d'e-mails via Amazon SES à l'aide d'un AWS SDK
<a name="create-shared-credentials-file"></a>

La procédure suivante montre comment créer un fichier d'informations d'identification partagées dans votre répertoire. Pour que l'exemple de code du kit de développement logiciel (SDK) fonctionne correctement, vous devez créer ce fichier.

1. Dans un éditeur de texte, créez un fichier. Dans le fichier, collez le code suivant :

   ```
   1. [default]
   2. aws_access_key_id = YOUR_AWS_ACCESS_KEY_ID
   3. aws_secret_access_key = YOUR_AWS_SECRET_ACCESS_KEY
   ```

1. Dans le fichier texte que vous venez de créer, remplacez-le `YOUR_AWS_ACCESS_KEY` par votre identifiant de clé d' AWS accès unique et remplacez-le `YOUR_AWS_SECRET_ACCESS_KEY` par votre clé d'accès AWS secrète unique.

1. Enregistrez le fichier. Le tableau suivant indique l'emplacement et le nom de fichier corrects pour votre système d'exploitation.    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/ses/latest/dg/create-shared-credentials-file.html)
**Important**  
N'ajoutez pas d'extension de fichier lors de le registre du fichier des informations d'identification.

# Encodages de contenu pris en charge par Amazon SES
<a name="content-encodings"></a>

Les éléments suivants sont fournis à titre de référence.

Amazon SES prend en charge les codages de contenu suivants :
+ `deflate`
+ `gzip`
+ `identity`

Amazon SES prend également en charge le format d'en-tête Accept-Encoding suivant, conformément à la spécification [RFC 7231](https://tools.ietf.org/html/rfc7231#section-5.3.4) :
+ `Accept-Encoding:deflate,gzip`
+ `Accept-Encoding:`
+ `Accept-Encoding:*`
+ `Accept-Encoding:deflate;q=0.5,gzip;q=1.0`
+ `Accept-Encoding:gzip;q=1.0,identity;q=0.5,*;q=0`

# Amazon SES et protocoles de sécurité
<a name="security-protocols"></a>

Cette rubrique décrit les protocoles de sécurité que vous pouvez utiliser lorsque vous vous connectez à Amazon SES, mais aussi lorsqu'Amazon SES remet un e-mail à un récepteur.

## Expéditeur d'e-mails à destination d'Amazon SES
<a name="security-client-to-ses"></a>

Le protocole de sécurité que vous utilisez pour vous connecter à Amazon SES varie selon que vous utilisez l'API Amazon SES ou l'interface SMTP Amazon SES, comme décrit ensuite.

### HTTPS
<a name="security-client-to-ses-api"></a>

Si vous utilisez l'API Amazon SES (directement ou via un AWS SDK), toutes les communications sont cryptées par TLS via le point de terminaison HTTPS Amazon SES. Le point de terminaison HTTPS Amazon SES prend en charge TLS 1.2 et TLS 1.3.

### Interface SMTP
<a name="security-client-to-ses-smtp"></a>

Si vous accédez à Amazon SES via l'interface SMTP, vous devez chiffrer votre connexion à l'aide du protocole TLS (Transport Layer Security). Notez que TLS est souvent désigné sous le nom de son prédécesseur, le protocole SSL (Secure Sockets Layer).

Amazon SES prend en charge deux mécanismes d'établissement d'une connexion à chiffrement TLS : STARTTLS et TLS Wrapper.
+ **STARTTLS** – STARTTLS permet de mettre à niveau une connexion non chiffrée en connexion chiffrée. Il existe différentes versions de STARTTLS selon les protocoles. La version SMTP est définie dans [RFC 3207](https://www.ietf.org/rfc/rfc3207.txt). Pour les connexions STARTTLS, Amazon SES prend en charge les protocoles TLS 1.2 et TLS 1.3.
+ **TLS Wrapper** – TLS Wrapper (également connu sous le nom de SMTPS ou de protocole de négociation) permet d'initier une connexion chiffrée sans établir en premier lieu une connexion non chiffrée. Avec TLS Wrapper, le point de terminaison SMTP Amazon SES n'effectue pas de négociation TLS : c'est la responsabilité du client de se connecter au point de terminaison à l'aide de TLS et de continuer à utiliser TLS pour la totalité de la conversation. TLS Wrapper est un protocole plus ancien, mais de nombreux clients continuent de le prendre en charge. Pour les connexions TLS Wrapper, Amazon SES prend en charge TLS 1.2 et TLS 1.3.

Pour obtenir des informations sur la connexion à l'interface SMTP Amazon SES à l'aide de ces méthodes, consultez [Connexion à un point de terminaison SMTP Amazon SES](smtp-connect.md).

## Amazon SES à destination d'un récepteur
<a name="security-ses-to-receiver"></a>

 Bien que TLS 1.3 soit notre méthode de livraison par défaut, SES peut envoyer des e-mails aux serveurs de messagerie utilisant des versions antérieures de TLS. 

Par défaut, Amazon SES utilise *la méthode TLS opportuniste*. Dans SES, le protocole TLS opportuniste utilise toujours STARTTLS et n'inclut pas le TLS Wrapper. Le flux implique l'établissement d'une connexion initiale en texte brut, suivie d'une mise à niveau vers une session cryptée TLS si le client et le serveur prennent en charge STARTTLS. Si SES ne parvient pas à établir une connexion sécurisée, il envoie le message non chiffré.

Vous pouvez modifier ce comportement en utilisant des jeux de configurations. Utilisez l'opération [PutConfigurationSetDeliveryOptions](https://docs.aws.amazon.com/ses/latest/APIReference/API_PutConfigurationSetDeliveryOptions.html)API pour définir la `TlsPolicy` propriété d'une configuration définie sur`Require`. Vous pouvez utiliser l'[AWS CLI](https://aws.amazon.com/cli) pour effectuer cette modification.

**Pour configurer Amazon SES afin d'exiger des connexions TLS pour un jeu de configurations**
+ Sur la ligne de commande, entrez la commande suivante :

  ```
  aws sesv2 put-configuration-set-delivery-options --configuration-set-name MyConfigurationSet --tls-policy REQUIRE
  ```

  Dans l'exemple précédent, remplacez *MyConfigurationSet* par le nom de votre jeu de configuration.

  Lorsque vous envoyez un e-mail à l'aide de ce jeu de configurations, Amazon SES envoie uniquement le message au serveur de messagerie de réception s'il peut établir une connexion sécurisée. Si Amazon SES ne peut pas créer une connexion sécurisée au serveur de messagerie de réception, il supprime le message.

## End-to-end chiffrement
<a name="security-end-to-end"></a>

Vous pouvez utiliser Amazon SES pour envoyer des messages chiffrés à l'aide S/MIME de PGP. Les messages qui utilisent ces protocoles sont chiffrés par l'expéditeur. Leur contenu ne peut être consulté que par les destinataires qui possèdent les clés privées requises pour déchiffrer les messages.

Amazon SES prend en charge les types MIME suivants, que vous pouvez utiliser pour envoyer des e-mails S/MIME chiffrés :
+ `application/pkcs7-mime`
+ `application/pkcs7-signature`
+ `application/x-pkcs7-mime`
+ `application/x-pkcs7-signature`

Amazon SES prend également en charge les types MIME suivants, que vous pouvez utiliser pour envoyer des e-mails chiffrés à l'aide de PGP :
+ `application/pgp-encrypted`
+ `application/pgp-keys`
+ `application/pgp-signature`

# Champs d'en-tête Amazon SES
<a name="header-fields"></a>

Amazon SES accepte tous les champs d'en-tête de-mail qui respectent le format décrit dans [RFC 822](https://www.rfc-editor.org/rfc/rfc822.html).

Les champs suivants ne peuvent pas apparaître plusieurs fois dans la section d'en-tête d'un message :
+ `Accept-Language`
+ `acceptLanguage`
+ `Archived-At`
+ `Auto-Submitted`
+ `Bounces-to`
+ `Comments`
+ `Content-Alternative`
+ `Content-Base`
+ `Content-Class`
+ `Content-Description`
+ `Content-Disposition`
+ `Content-Duration`
+ `Content-ID`
+ `Content-Language`
+ `Content-Length`
+ `Content-Location`
+ `Content-MD5`
+ `Content-Transfer-Encoding`
+ `Content-Type`
+ `Date`
+ `Delivered-To `
+ `Disposition-Notification-Options`
+ `Disposition-Notification-To`
+ `DKIM-Signature`
+ `DomainKey-Signature`
+ `Errors-To`
+ `From`
+ `Importance`
+ `In-Reply-To`
+ `Keywords`
+ `List-Archive`
+ `List-Help`
+ `List-Id`
+ `List-Owner`
+ `List-Post`
+ `List-Subscribe`
+ `List-Unsubscribe`
+ `List-Unsubscribe-Post`
+ `Message-Context`
+ `Message-ID`
+ `MIME-Version`
+ `Organization`
+ `Original-From`
+ `Original-Message-ID`
+ `Original-Recipient`
+ `Original-Subject`
+ `Precedence`
+ `Priority`
+ `References`
+ `Reply-To`
+ `Return-Path`
+ `Return-Receipt-To`
+ `Sender`
+ `Solicitation`
+ `Sensitivity`
+ `Subject`
+ `Thread-Index`
+ `Thread-Topic`
+ `User-Agent`
+ `VBR-Info`

**Considérations**
+ Le champ `acceptLanguage` n'est pas standard. Si possible, utilisez plutôt l'en-tête `Accept-Language`.
+ Si vous spécifiez un en-tête `Date`, Amazon SES le remplace par un horodatage correspondant à la date et à l'heure du fuseau horaire UTC auxquelles Amazon SES a accepté le message.
+ Si vous fournissez un en-tête `Message-ID`, Amazon SES remplace cet en-tête par sa propre valeur.
+ Si vous spécifiez un en-tête `Return-Path`, Amazon SES envoie les notifications de retour à l'expéditeur et de réclamation à l'adresse que vous avez spécifiée. Toutefois, le message que vos destinataires reçoivent contient une valeur différente pour l'en-tête `Return-Path`.
+ Si vous utilisez l'`SendEmail`opération Amazon SES API v2 avec du contenu *simple ou *modélisé**, ou si vous utilisez l'`SendBulkEmail`opération, vous ne pouvez pas définir de contenu d'en-tête personnalisé pour les en-têtes définis par SES ; par conséquent, les en-têtes suivants ne sont pas autorisés en tant qu'en-têtes personnalisés :
  + `BCC`, `CC`, `Content-Disposition`, `Content-Type`, `Date`, `From`, `Message-ID`, `MIME-Version`, `Reply-To`, `Return-Path`, `Subject`, `To`

# Utilisation des pièces jointes aux e-mails dans SES
<a name="attachments"></a>

Les pièces jointes aux e-mails dans SES sont des fichiers que vous pouvez inclure dans vos e-mails lorsque vous utilisez l'API SES v2 `SendEmail` et ses `SendBulkEmail` opérations. Cette fonctionnalité vous permet d'enrichir le contenu de vos e-mails en incluant des documents tels que des fichiers Word PDFs, des images ou d'autres types de fichiers conformes aux types MIME pris en charge par SES. Vous pouvez également inclure des images intégrées qui s'affichent directement dans le contenu de l'e-mail sans que les destinataires n'aient à les télécharger séparément. Vous pouvez inclure plusieurs pièces jointes par e-mail, jusqu'à la limite de taille totale des messages de 40 Mo.

**Note**  
[https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendEmail.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendEmail.html)L'API SES v2 avec le type de `Raw` contenu, l'interface SMTP et l'API SES v1 continuent de gérer les pièces jointes par le biais de la construction de [messages MIME de courrier électronique bruts](send-email-raw.md#send-email-raw-mime).

## Comment fonctionnent les pièces jointes dans SES
<a name="how-attachments-work"></a>

Il existe deux types d'encodage différents qui se produisent à différents stades lors de l'envoi d'un e-mail avec pièces jointes :

Étape 1 — Envoi de données à SES :
+ Lorsque vous souhaitez envoyer une pièce jointe à SES, les données binaires (comme un PDF ou une image) doivent être converties dans un format pouvant être transmis en toute sécurité.
+ C'est là qu'intervient le codage base64 : il est obligatoire car vous ne pouvez pas envoyer de données binaires brutes dans une requête JSON.
+ Si vous utilisez le AWS SDK, il gère automatiquement cet encodage.
+ Si vous utilisez le AWS CLI, vous devez encoder vous-même la pièce jointe en base64 avant de l'envoyer.

Étape 2 — Création de l'e-mail par SES :
+ Une fois que SES reçoit vos données, il doit créer un véritable e-mail avec la pièce jointe.
+ C'est là que le [ContentTransferEncoding](#attachment-structure)décor entre en jeu.
+ SES utilisera la méthode de codage que vous spécifiez ContentTransferEncoding pour formater automatiquement la pièce jointe dans l'e-mail final.

Pensez-y comme ceci : c'est comme envoyer un colis par la poste. Tout d'abord, vous devez faire parvenir le colis au bureau de poste (étape 1 - encodage Base64 requis), puis le bureau de poste l'emballera de manière appropriée pour la livraison finale (étape 2 - ContentTransferEncoding).

## Structure de l'objet de fixation
<a name="attachment-structure"></a>

Lorsque vous envoyez un e-mail avec des pièces jointes via SES, le service gère automatiquement la construction complexe des messages MIME. Il vous suffit de fournir le contenu et les métadonnées de la pièce jointe via la structure d'[https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Attachment.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_Attachment.html)objets suivante de l'API SES v2 :
+ `FileName`(Obligatoire) — Le nom du fichier est affiché aux destinataires (doit inclure l'extension du fichier). S'il n'est pas fourni, SES `ContentType` dérivera un de l'extension du`FileName`.
+ `ContentType`(Facultatif) — Identifiant de [type de support conforme à l'IANA](https://www.iana.org/assignments/media-types/media-types.xhtml).
+ `ContentDisposition`(Facultatif) — Spécifie le mode de rendu de la pièce jointe : `ATTACHMENT` *(par défaut)* ou`INLINE`.
+ `ContentDescription`(Facultatif) — Brève description du contenu.
+ `RawContent`(Obligatoire) — Le contenu réel de la pièce jointe.
+ `ContentTransferEncoding`(Facultatif) — Spécifie la manière dont la charge utile de la pièce jointe est codée lorsqu'elle est assemblée dans le message MIME de l'e-mail : `SEVEN_BIT` *(par défaut), `BASE64` ou*. `QUOTED_PRINTABLE`

Tout le contenu joint doit être codé en base64 avant d'être transféré vers le point de terminaison SES pour envoi. Si vous utilisez le client AWS SDK pour effectuer des appels d'API, cela est automatiquement géré pour vous. Si vous utilisez ou avez implémenté votre propre client, vous devrez effectuer le codage vous-même, par exemple : AWS CLI
+ Contenu en texte brut : `Text attachment sample content.`
+ Encodé en Base64 : `VGV4dCBhdHRhY2htZW50IHNhbXBsZSBjb250ZW50Lg==`

Les exemples suivants montrent comment utiliser la structure d'objet de pièce jointe lors de la spécification de pièces jointes avec l'API SES v2 [https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendEmail.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendEmail.html)et d'[https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendBulkEmail.html](https://docs.aws.amazon.com/ses/latest/APIReference-V2/API_SendBulkEmail.html)opérations utilisant le AWS CLI référencement d'un fichier JSON contenant des éléments d'objet de pièce jointe.

**Example — SendEmail avec un contenu simple**  

```
aws sesv2 send-email --cli-input-json file://request-send-email-simple.json
```
**request-send-email-simple.json**  

```
{
    "FromEmailAddress": "sender@example.com",
    "Destination": {
        "ToAddresses": [
            "recipient@example.com"
        ]
    },
    "Content": {
        "Simple": {
            "Subject": {
                "Data": "Email with attachment"
            },
            "Body": {
                "Text": {
                    "Data": "Please see attached document."
                },
                "Html": {
                    "Data": "Please see attached <b>document</b>."
                }
            },
            "Attachments": [
                {
                    "RawContent": "<base64-encoded-content>",
                    "ContentDisposition": "ATTACHMENT",
                    "FileName": "document.pdf",
                    "ContentDescription": "PDF Document Attachment",
                    "ContentTransferEncoding": "BASE64"
                }
            ]
        }
    }
}
```

**Example — SendEmail avec un contenu simple et une pièce jointe en ligne**  

```
aws sesv2 send-email --cli-input-json file://request-send-email-simple-inline-attachment.json
```
**request-send-email-simple-inline-attachment.json**  

```
{
    "FromEmailAddress": "sender@example.com",
    "Destination": {
        "ToAddresses": [
            "recipient@example.com"
        ]
    },
    "Content": {
        "Simple": {
            "Subject": {
                "Data": "Email with attachment"
            },
            "Body": {
                "Html": {
                    "Data": "<html><body>Our logo:<br><img src=\"cid:logo123\" alt=\"Company Logo\"></body></html>"
                }
            },
            "Attachments": [
                {
                    "RawContent": "<base64-encoded-content>",
                    "ContentDisposition": "INLINE",
                    "FileName": "logo.png",
                    "ContentId": "logo123",
                    "ContentTransferEncoding": "BASE64"
                }
            ]
        }
    }
}
```

**Example — SendEmail avec le contenu du modèle**  

```
aws sesv2 send-email --cli-input-json file://request-send-email-template.json
```
**request-send-email-template.json**  

```
{
    "FromEmailAddress": "sender@example.com",
    "Destination": {
        "ToAddresses": [
            "recipient@example.com"
        ]
    },
    "Content": {
        "Template": {
            "TemplateName": "MyTemplate",
            "TemplateData": "{\"name\":\"John\"}",
            "Attachments": [
                {
                    "RawContent": "<base64-encoded-content>",
                    "ContentDisposition": "ATTACHMENT",
                    "FileName": "document.pdf",
                    "ContentDescription": "PDF Document Attachment",
                    "ContentTransferEncoding": "BASE64"
                }
            ]
        }
    }
}
```

**Example — SendBulkEmail avec contenu en pièce jointe**  

```
aws sesv2 send-bulk-email --cli-input-json file://request-send-bulk-email.json
```
**request-send-bulk-email.json**  

```
{
    "FromEmailAddress": "sender@example.com",
    "DefaultContent": {
        "Template": {
            "TemplateName": "MyTemplate",
            "TemplateData": "{}",
            "Attachments": [
                {
                    "RawContent": "<base64-encoded-content>",
                    "ContentDisposition": "ATTACHMENT",
                    "FileName": "document.pdf",
                    "ContentDescription": "PDF Document Attachment",
                    "ContentTransferEncoding": "BASE64"
                }
            ]
        }
    },
    "BulkEmailEntries": [
        {
            "Destination": {
                "ToAddresses": [
                    "recipient@example.com"
                ]
            },
            "ReplacementEmailContent": {
                "ReplacementTemplate": {
                    "ReplacementTemplateData": "{\"name\":\"John\"}"
                }
            }
        }
    ]
}
```

## Bonnes pratiques
<a name="attachments-best-practices"></a>
+ Limitez la taille totale des messages (pièces jointes comprises) à moins de 40 Mo.
+ Dans la mesure du possible, laissez SES détecter automatiquement les types de contenu en fonction des extensions de fichiers.
+ Spécifiez explicitement les types de contenu uniquement lorsqu'ils ne correspondent pas aux [types MIME courants](https://developer.mozilla.org/en-US/docs/Web/HTTP/MIME_types/Common_types).
+ Envisagez d'utiliser des images intégrées pour un meilleur rendu des e-mails.
+ SES prend en charge un large éventail de types MIME pour les pièces jointes, à l'exception de ceux répertoriés dans[Types de pièces jointes non pris en charge](#mime-types).

## Types de pièces jointes SES non pris en charge
<a name="mime-types"></a>

Vous pouvez envoyer des messages avec des pièces jointes via Amazon SES en utilisant le standard Multipurpose Internet Mail Extensions (MIME). Amazon SES accepte tous les types de pièces jointes *à l'exception* des pièces jointes dont l'extension de fichier figure dans la liste qui suit.


|  |  |  |  |  | 
| --- |--- |--- |--- |--- |
| .ade .adp .app .asp .bas .bat .cer .chm .cmd .com .cpl .crt .csh .der .exe .fxp .gadget .hlp  | .hta .inf .ins .isp .its .js .jse .ksh .lib .lnk .mad .maf .mag .mam .maq .mar .mas .mat  | .mau .mav .maw .mda .mdb .mde .mdt .mdw .mdz .msc .msh .msh1 .msh2 .mshxml .msh1xml .msh2xml .msi .msp  | .mst .ops .pcd .pif .plg .prf .prg .reg .scf .scr .sct .shb .shs .sys .ps1 .ps1xml .ps2 .ps2xml  | .psc1 .psc2 .tmp .url .vb .vbe .vbs .vps .vsmacros .vss .vst .vsw .vxd .ws .wsc .wsf .wsh .xnk  | 

Certains ISPs comportent d'autres restrictions (telles que les restrictions concernant les pièces jointes archivées). Nous vous recommandons donc de tester l'envoi de vos e-mails via le ISPs service principal avant d'envoyer votre e-mail de production.