Please see the attached file for a list of customers to contact.
26. 27. 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 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 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 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 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 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 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 NamePlease see the attached file for a " 63. + "list of customers to contact.
" 64. + "" 65. + ""; 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 = "SenderPlease see the attached file for a list of customers to contact.
25. 26. 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 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 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 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": "Your favorite animal is {{favoriteanimal}}.
" } } ``` 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é 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 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 MajorYour favorite animal is {{favoriteanimal}}.
" }, "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 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 MajorYour favorite animal is {{favoriteanimal}}.
" }, "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 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 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 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": "You have indicated that you are interested in receiving information about the following subjects:
You can change these settings at any time by visiting the Preference Center.
", "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 NameDear {{contact.firstName}},
{{#if subscription}}You have indicated that you are interested in receiving information about the following subjects:
You can change these settings at any time by visiting the Preference Center.
{{else}}Please update your subscription preferences by visiting
the
Preference Center.
{{/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 You have listed the following people as your friends: This is the HTML part of the message. This is the HTML part of the message. This email was sent with
38. Amazon SES using the
39. AWS SDK pour .NET. This email was sent with "
35. + "Amazon SES using the "
36. + "AWS SDK for Java";
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. '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 = ' This email was sent with '.
37. 'Amazon SES using the '.
38. 'AWS SDK pour PHP. This email was sent with '\
26. 'Amazon SES using the '\
27. 'AWS SDK pour Ruby.'
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 This email was sent with
35. Amazon SES using the
36. AWS SDK pour Python (Boto).Hello {{> fullName}}!
{{#each friends}}
",
"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
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
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
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": "\n\nHello!
\nHello!
\nAmazon SES Test (SDK pour .NET)
37. Amazon SES test (AWS SDK pour Java)
"
34. + "AWS Amazon Simple Email Service Test Email
'.
36. 'Amazon SES test (AWS SDK pour Ruby)
'\
25. 'Amazon SES Test (SDK for Python)
34.