À propos des champs d'en-tête d'e-mail En utilisant MIME Envoi d'e-mails bruts à l'aide d'Amazon SES API v2

Envoi d'e-mails bruts à l'aide d'Amazon SES API v2

Vous pouvez utiliser l'SendEmailopé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

Le protocole Simple Mail Transfer Protocol (SMTP) définit la manière dont les messages électroniques doivent être envoyés en définissant l'enveloppe du courrier et certains de ses paramètres, mais il ne se préoccupe pas du contenu du message. Au lieu de cela, le format de message Internet (RFC5322) définit la manière dont le message doit être construit.

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.

En utilisant MIME

Le SMTP protocole a été initialement conçu pour envoyer des messages électroniques contenant uniquement des ASCII caractères de 7 bits. Cette spécification est SMTP insuffisante pour les codages non ASCII textuels (tels que Unicode), les contenus binaires ou les pièces jointes. La norme Multipurpose Internet Mail Extensions (MIME) a été développée pour permettre d'envoyer de nombreux autres types de contenu à l'aide SMTP de.

La MIME norme fonctionne en divisant le corps du message en plusieurs parties, puis en spécifiant ce qui doit être fait avec chaque partie. Par exemple, une partie du corps d'un e-mail peut être en texte brut, tandis qu'une autre peut l'êtreHTML. Autorise également les MIME 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.

Dans l'exemple suivant, le message en plusieurs parties contient un texte, une HTML partie et une pièce jointe. La pièce jointe doit être placée juste en dessous des en-têtes de pièce jointe et est le plus souvent encodée en base64, comme indiqué dans cet exemple.


From: "Sender Name" <sender@example.com>
To: recipient@example.com
Subject: Customer service contact info
Content-Type: multipart/mixed;
    boundary="a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a"

--a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a
Content-Type: multipart/alternative;
    boundary="sub_a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a"

--sub_a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a
Content-Type: text/plain; charset=iso-8859-1
Content-Transfer-Encoding: quoted-printable

Please see the attached file for a list of customers to contact.

--sub_a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a
Content-Type: text/html; charset=iso-8859-1
Content-Transfer-Encoding: quoted-printable

<html>
<head></head>
<body>
<h1>Hello!</h1>
<p>Please see the attached file for a list of customers to contact.</p>
</body>
</html>

--sub_a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a--

--a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a
Content-Type: text/plain; name="customers.txt"
Content-Description: customers.txt
Content-Disposition: attachment;filename="customers.txt";
    creation-date="Sat, 05 Aug 2017 19:35:36 GMT";
Content-Transfer-Encoding: base64

SUQsRmlyc3ROYW1lLExhc3ROYW1lLENvdW50cnkKMzQ4LEpvaG4sU3RpbGVzLENhbmFkYQo5MjM4
OSxKaWUsTGl1LENoaW5hCjczNCxTaGlybGV5LFJvZHJpZ3VleixVbml0ZWQgU3RhdGVzCjI4OTMs
QW5heWEsSXllbmdhcixJbmRpYQ==

--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 HTML version). Si le client de messagerie du destinataire peut afficher HTML du contenu, il affiche la HTML version du corps du message. Si le client de messagerie du destinataire ne peut pas afficher le HTML contenu, il affiche la version en 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 MIME imbriquez une pièce dans une autre pièce, comme dans cet exemple, la pièce imbriquée doit utiliser un boundary paramètre distinct de celui de la pièce parent. boundary Ces limites doivent être des chaînes de caractères uniques. Pour définir une limite entre les MIME pièces, tapez deux tirets (--) suivis de la chaîne de limite. À la fin d'une MIME partie, placez deux traits d'union au début et à la fin de la chaîne de délimitation.

Note

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

MIMEEncodage

Pour maintenir la compatibilité avec les anciens systèmes, Amazon SES respecte la ASCII limite de 7 bits SMTP définie dans le RFC2821. Si vous souhaitez envoyer du contenu qui ne contient pas de ASCII caractères, vous devez encoder ces caractères dans un format utilisant des caractères 7 bitsASCII.

Adresses e-mail

La chaîne d'adresse e-mail doit être de 7 bitsASCII. 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 MIME encoder le nom « friendly from » à l'aide de la syntaxe des mots codés, comme décrit dans. Envoi d'e-mails bruts à l'aide d'Amazon SES API v2 Pour plus d'informations sur Punycode, consultez RFC 3492.

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'SendEmailopé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 coder un en-tête de message, utilisez la syntaxe des mots MIME codés. MIMEla syntaxe des mots codés 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 plus d'informations sur le codage Q, voir RFC2047. Pour plus d'informations sur le codage base64, consultez 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 :

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

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 8 bits Content-Transfer-Encoding dans les messages que vous envoyez via AmazonSES. Toutefois, si Amazon SES doit apporter des modifications à vos messages (par exemple, lorsque vous utilisez le suivi des ouvertures et des clics), le contenu codé en 8 bits risque de ne pas s'afficher correctement lorsqu'il arrive dans les boîtes de réception des destinataires. Pour cette raison, vous devez toujours encoder le contenu qui n'est pas en 7 ASCII 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 des parties de MIME message 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 de MIME type de contenu courantes :
- Fichier en texte brut : Content-Type: text/plain; name="sample.txt"
- Document Microsoft Word : Content-Type: application/msword; name="document.docx"
- JPGimage — 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.

Amazon SES accepte les types de fichiers les plus courants. Pour obtenir la liste des types de fichiers qu'Amazon SES n'accepte pas, consultezTypes de pièces jointes SES non pris en charge par Amazon.

Envoi d'e-mails bruts à l'aide d'Amazon SES API v2

Amazon SES API v2 fournit l'SendEmailaction, 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èle. Pour une description complète, voir SendEmail. 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.

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 JavaMailbibliothèque et AWS SDK for Javacomment composer et envoyer un e-mail brut.


package com.amazonaws.samples;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.nio.ByteBuffer;
import java.util.Properties;

// JavaMail libraries. Download the JavaMail API 
// from https://javaee.github.io/javamail/
import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.activation.FileDataSource;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;

// AWS SDK libraries. Download the AWS SDK for Java // from https://aws.amazon.com/sdk-for-java
import com.amazonaws.regions.Regions;
import com.amazonaws.services.simpleemail.AmazonSimpleEmailService;
import com.amazonaws.services.simpleemail.AmazonSimpleEmailServiceClientBuilder;
import com.amazonaws.services.simpleemail.model.RawMessage;
import com.amazonaws.services.simpleemail.model.SendRawEmailRequest;

public class AmazonSESSample {

	// Replace sender@example.com with your "From" address.
	// This address must be verified with Amazon SES.
	private static String SENDER = "Sender Name <sender@example.com>";

	// Replace recipient@example.com with a "To" address. If your account 
	// is still in the sandbox, this address must be verified.
	private static String RECIPIENT = "recipient@example.com";

	// Specify a configuration set. If you do not want to use a configuration
	// set, comment the following variable, and the 
	// ConfigurationSetName=CONFIGURATION_SET argument below.
	private static String CONFIGURATION_SET = "ConfigSet";

	// The subject line for the email.
	private static String SUBJECT = "Customer service contact info";

	// The full path to the file that will be attached to the email.
	// If you're using Windows, escape backslashes as shown in this variable.
	private static String ATTACHMENT = "C:\\Users\\sender\\customers-to-contact.xlsx";

	// The email body for recipients with non-HTML email clients.
	private static String BODY_TEXT = "Hello,\r\n"
                                        + "Please see the attached file for a list "
                                        + "of customers to contact.";

	// The HTML body of the email.
	private static String BODY_HTML = "<html>"
                                        + "<head></head>"
                                        + "<body>"
                                        + "<h1>Hello!</h1>"
                                        + "<p>Please see the attached file for a "
                                        + "list of customers to contact.</p>"
                                        + "</body>"
                                        + "</html>";

    public static void main(String[] args) throws AddressException, MessagingException, IOException {
            	
    	Session session = Session.getDefaultInstance(new Properties());
        
        // Create a new MimeMessage object.
        MimeMessage message = new MimeMessage(session);
        
        // Add subject, from and to lines.
        message.setSubject(SUBJECT, "UTF-8");
        message.setFrom(new InternetAddress(SENDER));
        message.setRecipients(Message.RecipientType.TO, InternetAddress.parse(RECIPIENT));

        // Create a multipart/alternative child container.
        MimeMultipart msg_body = new MimeMultipart("alternative");
        
        // Create a wrapper for the HTML and text parts.        
        MimeBodyPart wrap = new MimeBodyPart();
        
        // Define the text part.
        MimeBodyPart textPart = new MimeBodyPart();
        textPart.setContent(BODY_TEXT, "text/plain; charset=UTF-8");
                
        // Define the HTML part.
        MimeBodyPart htmlPart = new MimeBodyPart();
        htmlPart.setContent(BODY_HTML,"text/html; charset=UTF-8");
                
        // Add the text and HTML parts to the child container.
        msg_body.addBodyPart(textPart);
        msg_body.addBodyPart(htmlPart);
        
        // Add the child container to the wrapper object.
        wrap.setContent(msg_body);
        
        // Create a multipart/mixed parent container.
        MimeMultipart msg = new MimeMultipart("mixed");
        
        // Add the parent container to the message.
        message.setContent(msg);
        
        // Add the multipart/alternative part to the message.
        msg.addBodyPart(wrap);
        
        // Define the attachment
        MimeBodyPart att = new MimeBodyPart();
        DataSource fds = new FileDataSource(ATTACHMENT);
        att.setDataHandler(new DataHandler(fds));
        att.setFileName(fds.getName());
        
        // Add the attachment to the message.
        msg.addBodyPart(att);

        // Try to send the email.
        try {
            System.out.println("Attempting to send an email through Amazon SES "
                              +"using the AWS SDK for Java...");

            // Instantiate an Amazon SES client, which will make the service 
            // call with the supplied AWS credentials.
            AmazonSimpleEmailService client = 
                    AmazonSimpleEmailServiceClientBuilder.standard()
                    // Replace US_WEST_2 with the AWS Region you're using for
                    // Amazon SES.
                    .withRegion(Regions.US_WEST_2).build();
            
            // Print the raw email content on the console
            PrintStream out = System.out;
            message.writeTo(out);

            // Send the email.
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
            message.writeTo(outputStream);
            RawMessage rawMessage = 
            		new RawMessage(ByteBuffer.wrap(outputStream.toByteArray()));

            SendRawEmailRequest rawEmailRequest = 
            		new SendRawEmailRequest(rawMessage)
            		    .withConfigurationSetName(CONFIGURATION_SET);
            
            client.sendRawEmail(rawEmailRequest);
            System.out.println("Email sent!");
        // Display an error if something goes wrong.
        } catch (Exception ex) {
          System.out.println("Email Failed");
            System.err.println("Error message: " + ex.getMessage());
            ex.printStackTrace();
        }
    }
}

Python

L'exemple de code suivant montre comment utiliser les packages Python email.mime et le kit AWS SDK for Python (Boto) pour composer et envoyer un e-mail brut.


import json
import boto3
from botocore.exceptions import ClientError
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.application import MIMEApplication
import os

def boto3_rawemailv2():
    SENDER = "Sender <sender@example.com>"
    RECIPIENT = "recipient@example.com"
    CONFIGURATION_SET = "ConfigSet"
    AWS_REGION = "us-east-1"
    SUBJECT = "Customer service contact info"
    ATTACHMENT = "path/to/customers-to-contact.xlsx"
    BODY_TEXT = "Hello,\r\nPlease see the attached file for a list of customers to contact."

    # The HTML body of the email.
    BODY_HTML = """\
    <html>
    <head/>
    <body>
    <h1>Hello!</h1>
    <p>Please see the attached file for a list of customers to contact.</p>
    </body>
    </html>
    """

    # The character encoding for the email.
    CHARSET = "utf-8"
    msg = MIMEMultipart('mixed')
    # Add subject, from and to lines.
    msg['Subject'] = SUBJECT 
    msg['From'] = SENDER 
    msg['To'] = RECIPIENT
    
    # Create a multipart/alternative child container.
    msg_body = MIMEMultipart('alternative')
    
    # Encode the text and HTML content and set the character encoding. This step is
    # necessary if you're sending a message with characters outside the ASCII range.
    textpart = MIMEText(BODY_TEXT.encode(CHARSET), 'plain', CHARSET)
    htmlpart = MIMEText(BODY_HTML.encode(CHARSET), 'html', CHARSET)
    
    # Add the text and HTML parts to the child container.
    msg_body.attach(textpart)
    msg_body.attach(htmlpart)
    
    # Define the attachment part and encode it using MIMEApplication.
    att = MIMEApplication(open(ATTACHMENT, 'rb').read())
    
    # Add a header to tell the email client to treat this part as an attachment,
    # and to give the attachment a name.
    att.add_header('Content-Disposition','attachment',filename=os.path.basename(ATTACHMENT))
    
    # Attach the multipart/alternative child container to the multipart/mixed
    # parent container.
    msg.attach(msg_body)
    msg.attach(att)

    #changes start from here
    strmsg = str(msg)
    body = bytes (strmsg, 'utf-8')



    
    client = boto3.client('sesv2')
    response = client.send_email(
    FromEmailAddress=SENDER,
    Destination={
        'ToAddresses': [RECIPIENT]
    },
    Content={
        'Raw': {
            'Data': body
        }
    }
    )
    print(response)
boto3_rawemailv2 ()

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Envoi d'e-mails formatés

Utiliser des modèles pour envoyer des e-mails