\s
Where:
sender - An email address that represents the sender.\s
recipient - An email address that represents the recipient.\s
subject - The subject line.\s
fileLocation - The location of a Microsoft Excel file to use as an attachment (C:/AWS/customers.xls).\s
""";
if (args.length != 4) {
System.out.println(usage);
System.exit(1);
}
String sender = args[0];
String recipient = args[1];
String subject = args[2];
String fileLocation = args[3];
// The email body for recipients with non-HTML email clients.
String bodyText = "Hello,\r\n" + "Please see the attached file for a list "
+ "of customers to contact.";
// The HTML body of the email.
String bodyHTML = "" + "" + "" + "Hello!
"
+ "Please see the attached file for a " + "list of customers to contact.
" + ""
+ "";
Region region = Region.US_WEST_2;
SesClient client = SesClient.builder()
.region(region)
.build();
try {
sendemailAttachment(client, sender, recipient, subject, bodyText, bodyHTML, fileLocation);
client.close();
System.out.println("Done");
} catch (IOException | MessagingException e) {
e.printStackTrace();
}
}
public static void sendemailAttachment(SesClient client,
String sender,
String recipient,
String subject,
String bodyText,
String bodyHTML,
String fileLocation) throws AddressException, MessagingException, IOException {
java.io.File theFile = new java.io.File(fileLocation);
byte[] fileContent = Files.readAllBytes(theFile.toPath());
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 msgBody = 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(bodyText, "text/plain; charset=UTF-8");
// Define the HTML part.
MimeBodyPart htmlPart = new MimeBodyPart();
htmlPart.setContent(bodyHTML, "text/html; charset=UTF-8");
// Add the text and HTML parts to the child container.
msgBody.addBodyPart(textPart);
msgBody.addBodyPart(htmlPart);
// Add the child container to the wrapper object.
wrap.setContent(msgBody);
// Create a multipart/mixed parent container.
MimeMultipart msg = new MimeMultipart("mixed");
// Add the parent container to the message.
message.setContent(msg);
msg.addBodyPart(wrap);
// Define the attachment.
MimeBodyPart att = new MimeBodyPart();
DataSource fds = new ByteArrayDataSource(fileContent,
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
att.setDataHandler(new DataHandler(fds));
String reportName = "WorkReport.xls";
att.setFileName(reportName);
// Add the attachment to the message.
msg.addBodyPart(att);
try {
System.out.println("Attempting to send an email through Amazon SES " + "using the AWS SDK for Java...");
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
message.writeTo(outputStream);
ByteBuffer buf = ByteBuffer.wrap(outputStream.toByteArray());
byte[] arr = new byte[buf.remaining()];
buf.get(arr);
SdkBytes data = SdkBytes.fromByteArray(arr);
RawMessage rawMessage = RawMessage.builder()
.data(data)
.build();
SendRawEmailRequest rawEmailRequest = SendRawEmailRequest.builder()
.rawMessage(rawMessage)
.build();
client.sendRawEmail(rawEmailRequest);
} catch (SesException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
System.out.println("Email sent using SesClient with attachment");
}
}
```
+ Pour plus de détails sur l'API, voir [SendEmail](https://docs.aws.amazon.com/goto/SdkForJavaV2/email-2010-12-01/SendEmail)la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
import { SendEmailCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";
const createSendEmailCommand = (toAddress, fromAddress) => {
return new SendEmailCommand({
Destination: {
/* required */
CcAddresses: [
/* more items */
],
ToAddresses: [
toAddress,
/* more To-email addresses */
],
},
Message: {
/* required */
Body: {
/* required */
Html: {
Charset: "UTF-8",
Data: "HTML_FORMAT_BODY",
},
Text: {
Charset: "UTF-8",
Data: "TEXT_FORMAT_BODY",
},
},
Subject: {
Charset: "UTF-8",
Data: "EMAIL_SUBJECT",
},
},
Source: fromAddress,
ReplyToAddresses: [
/* more items */
],
});
};
const run = async () => {
const sendEmailCommand = createSendEmailCommand(
"recipient@example.com",
"sender@example.com",
);
try {
return await sesClient.send(sendEmailCommand);
} catch (caught) {
if (caught instanceof Error && caught.name === "MessageRejected") {
/** @type { import('@aws-sdk/client-ses').MessageRejected} */
const messageRejectedError = caught;
return messageRejectedError;
}
throw caught;
}
};
```
+ Pour plus de détails sur l'API, voir [SendEmail](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/SendEmailCommand)la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/ses#code-examples).
```
class SesMailSender:
"""Encapsulates functions to send emails with Amazon SES."""
def __init__(self, ses_client):
"""
:param ses_client: A Boto3 Amazon SES client.
"""
self.ses_client = ses_client
def send_email(self, source, destination, subject, text, html, reply_tos=None):
"""
Sends an email.
Note: If your account is in the Amazon SES sandbox, the source and
destination email accounts must both be verified.
:param source: The source email account.
:param destination: The destination email account.
:param subject: The subject of the email.
:param text: The plain text version of the body of the email.
:param html: The HTML version of the body of the email.
:param reply_tos: Email accounts that will receive a reply if the recipient
replies to the message.
:return: The ID of the message, assigned by Amazon SES.
"""
send_args = {
"Source": source,
"Destination": destination.to_service_format(),
"Message": {
"Subject": {"Data": subject},
"Body": {"Text": {"Data": text}, "Html": {"Data": html}},
},
}
if reply_tos is not None:
send_args["ReplyToAddresses"] = reply_tos
try:
response = self.ses_client.send_email(**send_args)
message_id = response["MessageId"]
logger.info(
"Sent mail %s from %s to %s.", message_id, source, destination.tos
)
except ClientError:
logger.exception(
"Couldn't send mail from %s to %s.", source, destination.tos
)
raise
else:
return message_id
```
+ Pour plus de détails sur l'API, consultez [SendEmail](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/SendEmail)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
#### [ Ruby ]
**Kit SDK pour Ruby**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/ses/v1#code-examples).
```
require 'aws-sdk-ses' # v2: require 'aws-sdk'
# Replace sender@example.com with your "From" address.
# This address must be verified with Amazon SES.
sender = 'sender@example.com'
# Replace recipient@example.com with a "To" address. If your account
# is still in the sandbox, this address must be verified.
recipient = 'recipient@example.com'
# Specify a configuration set. To use a configuration
# set, uncomment the next line and line 74.
# configsetname = "ConfigSet"
# The subject line for the email.
subject = 'Amazon SES test (AWS SDK for Ruby)'
# The HTML body of the email.
htmlbody =
'Amazon SES test (AWS SDK for Ruby)
'\
'This email was sent with '\
'Amazon SES using the '\
'AWS SDK for Ruby.'
# The email body for recipients with non-HTML email clients.
textbody = 'This email was sent with Amazon SES using the AWS SDK for Ruby.'
# Specify the text encoding scheme.
encoding = 'UTF-8'
# Create a new SES client in the us-west-2 region.
# Replace us-west-2 with the AWS Region you're using for Amazon SES.
ses = Aws::SES::Client.new(region: 'us-west-2')
# Try to send the email.
begin
# Provide the contents of the email.
ses.send_email(
destination: {
to_addresses: [
recipient
]
},
message: {
body: {
html: {
charset: encoding,
data: htmlbody
},
text: {
charset: encoding,
data: textbody
}
},
subject: {
charset: encoding,
data: subject
}
},
source: sender
# Uncomment the following line to use a configuration set.
# configuration_set_name: configsetname,
)
puts "Email sent to #{recipient}"
# If something goes wrong, display an error message.
rescue Aws::SES::Errors::ServiceError => e
puts "Email not sent. Error message: #{e}"
end
```
+ Pour plus de détails sur l'API, voir [SendEmail](https://docs.aws.amazon.com/goto/SdkForRubyV3/email-2010-12-01/SendEmail)la section *Référence des AWS SDK pour Ruby API*.
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/ses#code-examples).
```
" Create message object
DATA(lo_subject) = NEW /aws1/cl_sescontent( iv_data = iv_subject ).
DATA(lo_text_body) = NEW /aws1/cl_sescontent( iv_data = iv_text ).
DATA(lo_html_body) = NEW /aws1/cl_sescontent( iv_data = iv_html ).
DATA(lo_body) = NEW /aws1/cl_sesbody(
io_text = lo_text_body
io_html = lo_html_body
).
DATA(lo_message) = NEW /aws1/cl_sesmessage(
io_subject = lo_subject
io_body = lo_body
).
TRY.
" Send email
DATA(lo_result) = lo_ses->sendemail(
iv_source = iv_source
io_destination = io_destination
io_message = lo_message
it_replytoaddresses = it_reply_tos
).
ov_msg_id = lo_result->get_messageid( ).
MESSAGE 'Email sent successfully' TYPE 'I'.
CATCH /aws1/cx_sesacctsendingpause00 INTO DATA(lo_ex1).
DATA(lv_error) = |Account sending paused: { lo_ex1->get_text( ) }|.
MESSAGE lv_error TYPE 'I'.
RAISE EXCEPTION lo_ex1.
CATCH /aws1/cx_sesmessagerejected INTO DATA(lo_ex2).
lv_error = |Message rejected: { lo_ex2->get_text( ) }|.
MESSAGE lv_error TYPE 'I'.
RAISE EXCEPTION lo_ex2.
CATCH /aws1/cx_rt_generic INTO DATA(lo_ex_generic).
lv_error = |An error occurred: { lo_ex_generic->get_text( ) }|.
MESSAGE lv_error TYPE 'I'.
RAISE EXCEPTION lo_ex_generic.
ENDTRY.
```
+ Pour plus de détails sur l'API, reportez-vous [SendEmail](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)à la section de référence du *AWS SDK pour l'API SAP ABAP*.
------
# Utilisation `SendRawEmail` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `SendRawEmail`.
------
#### [ CLI ]
**AWS CLI**
**Pour envoyer un e-mail brut à l’aide d’Amazon SES**
L’exemple suivant utilise la commande `send-raw-email` pour envoyer un e-mail avec une pièce jointe TXT :
```
aws ses send-raw-email --raw-message file://message.json
```
Sortie :
```
{
"MessageId": "EXAMPLEf3f73d99b-c63fb06f-d263-41f8-a0fb-d0dc67d56c07-000000"
}
```
Le message brut est une structure de données JSON enregistrée dans un fichier nommé `message.json` dans le répertoire actuel. Il contient les éléments suivants :
```
{
"Data": "From: sender@example.com\nTo: recipient@example.com\nSubject: Test email sent using the AWS CLI (contains an attachment)\nMIME-Version: 1.0\nContent-type: Multipart/Mixed; boundary=\"NextPart\"\n\n--NextPart\nContent-Type: text/plain\n\nThis is the message body.\n\n--NextPart\nContent-Type: text/plain;\nContent-Disposition: attachment; filename=\"attachment.txt\"\n\nThis is the text in the attachment.\n\n--NextPart--"
}
```
Comme vous pouvez le constater, « Data » est une longue chaîne contenant l’intégralité du contenu de l’e-mail brut au format MIME, y compris une pièce jointe appelée attachment.txt.
Remplacez sender@example.com et recipient@example.com par les adresses que vous souhaitez utiliser. Notez que l’adresse e-mail de l’expéditeur doit être vérifiée avec Amazon SES. Jusqu’à ce que vous obteniez un accès en production pour Amazon SES, vous devez également vérifier l’adresse e-mail du destinataire, sauf si le destinataire est le simulateur de boîte aux lettres Amazon SES. Pour plus d’informations sur la vérification, consultez Vérification des adresses e-mail et des domaines dans Amazon SES dans le *Guide du développeur Amazon Simple Email Service*.
L'ID du message dans la sortie indique que l'appel send-raw-email a réussi.
Si vous ne recevez pas l’e-mail, vérifiez votre boîte de courrier indésirable.
Pour plus d’informations sur l’envoi d’un e-mail brut, consultez Envoi d’e-mails bruts à l’aide de l’API Amazon SES dans le *Guide du développeur Amazon Simple Email Service*.
+ Pour plus de détails sur l'API, reportez-vous [SendRawEmail](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ses/send-raw-email.html)à la section *Référence des AWS CLI commandes*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
Utilisez [nodemailer](https://nodemailer.com/transports/ses) pour envoyer un e-mail avec une pièce jointe.
```
import sesClientModule from "@aws-sdk/client-ses";
/**
* nodemailer wraps the SES SDK and calls SendRawEmail. Use this for more advanced
* functionality like adding attachments to your email.
*
* https://nodemailer.com/transports/ses
*/
import nodemailer from "nodemailer";
/**
* @param {string} from An Amazon SES verified email address.
* @param {*} to An Amazon SES verified email address.
*/
export const sendEmailWithAttachments = (
from = "from@example.com",
to = "to@example.com",
) => {
const ses = new sesClientModule.SESClient({});
const transporter = nodemailer.createTransport({
SES: { ses, aws: sesClientModule },
});
return new Promise((resolve, reject) => {
transporter.sendMail(
{
from,
to,
subject: "Hello World",
text: "Greetings from Amazon SES!",
attachments: [{ content: "Hello World!", filename: "hello.txt" }],
},
(err, info) => {
if (err) {
reject(err);
} else {
resolve(info);
}
},
);
});
};
```
+ Pour plus de détails sur l'API, voir [SendRawEmail](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/SendRawEmailCommand)la section *Référence des AWS SDK pour JavaScript API*.
------
# Utilisation `SendTemplatedEmail` avec un AWS SDK
Les exemples de code suivants illustrent comment utiliser `SendTemplatedEmail`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Vérifier une identité d’e-mail et envoyer des messages](ses_example_ses_Scenario_SendEmail_section.md)
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/SES#code-examples).
```
///
/// Send an email using a template.
///
/// Address of the sender.
/// Addresses of the recipients.
/// Name of the email template.
/// Data for the email template.
/// The messageId of the email.
public async Task SendTemplateEmailAsync(string sender, List recipients,
string templateName, object templateDataObject)
{
var messageId = "";
try
{
// Template data should be serialized JSON from either a class or a dynamic object.
var templateData = JsonSerializer.Serialize(templateDataObject);
var response = await _amazonSimpleEmailService.SendTemplatedEmailAsync(
new SendTemplatedEmailRequest
{
Source = sender,
Destination = new Destination
{
ToAddresses = recipients
},
Template = templateName,
TemplateData = templateData
});
messageId = response.MessageId;
}
catch (Exception ex)
{
Console.WriteLine("SendTemplateEmailAsync failed with exception: " + ex.Message);
}
return messageId;
}
```
+ Pour plus de détails sur l'API, voir [SendTemplatedEmail](https://docs.aws.amazon.com/goto/DotNetSDKV3/email-2010-12-01/SendTemplatedEmail)la section *Référence des AWS SDK pour .NET API*.
------
#### [ C\$1\$1 ]
**SDK pour C\$1\$1**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ses#code-examples).
```
//! Send a templated email to a list of recipients.
/*!
\param recipients; Vector of recipient email addresses.
\param templateName: The name of the template to use.
\param templateData: Map of key-value pairs for replacing text in template.
\param senderEmailAddress: Email address of sender. Ignored if empty string.
\param ccAddresses: Vector of cc addresses. Ignored if empty.
\param replyToAddress: Reply to email address. Ignored if empty string.
\param clientConfiguration: AWS client configuration.
\return bool: Function succeeded.
*/
bool AwsDoc::SES::sendTemplatedEmail(const Aws::Vector &recipients,
const Aws::String &templateName,
const Aws::Map &templateData,
const Aws::String &senderEmailAddress,
const Aws::Vector &ccAddresses,
const Aws::String &replyToAddress,
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::SES::SESClient sesClient(clientConfiguration);
Aws::SES::Model::Destination destination;
if (!ccAddresses.empty()) {
destination.WithCcAddresses(ccAddresses);
}
if (!recipients.empty()) {
destination.WithToAddresses(recipients);
}
Aws::SES::Model::SendTemplatedEmailRequest sendTemplatedEmailRequest;
sendTemplatedEmailRequest.SetDestination(destination);
sendTemplatedEmailRequest.SetTemplate(templateName);
std::ostringstream templateDataStream;
templateDataStream << "{";
size_t dataCount = 0;
for (auto &pair: templateData) {
templateDataStream << "\"" << pair.first << "\":\"" << pair.second << "\"";
dataCount++;
if (dataCount < templateData.size()) {
templateDataStream << ",";
}
}
templateDataStream << "}";
sendTemplatedEmailRequest.SetTemplateData(templateDataStream.str());
if (!senderEmailAddress.empty()) {
sendTemplatedEmailRequest.SetSource(senderEmailAddress);
}
if (!replyToAddress.empty()) {
sendTemplatedEmailRequest.AddReplyToAddresses(replyToAddress);
}
auto outcome = sesClient.SendTemplatedEmail(sendTemplatedEmailRequest);
if (outcome.IsSuccess()) {
std::cout << "Successfully sent templated message with ID "
<< outcome.GetResult().GetMessageId()
<< "." << std::endl;
}
else {
std::cerr << "Error sending templated message. "
<< outcome.GetError().GetMessage()
<< std::endl;
}
return outcome.IsSuccess();
}
```
+ Pour plus de détails sur l'API, voir [SendTemplatedEmail](https://docs.aws.amazon.com/goto/SdkForCpp/email-2010-12-01/SendTemplatedEmail)la section *Référence des AWS SDK pour C\$1\$1 API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/ses#code-examples).
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sesv2.model.Destination;
import software.amazon.awssdk.services.sesv2.model.EmailContent;
import software.amazon.awssdk.services.sesv2.model.SendEmailRequest;
import software.amazon.awssdk.services.sesv2.model.SesV2Exception;
import software.amazon.awssdk.services.sesv2.SesV2Client;
import software.amazon.awssdk.services.sesv2.model.Template;
/**
* Before running this AWS SDK for Java (v2) example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*
* Also, make sure that you create a template. See the following documentation
* topic:
*
* https://docs.aws.amazon.com/ses/latest/dg/send-personalized-email-api.html
*/
public class SendEmailTemplate {
public static void main(String[] args) {
final String usage = """
Usage:
\s
Where:
template - The name of the email template.
sender - An email address that represents the sender.\s
recipient - An email address that represents the recipient.\s
""";
if (args.length != 3) {
System.out.println(usage);
System.exit(1);
}
String templateName = args[0];
String sender = args[1];
String recipient = args[2];
Region region = Region.US_EAST_1;
SesV2Client sesv2Client = SesV2Client.builder()
.region(region)
.build();
send(sesv2Client, sender, recipient, templateName);
}
public static void send(SesV2Client client, String sender, String recipient, String templateName) {
Destination destination = Destination.builder()
.toAddresses(recipient)
.build();
/*
* Specify both name and favorite animal (favoriteanimal) in your code when
* defining the Template object.
* If you don't specify all the variables in the template, Amazon SES doesn't
* send the email.
*/
Template myTemplate = Template.builder()
.templateName(templateName)
.templateData("{\n" +
" \"name\": \"Jason\"\n," +
" \"favoriteanimal\": \"Cat\"\n" +
"}")
.build();
EmailContent emailContent = EmailContent.builder()
.template(myTemplate)
.build();
SendEmailRequest emailRequest = SendEmailRequest.builder()
.destination(destination)
.content(emailContent)
.fromEmailAddress(sender)
.build();
try {
System.out.println("Attempting to send an email based on a template using the AWS SDK for Java (v2)...");
client.sendEmail(emailRequest);
System.out.println("email based on a template was sent");
} catch (SesV2Exception e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [SendTemplatedEmail](https://docs.aws.amazon.com/goto/SdkForJavaV2/email-2010-12-01/SendTemplatedEmail)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
import { SendTemplatedEmailCommand } from "@aws-sdk/client-ses";
import {
getUniqueName,
postfix,
} from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";
/**
* Replace this with the name of an existing template.
*/
const TEMPLATE_NAME = getUniqueName("ReminderTemplate");
/**
* Replace these with existing verified emails.
*/
const VERIFIED_EMAIL = postfix(getUniqueName("Bilbo"), "@example.com");
const USER = { firstName: "Bilbo", emailAddress: VERIFIED_EMAIL };
/**
*
* @param { { emailAddress: string, firstName: string } } user
* @param { string } templateName - The name of an existing template in Amazon SES.
* @returns { SendTemplatedEmailCommand }
*/
const createReminderEmailCommand = (user, templateName) => {
return new SendTemplatedEmailCommand({
/**
* Here's an example of how a template would be replaced with user data:
* Template: Hello {{contact.firstName}},
Don't forget about the party gifts!
* Destination: Hello Bilbo,
Don't forget about the party gifts!
*/
Destination: { ToAddresses: [user.emailAddress] },
TemplateData: JSON.stringify({ contact: { firstName: user.firstName } }),
Source: VERIFIED_EMAIL,
Template: templateName,
});
};
const run = async () => {
const sendReminderEmailCommand = createReminderEmailCommand(
USER,
TEMPLATE_NAME,
);
try {
return await sesClient.send(sendReminderEmailCommand);
} catch (caught) {
if (caught instanceof Error && caught.name === "MessageRejected") {
/** @type { import('@aws-sdk/client-ses').MessageRejected} */
const messageRejectedError = caught;
return messageRejectedError;
}
throw caught;
}
};
```
+ Pour plus de détails sur l'API, reportez-vous [SendTemplatedEmail](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/SendTemplatedEmailCommand)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/ses#code-examples).
```
class SesMailSender:
"""Encapsulates functions to send emails with Amazon SES."""
def __init__(self, ses_client):
"""
:param ses_client: A Boto3 Amazon SES client.
"""
self.ses_client = ses_client
def send_templated_email(
self, source, destination, template_name, template_data, reply_tos=None
):
"""
Sends an email based on a template. A template contains replaceable tags
each enclosed in two curly braces, such as {{name}}. The template data passed
in this function contains key-value pairs that define the values to insert
in place of the template tags.
Note: If your account is in the Amazon SES sandbox, the source and
destination email accounts must both be verified.
:param source: The source email account.
:param destination: The destination email account.
:param template_name: The name of a previously created template.
:param template_data: JSON-formatted key-value pairs of replacement values
that are inserted in the template before it is sent.
:return: The ID of the message, assigned by Amazon SES.
"""
send_args = {
"Source": source,
"Destination": destination.to_service_format(),
"Template": template_name,
"TemplateData": json.dumps(template_data),
}
if reply_tos is not None:
send_args["ReplyToAddresses"] = reply_tos
try:
response = self.ses_client.send_templated_email(**send_args)
message_id = response["MessageId"]
logger.info(
"Sent templated mail %s from %s to %s.",
message_id,
source,
destination.tos,
)
except ClientError:
logger.exception(
"Couldn't send templated mail from %s to %s.", source, destination.tos
)
raise
else:
return message_id
```
+ Pour plus de détails sur l'API, consultez [SendTemplatedEmail](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/SendTemplatedEmail)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/ses#code-examples).
```
TRY.
" Send templated email
DATA(lo_result) = lo_ses->sendtemplatedemail(
iv_source = iv_source
io_destination = io_destination
iv_template = iv_template_name
iv_templatedata = iv_template_data
it_replytoaddresses = it_reply_tos
).
ov_msg_id = lo_result->get_messageid( ).
MESSAGE 'Templated email sent successfully' TYPE 'I'.
CATCH /aws1/cx_sestmpldoesnotexistex INTO DATA(lo_ex1).
DATA(lv_error) = |Template does not exist: { lo_ex1->get_text( ) }|.
MESSAGE lv_error TYPE 'I'.
RAISE EXCEPTION lo_ex1.
CATCH /aws1/cx_rt_generic INTO DATA(lo_ex_generic).
lv_error = |An error occurred: { lo_ex_generic->get_text( ) }|.
MESSAGE lv_error TYPE 'I'.
RAISE EXCEPTION lo_ex_generic.
ENDTRY.
```
+ Pour plus de détails sur l'API, reportez-vous [SendTemplatedEmail](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)à la section de référence du *AWS SDK pour l'API SAP ABAP*.
------
# Utilisation `UpdateTemplate` avec un AWS SDK
Les exemples de code suivants illustrent comment utiliser `UpdateTemplate`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Vérifier une identité d’e-mail et envoyer des messages](ses_example_ses_Scenario_SendEmail_section.md)
------
#### [ C\$1\$1 ]
**SDK pour C\$1\$1**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ses#code-examples).
```
//! Update an Amazon Simple Email Service (Amazon SES) template.
/*!
\param templateName: The name of the template.
\param htmlPart: The HTML body of the email.
\param subjectPart: The subject line of the email.
\param textPart: The plain text version of the email.
\param clientConfiguration: AWS client configuration.
\return bool: Function succeeded.
*/
bool AwsDoc::SES::updateTemplate(const Aws::String &templateName,
const Aws::String &htmlPart,
const Aws::String &subjectPart,
const Aws::String &textPart,
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::SES::SESClient sesClient(clientConfiguration);
Aws::SES::Model::Template templateValues;
templateValues.SetTemplateName(templateName);
templateValues.SetSubjectPart(subjectPart);
templateValues.SetHtmlPart(htmlPart);
templateValues.SetTextPart(textPart);
Aws::SES::Model::UpdateTemplateRequest updateTemplateRequest;
updateTemplateRequest.SetTemplate(templateValues);
Aws::SES::Model::UpdateTemplateOutcome outcome = sesClient.UpdateTemplate(updateTemplateRequest);
if (outcome.IsSuccess()) {
std::cout << "Successfully updated template." << std::endl;
} else {
std::cerr << "Error updating template. " << outcome.GetError().GetMessage()
<< std::endl;
}
return outcome.IsSuccess();
}
```
+ Pour plus de détails sur l'API, reportez-vous [UpdateTemplate](https://docs.aws.amazon.com/goto/SdkForCpp/email-2010-12-01/UpdateTemplate)à la section *Référence des AWS SDK pour C\$1\$1 API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
import { UpdateTemplateCommand } from "@aws-sdk/client-ses";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";
const TEMPLATE_NAME = getUniqueName("TemplateName");
const HTML_PART = "Hello, World!
";
const createUpdateTemplateCommand = () => {
return new UpdateTemplateCommand({
Template: {
TemplateName: TEMPLATE_NAME,
HtmlPart: HTML_PART,
SubjectPart: "Example",
TextPart: "Updated template text.",
},
});
};
const run = async () => {
const updateTemplateCommand = createUpdateTemplateCommand();
try {
return await sesClient.send(updateTemplateCommand);
} catch (err) {
console.log("Failed to update template.", err);
return err;
}
};
```
+ Pour plus de détails sur l'API, reportez-vous [UpdateTemplate](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/UpdateTemplateCommand)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/ses#code-examples).
```
class SesTemplate:
"""Encapsulates Amazon SES template functions."""
def __init__(self, ses_client):
"""
:param ses_client: A Boto3 Amazon SES client.
"""
self.ses_client = ses_client
self.template = None
self.template_tags = set()
def _extract_tags(self, subject, text, html):
"""
Extracts tags from a template as a set of unique values.
:param subject: The subject of the email.
:param text: The text version of the email.
:param html: The html version of the email.
"""
self.template_tags = set(re.findall(TEMPLATE_REGEX, subject + text + html))
logger.info("Extracted template tags: %s", self.template_tags)
def update_template(self, name, subject, text, html):
"""
Updates a previously created email template.
:param name: The name of the template.
:param subject: The subject of the email.
:param text: The plain text version of the email.
:param html: The HTML version of the email.
"""
try:
template = {
"TemplateName": name,
"SubjectPart": subject,
"TextPart": text,
"HtmlPart": html,
}
self.ses_client.update_template(Template=template)
logger.info("Updated template %s.", name)
self.template = template
self._extract_tags(subject, text, html)
except ClientError:
logger.exception("Couldn't update template %s.", name)
raise
```
+ Pour plus de détails sur l'API, consultez [UpdateTemplate](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/UpdateTemplate)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/ses#code-examples).
```
DATA(lo_template) = NEW /aws1/cl_sestemplate(
iv_templatename = iv_name
iv_subjectpart = iv_subject
iv_textpart = iv_text
iv_htmlpart = iv_html
).
TRY.
lo_ses->updatetemplate( io_template = lo_template ).
MESSAGE 'Template updated successfully' TYPE 'I'.
CATCH /aws1/cx_sestmpldoesnotexistex INTO DATA(lo_ex1).
DATA(lv_error) = |Template does not exist: { lo_ex1->get_text( ) }|.
MESSAGE lv_error TYPE 'I'.
RAISE EXCEPTION lo_ex1.
CATCH /aws1/cx_sesinvalidtemplateex INTO DATA(lo_ex2).
lv_error = |Invalid template: { lo_ex2->get_text( ) }|.
MESSAGE lv_error TYPE 'I'.
RAISE EXCEPTION lo_ex2.
CATCH /aws1/cx_rt_generic INTO DATA(lo_ex_generic).
lv_error = |An error occurred: { lo_ex_generic->get_text( ) }|.
MESSAGE lv_error TYPE 'I'.
RAISE EXCEPTION lo_ex_generic.
ENDTRY.
```
+ Pour plus de détails sur l'API, reportez-vous [UpdateTemplate](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)à la section de référence du *AWS SDK pour l'API SAP ABAP*.
------
# Utilisation `VerifyDomainIdentity` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `VerifyDomainIdentity`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans les exemples de code suivants :
+ [Copier les identités de domaine et d’e-mail dans les régions](ses_example_ses_Scenario_ReplicateIdentities_section.md)
+ [Vérifier une identité d’e-mail et envoyer des messages](ses_example_ses_Scenario_SendEmail_section.md)
------
#### [ CLI ]
**AWS CLI**
**Pour vérifier un domaine avec Amazon SES**
L’exemple suivant utilise la commande `verify-domain-identity` pour vérifier un domaine :
```
aws ses verify-domain-identity --domain example.com
```
Sortie :
```
{
"VerificationToken": "eoEmxw+YaYhb3h3iVJHuXMJXqeu1q1/wwmvjuEXAMPLE"
}
```
Pour terminer la vérification du domaine, vous devez ajouter un enregistrement TXT avec le jeton de vérification renvoyé aux paramètres DNS de votre domaine. Pour plus d’informations, consultez Vérification des domaines dans Amazon SES dans le *Guide du développeur Amazon Simple Email Service*.
+ Pour plus de détails sur l'API, reportez-vous [VerifyDomainIdentity](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ses/verify-domain-identity.html)à la section *Référence des AWS CLI commandes*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
import { VerifyDomainIdentityCommand } from "@aws-sdk/client-ses";
import {
getUniqueName,
postfix,
} from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";
/**
* You must have access to the domain's DNS settings to complete the
* domain verification process.
*/
const DOMAIN_NAME = postfix(getUniqueName("Domain"), ".example.com");
const createVerifyDomainIdentityCommand = () => {
return new VerifyDomainIdentityCommand({ Domain: DOMAIN_NAME });
};
const run = async () => {
const VerifyDomainIdentityCommand = createVerifyDomainIdentityCommand();
try {
return await sesClient.send(VerifyDomainIdentityCommand);
} catch (err) {
console.log("Failed to verify domain.", err);
return err;
}
};
```
+ Pour plus de détails sur l'API, reportez-vous [VerifyDomainIdentity](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/VerifyDomainIdentityCommand)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/ses#code-examples).
```
class SesIdentity:
"""Encapsulates Amazon SES identity functions."""
def __init__(self, ses_client):
"""
:param ses_client: A Boto3 Amazon SES client.
"""
self.ses_client = ses_client
def verify_domain_identity(self, domain_name):
"""
Starts verification of a domain identity. To complete verification, you must
create a TXT record with a specific format through your DNS provider.
For more information, see *Verifying a domain with Amazon SES* in the
Amazon SES documentation:
https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-domain-procedure.html
:param domain_name: The name of the domain to verify.
:return: The token to include in the TXT record with your DNS provider.
"""
try:
response = self.ses_client.verify_domain_identity(Domain=domain_name)
token = response["VerificationToken"]
logger.info("Got domain verification token for %s.", domain_name)
except ClientError:
logger.exception("Couldn't verify domain %s.", domain_name)
raise
else:
return token
```
+ Pour plus de détails sur l'API, consultez [VerifyDomainIdentity](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/VerifyDomainIdentity)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/ses#code-examples).
```
TRY.
DATA(lo_result) = lo_ses->verifydomainidentity( iv_domain = iv_domain_name ).
ov_token = lo_result->get_verificationtoken( ).
MESSAGE 'Domain verification initiated' TYPE 'I'.
CATCH /aws1/cx_rt_generic INTO DATA(lo_ex).
DATA(lv_error) = |An error occurred: { lo_ex->get_text( ) }|.
MESSAGE lv_error TYPE 'I'.
RAISE EXCEPTION lo_ex.
ENDTRY.
```
+ Pour plus de détails sur l'API, reportez-vous [VerifyDomainIdentity](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)à la section de référence du *AWS SDK pour l'API SAP ABAP*.
------
# Utilisation `VerifyEmailIdentity` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `VerifyEmailIdentity`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans les exemples de code suivants :
+ [Copier les identités de domaine et d’e-mail dans les régions](ses_example_ses_Scenario_ReplicateIdentities_section.md)
+ [Vérifier une identité d’e-mail et envoyer des messages](ses_example_ses_Scenario_SendEmail_section.md)
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/SES#code-examples).
```
///
/// Starts verification of an email identity. This request sends an email
/// from Amazon SES to the specified email address. To complete
/// verification, follow the instructions in the email.
///
/// Email address to verify.
/// True if successful.
public async Task VerifyEmailIdentityAsync(string recipientEmailAddress)
{
var success = false;
try
{
var response = await _amazonSimpleEmailService.VerifyEmailIdentityAsync(
new VerifyEmailIdentityRequest
{
EmailAddress = recipientEmailAddress
});
success = response.HttpStatusCode == HttpStatusCode.OK;
}
catch (Exception ex)
{
Console.WriteLine("VerifyEmailIdentityAsync failed with exception: " + ex.Message);
}
return success;
}
```
+ Pour plus de détails sur l'API, reportez-vous [VerifyEmailIdentity](https://docs.aws.amazon.com/goto/DotNetSDKV3/email-2010-12-01/VerifyEmailIdentity)à la section *Référence des AWS SDK pour .NET API*.
------
#### [ C\$1\$1 ]
**SDK pour C\$1\$1**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ses#code-examples).
```
//! Add an email address to the list of identities associated with this account and
//! initiate verification.
/*!
\param emailAddress; The email address to add.
\param clientConfiguration: AWS client configuration.
\return bool: Function succeeded.
*/
bool AwsDoc::SES::verifyEmailIdentity(const Aws::String &emailAddress,
const Aws::Client::ClientConfiguration &clientConfiguration)
{
Aws::SES::SESClient sesClient(clientConfiguration);
Aws::SES::Model::VerifyEmailIdentityRequest verifyEmailIdentityRequest;
verifyEmailIdentityRequest.SetEmailAddress(emailAddress);
Aws::SES::Model::VerifyEmailIdentityOutcome outcome = sesClient.VerifyEmailIdentity(verifyEmailIdentityRequest);
if (outcome.IsSuccess())
{
std::cout << "Email verification initiated." << std::endl;
}
else
{
std::cerr << "Error initiating email verification. " << outcome.GetError().GetMessage()
<< std::endl;
}
return outcome.IsSuccess();
}
```
+ Pour plus de détails sur l'API, reportez-vous [VerifyEmailIdentity](https://docs.aws.amazon.com/goto/SdkForCpp/email-2010-12-01/VerifyEmailIdentity)à la section *Référence des AWS SDK pour C\$1\$1 API*.
------
#### [ CLI ]
**AWS CLI**
**Pour vérifier une adresse e-mail avec Amazon SES**
L’exemple suivant utilise la commande `verify-email-identity` pour vérifier une adresse e-mail :
```
aws ses verify-email-identity --email-address user@example.com
```
Avant de pouvoir envoyer un e-mail avec Amazon SES, vous devez vérifier l’adresse ou le domaine à partir desquels vous envoyez l’e-mail afin de prouver que vous en êtes le propriétaire. Si vous n’avez pas encore l’accès en production, vous devez également vérifier toutes les adresses e-mail des destinataires, à l’exception de celles fournies par le simulateur de boîte aux lettres Amazon SES.
Après avoir été verify-email-identity appelée, l'adresse e-mail recevra un e-mail de vérification. L’utilisateur doit cliquer sur le lien disponible dans l’e-mail pour terminer le processus de vérification.
Pour plus d’informations, consultez Vérification des adresses e-mail dans Amazon SES dans le *Guide du développeur Amazon Simple Email Service*.
+ Pour plus de détails sur l'API, reportez-vous [VerifyEmailIdentity](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ses/verify-email-identity.html)à la section *Référence des AWS CLI commandes*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
// Import required AWS SDK clients and commands for Node.js
import { VerifyEmailIdentityCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";
const EMAIL_ADDRESS = "name@example.com";
const createVerifyEmailIdentityCommand = (emailAddress) => {
return new VerifyEmailIdentityCommand({ EmailAddress: emailAddress });
};
const run = async () => {
const verifyEmailIdentityCommand =
createVerifyEmailIdentityCommand(EMAIL_ADDRESS);
try {
return await sesClient.send(verifyEmailIdentityCommand);
} catch (err) {
console.log("Failed to verify email identity.", err);
return err;
}
};
```
+ Pour plus de détails sur l'API, reportez-vous [VerifyEmailIdentity](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/VerifyEmailIdentityCommand)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/ses#code-examples).
```
class SesIdentity:
"""Encapsulates Amazon SES identity functions."""
def __init__(self, ses_client):
"""
:param ses_client: A Boto3 Amazon SES client.
"""
self.ses_client = ses_client
def verify_email_identity(self, email_address):
"""
Starts verification of an email identity. This function causes an email
to be sent to the specified email address from Amazon SES. To complete
verification, follow the instructions in the email.
:param email_address: The email address to verify.
"""
try:
self.ses_client.verify_email_identity(EmailAddress=email_address)
logger.info("Started verification of %s.", email_address)
except ClientError:
logger.exception("Couldn't start verification of %s.", email_address)
raise
```
+ Pour plus de détails sur l'API, consultez [VerifyEmailIdentity](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/VerifyEmailIdentity)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
#### [ Ruby ]
**Kit SDK pour Ruby**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/ses/v1#code-examples).
```
require 'aws-sdk-ses' # v2: require 'aws-sdk'
# Replace recipient@example.com with a "To" address.
recipient = 'recipient@example.com'
# Create a new SES resource in the us-west-2 region.
# Replace us-west-2 with the AWS Region you're using for Amazon SES.
ses = Aws::SES::Client.new(region: 'us-west-2')
# Try to verify email address.
begin
ses.verify_email_identity({
email_address: recipient
})
puts "Email sent to #{recipient}"
# If something goes wrong, display an error message.
rescue Aws::SES::Errors::ServiceError => e
puts "Email not sent. Error message: #{e}"
end
```
+ Pour plus de détails sur l'API, reportez-vous [VerifyEmailIdentity](https://docs.aws.amazon.com/goto/SdkForRubyV3/email-2010-12-01/VerifyEmailIdentity)à la section *Référence des AWS SDK pour Ruby API*.
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/ses#code-examples).
```
TRY.
lo_ses->verifyemailidentity( iv_emailaddress = iv_email_address ).
MESSAGE 'Email verification initiated' TYPE 'I'.
CATCH /aws1/cx_rt_generic INTO DATA(lo_ex).
DATA(lv_error) = |An error occurred: { lo_ex->get_text( ) }|.
MESSAGE lv_error TYPE 'I'.
RAISE EXCEPTION lo_ex.
ENDTRY.
```
+ Pour plus de détails sur l'API, reportez-vous [VerifyEmailIdentity](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)à la section de référence du *AWS SDK pour l'API SAP ABAP*.
------
# Scénarios d'utilisation d'Amazon SES AWS SDKs
Les exemples de code suivants vous montrent comment implémenter des scénarios courants dans Amazon SES avec AWS SDKs. Ces scénarios vous montrent comment accomplir des tâches spécifiques en appelant plusieurs fonctions dans Amazon SES ou en les combinant avec d’autres Services AWS. Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code.
Les scénarios ciblent un niveau d’expérience intermédiaire pour vous aider à comprendre les actions de service dans leur contexte.
**Topics**
+ [Créer une application de streaming Amazon Transcribe](ses_example_cross_TranscriptionStreamingApp_section.md)
+ [Copier les identités de domaine et d’e-mail dans les régions](ses_example_ses_Scenario_ReplicateIdentities_section.md)
+ [Créer une application web pour suivre les données DynamoDB](ses_example_cross_DynamoDBDataTracker_section.md)
+ [Créer une application web pour suivre les données Amazon Redshift](ses_example_cross_RedshiftDataTracker_section.md)
+ [Créer un outil de suivi des éléments de travail sans serveur Aurora](ses_example_cross_RDSDataTracker_section.md)
+ [Détecter l’EPI dans des images](ses_example_cross_RekognitionPhotoAnalyzerPPE_section.md)
+ [Détecter des objets dans des images](ses_example_cross_RekognitionPhotoAnalyzer_section.md)
+ [Détecter des personnes et des objets dans une vidéo](ses_example_cross_RekognitionVideoDetection_section.md)
+ [Générer des informations d’identification pour vous connecter à un point de terminaison d’un SMTP](ses_example_ses_Scenario_GenerateSmtpCredentials_section.md)
+ [Utiliser les fonctions Step Functions pour invoquer des fonctions Lambda](ses_example_cross_ServerlessWorkflows_section.md)
+ [Vérifier une identité d’e-mail et envoyer des messages](ses_example_ses_Scenario_SendEmail_section.md)
# Créer une application de streaming Amazon Transcribe
L’exemple de code suivant montre comment créer une application qui enregistre, transcrit et traduit de l’audio en direct en temps réel, et envoie les résultats par e-mail.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Montre comment utiliser Amazon Transcribe afin de créer une application qui enregistre, transcrit et traduit de l’audio en direct en temps réel, et envoie les résultats par e-mail à l’aide d’Amazon Simple Email Service (Amazon SES).
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/transcribe-streaming-app).
**Les services utilisés dans cet exemple**
+ Amazon Comprehend
+ Amazon SES
+ Amazon Transcribe
+ Amazon Translate
------
# Copiez les adresses e-mail et les identités de domaine Amazon SES d'une AWS région à l'autre à l'aide d'un AWS SDK
L'exemple de code suivant montre comment copier les adresses e-mail et les identités de domaine Amazon SES d'une AWS région à l'autre. Lorsque les identités de domaine sont gérées par Route 53, les registres de vérification sont copiés dans le domaine de la Région de destination.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/ses#code-examples).
```
import argparse
import json
import logging
from pprint import pprint
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def get_identities(ses_client):
"""
Gets the identities for the current Region. The Region is specified in the
Boto3 Amazon SES client object.
:param ses_client: A Boto3 Amazon SES client.
:return: The list of email identities and the list of domain identities.
"""
email_identities = []
domain_identities = []
try:
identity_paginator = ses_client.get_paginator("list_identities")
identity_iterator = identity_paginator.paginate(
PaginationConfig={"PageSize": 20}
)
for identity_page in identity_iterator:
for identity in identity_page["Identities"]:
if "@" in identity:
email_identities.append(identity)
else:
domain_identities.append(identity)
logger.info(
"Found %s email and %s domain identities.",
len(email_identities),
len(domain_identities),
)
except ClientError:
logger.exception("Couldn't get identities.")
raise
else:
return email_identities, domain_identities
def verify_emails(email_list, ses_client):
"""
Starts verification of a list of email addresses. Verification causes an email
to be sent to each address. To complete verification, the recipient must follow
the instructions in the email.
:param email_list: The list of email addresses to verify.
:param ses_client: A Boto3 Amazon SES client.
:return: The list of emails that were successfully submitted for verification.
"""
verified_emails = []
for email in email_list:
try:
ses_client.verify_email_identity(EmailAddress=email)
verified_emails.append(email)
logger.info("Started verification of %s.", email)
except ClientError:
logger.warning("Couldn't start verification of %s.", email)
return verified_emails
def verify_domains(domain_list, ses_client):
"""
Starts verification for a list of domain identities. This returns a token for
each domain, which must be registered as a TXT record with the DNS provider for
the domain.
:param domain_list: The list of domains to verify.
:param ses_client: A Boto3 Amazon SES client.
:return: The generated domain tokens to use to completed verification.
"""
domain_tokens = {}
for domain in domain_list:
try:
response = ses_client.verify_domain_identity(Domain=domain)
token = response["VerificationToken"]
domain_tokens[domain] = token
logger.info("Got verification token %s for domain %s.", token, domain)
except ClientError:
logger.warning("Couldn't get verification token for domain %s.", domain)
return domain_tokens
def get_hosted_zones(route53_client):
"""
Gets the Amazon Route 53 hosted zones for the current account.
:param route53_client: A Boto3 Route 53 client.
:return: The list of hosted zones.
"""
zones = []
try:
zone_paginator = route53_client.get_paginator("list_hosted_zones")
zone_iterator = zone_paginator.paginate(PaginationConfig={"PageSize": 20})
zones = [
zone for zone_page in zone_iterator for zone in zone_page["HostedZones"]
]
logger.info("Found %s hosted zones.", len(zones))
except ClientError:
logger.warning("Couldn't get hosted zones.")
return zones
def find_domain_zone_matches(domains, zones):
"""
Finds matches between Amazon SES verified domains and Route 53 hosted zones.
Subdomain matches are taken when found, otherwise root domain matches are taken.
:param domains: The list of domains to match.
:param zones: The list of hosted zones to match.
:return: The set of matched domain-zone pairs. When a match is not found, the
domain is included in the set with a zone value of None.
"""
domain_zones = {}
for domain in domains:
domain_zones[domain] = None
# Start at the most specific sub-domain and walk up to the root domain until a
# zone match is found.
domain_split = domain.split(".")
for index in range(0, len(domain_split) - 1):
sub_domain = ".".join(domain_split[index:])
for zone in zones:
# Normalize the zone name from Route 53 by removing the trailing '.'.
zone_name = zone["Name"][:-1]
if sub_domain == zone_name:
domain_zones[domain] = zone
break
if domain_zones[domain] is not None:
break
return domain_zones
def add_route53_verification_record(domain, token, zone, route53_client):
"""
Adds a domain verification TXT record to the specified Route 53 hosted zone.
When a TXT record already exists in the hosted zone for the specified domain,
the existing values are preserved and the new token is added to the list.
:param domain: The domain to add.
:param token: The verification token for the domain.
:param zone: The hosted zone where the domain verification record is added.
:param route53_client: A Boto3 Route 53 client.
"""
domain_token_record_set_name = f"_amazonses.{domain}"
record_set_paginator = route53_client.get_paginator("list_resource_record_sets")
record_set_iterator = record_set_paginator.paginate(
HostedZoneId=zone["Id"], PaginationConfig={"PageSize": 20}
)
records = []
for record_set_page in record_set_iterator:
try:
txt_record_set = next(
record_set
for record_set in record_set_page["ResourceRecordSets"]
if record_set["Name"][:-1] == domain_token_record_set_name
and record_set["Type"] == "TXT"
)
records = txt_record_set["ResourceRecords"]
logger.info(
"Existing TXT record found in set %s for zone %s.",
domain_token_record_set_name,
zone["Name"],
)
break
except StopIteration:
pass
records.append({"Value": json.dumps(token)})
changes = [
{
"Action": "UPSERT",
"ResourceRecordSet": {
"Name": domain_token_record_set_name,
"Type": "TXT",
"TTL": 1800,
"ResourceRecords": records,
},
}
]
try:
route53_client.change_resource_record_sets(
HostedZoneId=zone["Id"], ChangeBatch={"Changes": changes}
)
logger.info(
"Created or updated the TXT record in set %s for zone %s.",
domain_token_record_set_name,
zone["Name"],
)
except ClientError as err:
logger.warning(
"Got error %s. Couldn't create or update the TXT record for zone %s.",
err.response["Error"]["Code"],
zone["Name"],
)
def generate_dkim_tokens(domain, ses_client):
"""
Generates DKIM tokens for a domain. These must be added as CNAME records to the
DNS provider for the domain.
:param domain: The domain to generate tokens for.
:param ses_client: A Boto3 Amazon SES client.
:return: The list of generated DKIM tokens.
"""
dkim_tokens = []
try:
dkim_tokens = ses_client.verify_domain_dkim(Domain=domain)["DkimTokens"]
logger.info("Generated %s DKIM tokens for domain %s.", len(dkim_tokens), domain)
except ClientError:
logger.warning("Couldn't generate DKIM tokens for domain %s.", domain)
return dkim_tokens
def add_dkim_domain_tokens(hosted_zone, domain, tokens, route53_client):
"""
Adds DKIM domain token CNAME records to a Route 53 hosted zone.
:param hosted_zone: The hosted zone where the records are added.
:param domain: The domain to add.
:param tokens: The DKIM tokens for the domain to add.
:param route53_client: A Boto3 Route 53 client.
"""
try:
changes = [
{
"Action": "UPSERT",
"ResourceRecordSet": {
"Name": f"{token}._domainkey.{domain}",
"Type": "CNAME",
"TTL": 1800,
"ResourceRecords": [{"Value": f"{token}.dkim.amazonses.com"}],
},
}
for token in tokens
]
route53_client.change_resource_record_sets(
HostedZoneId=hosted_zone["Id"], ChangeBatch={"Changes": changes}
)
logger.info(
"Added %s DKIM CNAME records to %s in zone %s.",
len(tokens),
domain,
hosted_zone["Name"],
)
except ClientError:
logger.warning(
"Couldn't add DKIM CNAME records for %s to zone %s.",
domain,
hosted_zone["Name"],
)
def configure_sns_topics(identity, topics, ses_client):
"""
Configures Amazon Simple Notification Service (Amazon SNS) notifications for
an identity. The Amazon SNS topics must already exist.
:param identity: The identity to configure.
:param topics: The list of topics to configure. The choices are Bounce, Delivery,
or Complaint.
:param ses_client: A Boto3 Amazon SES client.
"""
for topic in topics:
topic_arn = input(
f"Enter the Amazon Resource Name (ARN) of the {topic} topic or press "
f"Enter to skip: "
)
if topic_arn != "":
try:
ses_client.set_identity_notification_topic(
Identity=identity, NotificationType=topic, SnsTopic=topic_arn
)
logger.info("Configured %s for %s notifications.", identity, topic)
except ClientError:
logger.warning(
"Couldn't configure %s for %s notifications.", identity, topic
)
def replicate(source_client, destination_client, route53_client):
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
print("-" * 88)
print(
f"Replicating Amazon SES identities and other configuration from "
f"{source_client.meta.region_name} to {destination_client.meta.region_name}."
)
print("-" * 88)
print(f"Retrieving identities from {source_client.meta.region_name}.")
source_emails, source_domains = get_identities(source_client)
print("Email addresses found:")
print(*source_emails)
print("Domains found:")
print(*source_domains)
print("Starting verification for email identities.")
dest_emails = verify_emails(source_emails, destination_client)
print("Getting domain tokens for domain identities.")
dest_domain_tokens = verify_domains(source_domains, destination_client)
# Get Route 53 hosted zones and match them with Amazon SES domains.
answer = input(
"Is the DNS configuration for your domains managed by Amazon Route 53 (y/n)? "
)
use_route53 = answer.lower() == "y"
hosted_zones = get_hosted_zones(route53_client) if use_route53 else []
if use_route53:
print("Adding or updating Route 53 TXT records for your domains.")
domain_zones = find_domain_zone_matches(dest_domain_tokens.keys(), hosted_zones)
for domain in domain_zones:
add_route53_verification_record(
domain, dest_domain_tokens[domain], domain_zones[domain], route53_client
)
else:
print(
"Use these verification tokens to create TXT records through your DNS "
"provider:"
)
pprint(dest_domain_tokens)
answer = input("Do you want to configure DKIM signing for your identities (y/n)? ")
if answer.lower() == "y":
# Build a set of unique domains from email and domain identities.
domains = {email.split("@")[1] for email in dest_emails}
domains.update(dest_domain_tokens)
domain_zones = find_domain_zone_matches(domains, hosted_zones)
for domain, zone in domain_zones.items():
answer = input(
f"Do you want to configure DKIM signing for {domain} (y/n)? "
)
if answer.lower() == "y":
dkim_tokens = generate_dkim_tokens(domain, destination_client)
if use_route53 and zone is not None:
add_dkim_domain_tokens(zone, domain, dkim_tokens, route53_client)
else:
print(
"Add the following DKIM tokens as CNAME records through your "
"DNS provider:"
)
print(*dkim_tokens, sep="\n")
answer = input(
"Do you want to configure Amazon SNS notifications for your identities (y/n)? "
)
if answer.lower() == "y":
for identity in dest_emails + list(dest_domain_tokens.keys()):
answer = input(
f"Do you want to configure Amazon SNS topics for {identity} (y/n)? "
)
if answer.lower() == "y":
configure_sns_topics(
identity, ["Bounce", "Delivery", "Complaint"], destination_client
)
print(f"Replication complete for {destination_client.meta.region_name}.")
print("-" * 88)
def main():
boto3_session = boto3.Session()
ses_regions = boto3_session.get_available_regions("ses")
parser = argparse.ArgumentParser(
description="Copies email address and domain identities from one AWS Region to "
"another. Optionally adds records for domain verification and DKIM "
"signing to domains that are managed by Amazon Route 53, "
"and sets up Amazon SNS notifications for events of interest."
)
parser.add_argument(
"source_region", choices=ses_regions, help="The region to copy from."
)
parser.add_argument(
"destination_region", choices=ses_regions, help="The region to copy to."
)
args = parser.parse_args()
source_client = boto3.client("ses", region_name=args.source_region)
destination_client = boto3.client("ses", region_name=args.destination_region)
route53_client = boto3.client("route53")
replicate(source_client, destination_client, route53_client)
if __name__ == "__main__":
main()
```
+ Pour plus d’informations sur l’API, consultez les rubriques suivantes dans *AWS SDK for Python (Boto3) API Reference*.
+ [ListIdentities](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/ListIdentities)
+ [SetIdentityNotificationTopic](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/SetIdentityNotificationTopic)
+ [VerifyDomainDkim](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/VerifyDomainDkim)
+ [VerifyDomainIdentity](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/VerifyDomainIdentity)
+ [VerifyEmailIdentity](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/VerifyEmailIdentity)
------
# Créer une application web pour suivre les données DynamoDB
Les exemples de code suivants montrent comment créer une application web qui suit des éléments de travail dans une table Amazon DynamoDB et envoie des rapports par e-mail à l’aide d’Amazon Simple Email Service (Amazon SES).
------
#### [ .NET ]
**SDK pour .NET**
Montre comment utiliser l’API Amazon DynamoDB .NET pour créer une application web dynamique qui suit les données de travail DynamoDB.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/DynamoDbItemTracker).
**Les services utilisés dans cet exemple**
+ DynamoDB
+ Amazon SES
------
#### [ Java ]
**SDK pour Java 2.x**
Montre comment utiliser l’API Amazon DynamoDB pour créer une application web dynamique qui suit les données de travail DynamoDB.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/creating_dynamodb_web_app).
**Les services utilisés dans cet exemple**
+ DynamoDB
+ Amazon SES
------
#### [ Kotlin ]
**SDK pour Kotlin**
Montre comment utiliser l’API Amazon DynamoDB pour créer une application web dynamique qui suit les données de travail DynamoDB.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/usecases/itemtracker_dynamodb).
**Les services utilisés dans cet exemple**
+ DynamoDB
+ Amazon SES
------
#### [ Python ]
**SDK pour Python (Boto3)**
Montre comment utiliser le AWS SDK pour Python (Boto3) pour créer un service REST qui suit les éléments de travail dans Amazon DynamoDB et envoie des rapports par e-mail à l'aide d'Amazon Simple Email Service (Amazon SES). Cet exemple utilise la structure web Flask pour gérer le routage HTTP et s’intègre à une page web React pour présenter une application web entièrement fonctionnelle.
+ Créez un service Flask REST qui s'intègre à Services AWS.
+ Lisez, écrivez et mettez à jour les éléments de travail stockés dans une table DynamoDB.
+ Utilisez Amazon SES pour envoyer des rapports par e-mail sur les éléments de travail.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet dans le [référentiel d'exemples de AWS code](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/dynamodb_item_tracker) sur GitHub.
**Les services utilisés dans cet exemple**
+ DynamoDB
+ Amazon SES
------
# Créer un outil de suivi des éléments Amazon Redshift.
Les exemples de code suivants montrent comment créer une application web qui suit et crée des rapports sur les éléments de travail à l’aide d’une base de données Amazon Redshift.
------
#### [ Java ]
**SDK pour Java 2.x**
Montre comment créer une application web qui suit et génère des rapports sur les éléments de travail stockés dans une base de données Amazon Redshift.
Pour obtenir le code source complet et les instructions sur la façon de configurer une API Spring REST qui interroge les données Amazon Redshift et pour une utilisation par une application React, consultez l'exemple complet sur. [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/CreatingSpringRedshiftRest)
**Les services utilisés dans cet exemple**
+ Amazon Redshift
+ Amazon SES
------
#### [ Kotlin ]
**SDK pour Kotlin**
Montre comment créer une application web qui suit et génère des rapports sur les éléments de travail stockés dans une base de données Amazon Redshift.
Pour obtenir le code source complet et les instructions sur la façon de configurer une API Spring REST qui interroge les données Amazon Redshift et pour une utilisation par une application React, consultez l'exemple complet sur. [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/usecases/creating_redshift_application)
**Les services utilisés dans cet exemple**
+ Amazon Redshift
+ Amazon SES
------
# Créer un outil de suivi des éléments de travail sans serveur Aurora
Les exemples de code suivants montrent comment créer une application web qui suit des éléments de travail dans une base de données Amazon Aurora sans serveur et envoie des rapports par e-mail à l’aide d’Amazon Simple Email Service (Amazon SES).
------
#### [ .NET ]
**SDK pour .NET**
Montre comment utiliser le AWS SDK pour .NET pour créer une application Web qui suit les éléments de travail dans une base de données Amazon Aurora et envoie des rapports par e-mail à l'aide d'Amazon Simple Email Service (Amazon SES). Cet exemple utilise un front-end créé avec React.js pour interagir avec un backend RESTful .NET.
+ Intégrez une application Web React à AWS des services.
+ Listez, ajoutez et mettez à jour des éléments dans une table Aurora.
+ Envoyez un rapport par e-mail sur les éléments de travail filtrés à l’aide d’Amazon SES.
+ Déployez et gérez des exemples de ressources à l'aide du AWS CloudFormation script inclus.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/AuroraItemTracker).
**Les services utilisés dans cet exemple**
+ Aurora
+ Amazon RDS
+ Services de données Amazon RDS
+ Amazon SES
------
#### [ C\$1\$1 ]
**SDK pour C\$1\$1**
Montre comment créer une application web qui suit et génère des rapports sur les éléments de travail stockés dans une base de données Amazon Aurora sans serveur.
Pour obtenir le code source complet et les instructions sur la façon de configurer une API REST C\$1\$1 qui interroge les données Amazon Aurora Serverless et à utiliser par une application React, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cross-service/serverless-aurora).
**Les services utilisés dans cet exemple**
+ Aurora
+ Amazon RDS
+ Services de données Amazon RDS
+ Amazon SES
------
#### [ Java ]
**SDK pour Java 2.x**
Montre comment créer une application web qui suit et génère des rapports sur les éléments de travail stockés dans une base de données Amazon RDS.
Pour obtenir le code source complet et les instructions sur la façon de configurer une API Spring REST qui interroge les données Amazon Aurora Serverless et pour une utilisation par une application React, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/Creating_Spring_RDS_Rest).
Pour obtenir le code source complet et les instructions sur la façon de configurer et d'exécuter un exemple utilisant l'API JDBC, consultez l'exemple complet sur. [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/Creating_rds_item_tracker)
**Les services utilisés dans cet exemple**
+ Aurora
+ Amazon RDS
+ Services de données Amazon RDS
+ Amazon SES
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Montre comment utiliser le AWS SDK pour JavaScript (v3) pour créer une application Web qui suit les éléments de travail dans une base de données Amazon Aurora et envoie des rapports par e-mail à l'aide d'Amazon Simple Email Service (Amazon SES). Cet exemple utilise un front end créé avec React.js pour interagir avec un backend Express Node.js.
+ Intégrez une application Web React.js à Services AWS.
+ Lister, ajouter et mettre à jour des éléments dans une table Aurora.
+ Envoyez un rapport par e-mail sur les éléments de travail filtrés en utilisant Amazon SES.
+ Déployez et gérez des exemples de ressources à l'aide du AWS CloudFormation script inclus.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/aurora-serverless-app).
**Les services utilisés dans cet exemple**
+ Aurora
+ Amazon RDS
+ Services de données Amazon RDS
+ Amazon SES
------
#### [ Kotlin ]
**SDK pour Kotlin**
Montre comment créer une application web qui suit et génère des rapports sur les éléments de travail stockés dans une base de données Amazon RDS.
Pour obtenir le code source complet et les instructions sur la façon de configurer une API Spring REST qui interroge les données Amazon Aurora Serverless et pour une utilisation par une application React, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/usecases/serverless_rds).
**Les services utilisés dans cet exemple**
+ Aurora
+ Amazon RDS
+ Services de données Amazon RDS
+ Amazon SES
------
#### [ PHP ]
**Kit SDK pour PHP**
Montre comment utiliser le AWS SDK pour PHP pour créer une application Web qui suit les éléments de travail dans une base de données Amazon RDS et envoie des rapports par e-mail à l'aide d'Amazon Simple Email Service (Amazon SES). Cet exemple utilise une interface créée avec React.js pour interagir avec un backend RESTful PHP.
+ Intégrez une application Web React.js à AWS des services.
+ Répertoriez, ajoutez, mettez à jour et supprimez des éléments dans une table Amazon RDS.
+ Envoyez un rapport par e-mail sur les éléments de travail filtrés à l’aide d’Amazon SES.
+ Déployez et gérez des exemples de ressources à l'aide du AWS CloudFormation script inclus.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/cross_service/aurora_item_tracker).
**Les services utilisés dans cet exemple**
+ Aurora
+ Amazon RDS
+ Services de données Amazon RDS
+ Amazon SES
------
#### [ Python ]
**SDK pour Python (Boto3)**
Montre comment utiliser le AWS SDK pour Python (Boto3) pour créer un service REST qui suit les éléments de travail dans une base de données Amazon Aurora Serverless et envoie des rapports par e-mail à l'aide d'Amazon Simple Email Service (Amazon SES). Cet exemple utilise la structure web Flask pour gérer le routage HTTP et s’intègre à une page web React pour présenter une application web entièrement fonctionnelle.
+ Créez un service Flask REST qui s'intègre à Services AWS.
+ Lisez, écrivez et mettez à jour les éléments de travail stockés dans une base de données Aurora sans serveur.
+ Créez un AWS Secrets Manager secret contenant les informations d'identification de la base de données et utilisez-le pour authentifier les appels à la base de données.
+ Utilisez Amazon SES pour envoyer des rapports par e-mail sur les éléments de travail.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/aurora_item_tracker).
**Les services utilisés dans cet exemple**
+ Aurora
+ Amazon RDS
+ Services de données Amazon RDS
+ Amazon SES
------
# Détectez le PPE dans les images avec Amazon Rekognition à l'aide d'un SDK AWS
Les exemples de code suivants montrent comment créer une application qui utilise Amazon Rekognition afin de détecter l’équipement de protection individuelle (EPI) dans les images.
------
#### [ Java ]
**SDK pour Java 2.x**
Montre comment créer une AWS Lambda fonction qui détecte les images à l'aide d'un équipement de protection individuelle.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/creating_lambda_ppe).
**Les services utilisés dans cet exemple**
+ DynamoDB
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
------
# Détectez des objets dans des images avec Amazon Rekognition à l'aide d'un SDK AWS
Les exemples de code suivants montrent comment créer une application qui utilise Amazon Rekognition afin de détecter des objets par catégorie dans des images.
------
#### [ .NET ]
**SDK pour .NET**
Montre comment utiliser l’API Java Amazon Rekognition afin de créer une application qui, avec Amazon Rekognition, permet d’identifier des objets par catégorie dans des images stockées dans un compartiment Amazon Simple Storage Service (Amazon S3). L’application envoie à l’administrateur une notification par e-mail contenant les résultats à l’aide d’Amazon Simple Email Service (Amazon SES).
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/PhotoAnalyzerApp).
**Les services utilisés dans cet exemple**
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
------
#### [ Java ]
**SDK pour Java 2.x**
Montre comment utiliser l’API Java Amazon Rekognition afin de créer une application qui, avec Amazon Rekognition, permet d’identifier des objets par catégorie dans des images stockées dans un compartiment Amazon Simple Storage Service (Amazon S3). L’application envoie à l’administrateur une notification par e-mail contenant les résultats à l’aide d’Amazon Simple Email Service (Amazon SES).
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/creating_photo_analyzer_app).
**Les services utilisés dans cet exemple**
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Montre comment utiliser Amazon Rekognition AWS SDK pour JavaScript pour créer une application qui utilise Amazon Rekognition pour identifier les objets par catégorie dans des images situées dans un compartiment Amazon Simple Storage Service (Amazon S3). L'application envoie à l'administrateur une notification par e-mail contenant les résultats à l'aide d'Amazon Simple Email Service (Amazon SES).
Découvrez comment :
+ Créer un utilisateur non authentifié à l’aide d’Amazon Cognito.
+ Analyser les images à la recherche d’objets à l’aide d’Amazon Rekognition.
+ Vérifier une adresse e-mail pour Amazon SES.
+ Envoyer une notification par e-mail à l’aide d’Amazon SES.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/photo_analyzer).
**Les services utilisés dans cet exemple**
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
------
#### [ Kotlin ]
**SDK pour Kotlin**
Montre comment utiliser l’API Kotlin Amazon Rekognition afin de créer une application qui, avec Amazon Rekognition, permet d’identifier des objets par catégorie dans des images stockées dans un compartiment Amazon Simple Storage Service (Amazon S3). L’application envoie à l’administrateur une notification par e-mail contenant les résultats à l’aide d’Amazon Simple Email Service (Amazon SES).
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/usecases/creating_photo_analyzer_app).
**Les services utilisés dans cet exemple**
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
------
#### [ Python ]
**SDK pour Python (Boto3)**
Vous montre comment utiliser le AWS SDK pour Python (Boto3) pour créer une application Web qui vous permet d'effectuer les opérations suivantes :
+ Chargez les photos dans un compartiment Amazon Simple Storage Service (Amazon S3).
+ Utilisez Amazon Rekognition pour analyser et étiqueter les photos.
+ Utilisez Amazon Simple Email Service (Amazon SES) pour envoyer des rapports d’analyse d’images par e-mail.
Cet exemple contient deux composants principaux : une page Web écrite en JavaScript React et un service REST écrit en Python construit avec Flask-RESTful.
Vous pouvez utiliser la page web React pour :
+ Affichez une liste d’images stockées dans votre compartiment S3.
+ Chargez des images depuis votre ordinateur dans votre compartiment S3.
+ Affichez des images et des étiquettes qui identifient les éléments détectés dans l’image.
+ Obtenez un rapport de toutes les images de votre compartiment S3 et envoyez un e-mail du rapport.
La page web appelle le service REST. Le service envoie des demandes à AWS pour effectuer les opérations suivantes :
+ Obtenez et filtrez la liste des images de votre compartiment S3.
+ Chargez des photos dans votre compartiment S3.
+ Utilisez Amazon Rekognition pour analyser des photos individuelles et obtenir une liste d’étiquettes qui identifient les éléments détectés sur la photo.
+ Analysez toutes les photos de votre compartiment S3 et utilisez Amazon SES pour envoyer un rapport par e-mail.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/photo_analyzer).
**Les services utilisés dans cet exemple**
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
------
# Détectez les personnes et les objets dans une vidéo avec Amazon Rekognition à l'aide d'un SDK AWS
Les exemples de code suivants montrent comment détecter des personnes et des objets dans une vidéo avec Amazon Rekognition.
------
#### [ Java ]
**SDK pour Java 2.x**
Montre comment utiliser l’API Java Amazon Rekognition afin de créer une application qui détecte les visages et les objets dans des vidéos stockées dans un compartiment Amazon Simple Storage Service (Amazon S3). L’application envoie à l’administrateur une notification par e-mail contenant les résultats à l’aide d’Amazon Simple Email Service (Amazon SES).
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/video_analyzer_application).
**Les services utilisés dans cet exemple**
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
+ Amazon SNS
+ Amazon SQS
------
#### [ Python ]
**SDK pour Python (Boto3)**
Utilisez Amazon Rekognition pour détecter des visages, des objets et des personnes dans des vidéos en démarrant des tâches de détection asynchrone. Cet exemple montre également comment configurer Amazon Rekognition pour notifier une rubrique Amazon Simple Notification Service (Amazon SNS) lorsque les tâches sont terminées et abonner une file d’attente Amazon Simple Queue Service (Amazon SQS) à la rubrique. Lorsque la file d’attente reçoit un message concernant une tâche, elle est récupérée et les résultats sont affichés.
Il est préférable de visionner cet exemple sur GitHub. Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/rekognition).
**Les services utilisés dans cet exemple**
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
+ Amazon SNS
+ Amazon SQS
------
# Générer des informations d’identification pour vous connecter à un point de terminaison d’un SMTP Amazon SES
L’exemple de code suivant montre comment générer des informations d’identification pour vous connecter à un point de terminaison d’un SMTP Amazon SES.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/ses#code-examples).
```
#!/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()
```
------
# Utiliser les fonctions Step Functions pour invoquer des fonctions Lambda
L'exemple de code suivant montre comment créer une machine à AWS Step Functions états qui invoque des AWS Lambda fonctions en séquence.
------
#### [ Java ]
**SDK pour Java 2.x**
Montre comment créer un flux de travail AWS sans serveur en utilisant AWS Step Functions et le AWS SDK for Java 2.x. Chaque étape du flux de travail est implémentée à l'aide d'une AWS Lambda fonction.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/creating_workflows_stepfunctions).
**Les services utilisés dans cet exemple**
+ DynamoDB
+ Lambda
+ Amazon SES
+ Step Functions
------
# Vérifiez une identité e-mail et envoyez des messages avec Amazon SES à l'aide d'un AWS SDK
L’exemple de code suivant illustre comment :
+ Ajoutez et vérifiez une adresse e-mail avec Amazon SES.
+ Envoyez un e-mail standard.
+ Créez un modèle et envoyez un e-mail basé sur un modèle.
+ Envoyez un message en utilisant un serveur SMTP Amazon SES.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/ses#code-examples).
Vérifiez une adresse e-mail avec Amazon SES et envoyez des messages.
```
def usage_demo():
print("-" * 88)
print("Welcome to the Amazon Simple Email Service (Amazon SES) email demo!")
print("-" * 88)
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
ses_client = boto3.client("ses")
ses_identity = SesIdentity(ses_client)
ses_mail_sender = SesMailSender(ses_client)
ses_template = SesTemplate(ses_client)
email = input("Enter an email address to send mail with Amazon SES: ")
status = ses_identity.get_identity_status(email)
verified = status == "Success"
if not verified:
answer = input(
f"The address '{email}' is not verified with Amazon SES. Unless your "
f"Amazon SES account is out of sandbox, you can send mail only from "
f"and to verified accounts. Do you want to verify this account for use "
f"with Amazon SES? If yes, the address will receive a verification "
f"email (y/n): "
)
if answer.lower() == "y":
ses_identity.verify_email_identity(email)
print(f"Follow the steps in the email to {email} to complete verification.")
print("Waiting for verification...")
try:
ses_identity.wait_until_identity_exists(email)
print(f"Identity verified for {email}.")
verified = True
except WaiterError:
print(
f"Verification timeout exceeded. You must complete the "
f"steps in the email sent to {email} to verify the address."
)
if verified:
test_message_text = "Hello from the Amazon SES mail demo!"
test_message_html = "Hello!
From the Amazon SES mail demo!
"
print(f"Sending mail from {email} to {email}.")
ses_mail_sender.send_email(
email,
SesDestination([email]),
"Amazon SES demo",
test_message_text,
test_message_html,
)
input("Mail sent. Check your inbox and press Enter to continue.")
template = {
"name": "doc-example-template",
"subject": "Example of an email template.",
"text": "This is what {{name}} will {{action}} if {{name}} can't display "
"HTML.",
"html": "This is what {{name}} will {{action}} if {{name}} "
"can display HTML.
",
}
print("Creating a template and sending a templated email.")
ses_template.create_template(**template)
template_data = {"name": email.split("@")[0], "action": "read"}
if ses_template.verify_tags(template_data):
ses_mail_sender.send_templated_email(
email, SesDestination([email]), ses_template.name(), template_data
)
input("Mail sent. Check your inbox and press Enter to continue.")
print("Sending mail through the Amazon SES SMTP server.")
boto3_session = boto3.Session()
region = boto3_session.region_name
credentials = boto3_session.get_credentials()
port = 587
smtp_server = f"email-smtp.{region}.amazonaws.com"
password = calculate_key(credentials.secret_key, region)
message = """
Subject: Hi there
This message is sent from the Amazon SES SMTP mail demo."""
context = ssl.create_default_context()
with smtplib.SMTP(smtp_server, port) as server:
server.starttls(context=context)
server.login(credentials.access_key, password)
server.sendmail(email, email, message)
print("Mail sent. Check your inbox!")
if ses_template.template is not None:
print("Deleting demo template.")
ses_template.delete_template()
if verified:
answer = input(f"Do you want to remove {email} from Amazon SES (y/n)? ")
if answer.lower() == "y":
ses_identity.delete_identity(email)
print("Thanks for watching!")
print("-" * 88)
```
Créer des fonctions pour encapsuler les actions d’identité Amazon SES.
```
class SesIdentity:
"""Encapsulates Amazon SES identity functions."""
def __init__(self, ses_client):
"""
:param ses_client: A Boto3 Amazon SES client.
"""
self.ses_client = ses_client
def verify_domain_identity(self, domain_name):
"""
Starts verification of a domain identity. To complete verification, you must
create a TXT record with a specific format through your DNS provider.
For more information, see *Verifying a domain with Amazon SES* in the
Amazon SES documentation:
https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-domain-procedure.html
:param domain_name: The name of the domain to verify.
:return: The token to include in the TXT record with your DNS provider.
"""
try:
response = self.ses_client.verify_domain_identity(Domain=domain_name)
token = response["VerificationToken"]
logger.info("Got domain verification token for %s.", domain_name)
except ClientError:
logger.exception("Couldn't verify domain %s.", domain_name)
raise
else:
return token
def verify_email_identity(self, email_address):
"""
Starts verification of an email identity. This function causes an email
to be sent to the specified email address from Amazon SES. To complete
verification, follow the instructions in the email.
:param email_address: The email address to verify.
"""
try:
self.ses_client.verify_email_identity(EmailAddress=email_address)
logger.info("Started verification of %s.", email_address)
except ClientError:
logger.exception("Couldn't start verification of %s.", email_address)
raise
def wait_until_identity_exists(self, identity):
"""
Waits until an identity exists. The waiter polls Amazon SES until the
identity has been successfully verified or until it exceeds its maximum time.
:param identity: The identity to wait for.
"""
try:
waiter = self.ses_client.get_waiter("identity_exists")
logger.info("Waiting until %s exists.", identity)
waiter.wait(Identities=[identity])
except WaiterError:
logger.error("Waiting for identity %s failed or timed out.", identity)
raise
def get_identity_status(self, identity):
"""
Gets the status of an identity. This can be used to discover whether
an identity has been successfully verified.
:param identity: The identity to query.
:return: The status of the identity.
"""
try:
response = self.ses_client.get_identity_verification_attributes(
Identities=[identity]
)
status = response["VerificationAttributes"].get(
identity, {"VerificationStatus": "NotFound"}
)["VerificationStatus"]
logger.info("Got status of %s for %s.", status, identity)
except ClientError:
logger.exception("Couldn't get status for %s.", identity)
raise
else:
return status
def delete_identity(self, identity):
"""
Deletes an identity.
:param identity: The identity to remove.
"""
try:
self.ses_client.delete_identity(Identity=identity)
logger.info("Deleted identity %s.", identity)
except ClientError:
logger.exception("Couldn't delete identity %s.", identity)
raise
def list_identities(self, identity_type, max_items):
"""
Gets the identities of the specified type for the current account.
:param identity_type: The type of identity to retrieve, such as EmailAddress.
:param max_items: The maximum number of identities to retrieve.
:return: The list of retrieved identities.
"""
try:
response = self.ses_client.list_identities(
IdentityType=identity_type, MaxItems=max_items
)
identities = response["Identities"]
logger.info("Got %s identities for the current account.", len(identities))
except ClientError:
logger.exception("Couldn't list identities for the current account.")
raise
else:
return identities
```
Créer des fonctions pour encapsuler les actions de modèle Amazon SES.
```
class SesTemplate:
"""Encapsulates Amazon SES template functions."""
def __init__(self, ses_client):
"""
:param ses_client: A Boto3 Amazon SES client.
"""
self.ses_client = ses_client
self.template = None
self.template_tags = set()
def _extract_tags(self, subject, text, html):
"""
Extracts tags from a template as a set of unique values.
:param subject: The subject of the email.
:param text: The text version of the email.
:param html: The html version of the email.
"""
self.template_tags = set(re.findall(TEMPLATE_REGEX, subject + text + html))
logger.info("Extracted template tags: %s", self.template_tags)
def create_template(self, name, subject, text, html):
"""
Creates an email template.
:param name: The name of the template.
:param subject: The subject of the email.
:param text: The plain text version of the email.
:param html: The HTML version of the email.
"""
try:
template = {
"TemplateName": name,
"SubjectPart": subject,
"TextPart": text,
"HtmlPart": html,
}
self.ses_client.create_template(Template=template)
logger.info("Created template %s.", name)
self.template = template
self._extract_tags(subject, text, html)
except ClientError:
logger.exception("Couldn't create template %s.", name)
raise
def delete_template(self):
"""
Deletes an email template.
"""
try:
self.ses_client.delete_template(TemplateName=self.template["TemplateName"])
logger.info("Deleted template %s.", self.template["TemplateName"])
self.template = None
self.template_tags = None
except ClientError:
logger.exception(
"Couldn't delete template %s.", self.template["TemplateName"]
)
raise
def get_template(self, name):
"""
Gets a previously created email template.
:param name: The name of the template to retrieve.
:return: The retrieved email template.
"""
try:
response = self.ses_client.get_template(TemplateName=name)
self.template = response["Template"]
logger.info("Got template %s.", name)
self._extract_tags(
self.template["SubjectPart"],
self.template["TextPart"],
self.template["HtmlPart"],
)
except ClientError:
logger.exception("Couldn't get template %s.", name)
raise
else:
return self.template
def list_templates(self):
"""
Gets a list of all email templates for the current account.
:return: The list of retrieved email templates.
"""
try:
response = self.ses_client.list_templates()
templates = response["TemplatesMetadata"]
logger.info("Got %s templates.", len(templates))
except ClientError:
logger.exception("Couldn't get templates.")
raise
else:
return templates
def update_template(self, name, subject, text, html):
"""
Updates a previously created email template.
:param name: The name of the template.
:param subject: The subject of the email.
:param text: The plain text version of the email.
:param html: The HTML version of the email.
"""
try:
template = {
"TemplateName": name,
"SubjectPart": subject,
"TextPart": text,
"HtmlPart": html,
}
self.ses_client.update_template(Template=template)
logger.info("Updated template %s.", name)
self.template = template
self._extract_tags(subject, text, html)
except ClientError:
logger.exception("Couldn't update template %s.", name)
raise
```
Créer des fonctions pour encapsuler les actions e-mail Amazon SES.
```
class SesDestination:
"""Contains data about an email destination."""
def __init__(self, tos, ccs=None, bccs=None):
"""
:param tos: The list of recipients on the 'To:' line.
:param ccs: The list of recipients on the 'CC:' line.
:param bccs: The list of recipients on the 'BCC:' line.
"""
self.tos = tos
self.ccs = ccs
self.bccs = bccs
def to_service_format(self):
"""
:return: The destination data in the format expected by Amazon SES.
"""
svc_format = {"ToAddresses": self.tos}
if self.ccs is not None:
svc_format["CcAddresses"] = self.ccs
if self.bccs is not None:
svc_format["BccAddresses"] = self.bccs
return svc_format
class SesMailSender:
"""Encapsulates functions to send emails with Amazon SES."""
def __init__(self, ses_client):
"""
:param ses_client: A Boto3 Amazon SES client.
"""
self.ses_client = ses_client
def send_email(self, source, destination, subject, text, html, reply_tos=None):
"""
Sends an email.
Note: If your account is in the Amazon SES sandbox, the source and
destination email accounts must both be verified.
:param source: The source email account.
:param destination: The destination email account.
:param subject: The subject of the email.
:param text: The plain text version of the body of the email.
:param html: The HTML version of the body of the email.
:param reply_tos: Email accounts that will receive a reply if the recipient
replies to the message.
:return: The ID of the message, assigned by Amazon SES.
"""
send_args = {
"Source": source,
"Destination": destination.to_service_format(),
"Message": {
"Subject": {"Data": subject},
"Body": {"Text": {"Data": text}, "Html": {"Data": html}},
},
}
if reply_tos is not None:
send_args["ReplyToAddresses"] = reply_tos
try:
response = self.ses_client.send_email(**send_args)
message_id = response["MessageId"]
logger.info(
"Sent mail %s from %s to %s.", message_id, source, destination.tos
)
except ClientError:
logger.exception(
"Couldn't send mail from %s to %s.", source, destination.tos
)
raise
else:
return message_id
def send_templated_email(
self, source, destination, template_name, template_data, reply_tos=None
):
"""
Sends an email based on a template. A template contains replaceable tags
each enclosed in two curly braces, such as {{name}}. The template data passed
in this function contains key-value pairs that define the values to insert
in place of the template tags.
Note: If your account is in the Amazon SES sandbox, the source and
destination email accounts must both be verified.
:param source: The source email account.
:param destination: The destination email account.
:param template_name: The name of a previously created template.
:param template_data: JSON-formatted key-value pairs of replacement values
that are inserted in the template before it is sent.
:return: The ID of the message, assigned by Amazon SES.
"""
send_args = {
"Source": source,
"Destination": destination.to_service_format(),
"Template": template_name,
"TemplateData": json.dumps(template_data),
}
if reply_tos is not None:
send_args["ReplyToAddresses"] = reply_tos
try:
response = self.ses_client.send_templated_email(**send_args)
message_id = response["MessageId"]
logger.info(
"Sent templated mail %s from %s to %s.",
message_id,
source,
destination.tos,
)
except ClientError:
logger.exception(
"Couldn't send templated mail from %s to %s.", source, destination.tos
)
raise
else:
return message_id
```
+ Pour plus de détails sur l’API, consultez les rubriques suivantes dans la *Référence des API du kit AWS SDK for Python (Boto3)*.
+ [CreateTemplate](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/CreateTemplate)
+ [DeleteIdentity](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/DeleteIdentity)
+ [DeleteTemplate](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/DeleteTemplate)
+ [GetIdentityVerificationAttributes](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/GetIdentityVerificationAttributes)
+ [GetTemplate](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/GetTemplate)
+ [ListIdentities](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/ListIdentities)
+ [ListTemplates](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/ListTemplates)
+ [SendEmail](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/SendEmail)
+ [SendTemplatedEmail](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/SendTemplatedEmail)
+ [UpdateTemplate](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/UpdateTemplate)
+ [VerifyDomainIdentity](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/VerifyDomainIdentity)
+ [VerifyEmailIdentity](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/VerifyEmailIdentity)
------