\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");
}
}
```
+ Para obter detalhes da API, consulte [SendEmail](https://docs.aws.amazon.com/goto/SdkForJavaV2/email-2010-12-01/SendEmail)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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;
}
};
```
+ Para obter detalhes da API, consulte [SendEmail](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/SendEmailCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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
```
+ Para obter detalhes da API, consulte a [SendEmail](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/SendEmail)Referência da API *AWS SDK for Python (Boto3*).
------
#### [ Ruby ]
**SDK para Ruby**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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
```
+ Para obter detalhes da API, consulte [SendEmail](https://docs.aws.amazon.com/goto/SdkForRubyV3/email-2010-12-01/SendEmail)a *Referência AWS SDK para Ruby da API*.
------
#### [ SAP ABAP ]
**SDK para SAP ABAP**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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.
```
+ Para obter detalhes da API, consulte a [SendEmail](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)referência da *API AWS SDK for SAP ABAP*.
------
# Use `SendRawEmail` com um AWS SDK ou CLI
Os exemplos de código a seguir mostram como usar o `SendRawEmail`.
------
#### [ CLI ]
**AWS CLI**
**Para enviar e-mail bruto usando o Amazon SES**
O exemplo a seguir usa o comando `send-raw-email` para enviar um e-mail com um anexo TXT:
```
aws ses send-raw-email --raw-message file://message.json
```
Saída:
```
{
"MessageId": "EXAMPLEf3f73d99b-c63fb06f-d263-41f8-a0fb-d0dc67d56c07-000000"
}
```
A mensagem bruta é uma estrutura de dados JSON salva em um arquivo chamado `message.json` no diretório atual. Ele contém o seguinte:
```
{
"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--"
}
```
Como você pode ver, “Dados” é uma longa sequência de caracteres que contém todo o conteúdo bruto do e-mail no formato MIME, incluindo um anexo chamado attachment.txt.
Substitua sender@example.com e recipient@example.com pelos endereços que você deseja usar. O endereço de e-mail do remetente deverá ser verificado com o Amazon SES. Até que você tenha acesso de produção ao Amazon SES, você também deverá verificar o endereço de e-mail do destinatário, a menos que o destinatário seja o simulador de caixa de correio do Amazon SES. Para obter mais informações sobre verificação, consulte Verificar endereços de e-mail e domínios no Amazon SES no *Guia do desenvolvedor do Amazon Simple Email Service*.
O ID da mensagem na saída indica que a chamada para send-raw-email foi bem-sucedida.
Se você não receber o e-mail, verifique a caixa de lixo eletrônico.
Para obter mais informações sobre como enviar e-mail bruto, consulte Enviar e-mail bruto usando a API do Amazon SES no *Guia do desenvolvedor do Amazon Simple Email Service*.
+ Para obter detalhes da API, consulte [SendRawEmail](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ses/send-raw-email.html)em *Referência de AWS CLI Comandos*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
Use [nodemailer](https://nodemailer.com/transports/ses) para enviar um e-mail com anexo.
```
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);
}
},
);
});
};
```
+ Para obter detalhes da API, consulte [SendRawEmail](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/SendRawEmailCommand)a *Referência AWS SDK para JavaScript da API*.
------
# Use `SendTemplatedEmail` com um AWS SDK
Os exemplos de código a seguir mostram como usar o `SendTemplatedEmail`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Verificar uma identidade de e-mail e enviar mensagens](ses_example_ses_Scenario_SendEmail_section.md)
------
#### [ .NET ]
**SDK para .NET**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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;
}
```
+ Para obter detalhes da API, consulte [SendTemplatedEmail](https://docs.aws.amazon.com/goto/DotNetSDKV3/email-2010-12-01/SendTemplatedEmail)a *Referência AWS SDK para .NET da API*.
------
#### [ C\$1\$1 ]
**SDK para C\$1\$1**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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();
}
```
+ Para obter detalhes da API, consulte [SendTemplatedEmail](https://docs.aws.amazon.com/goto/SdkForCpp/email-2010-12-01/SendTemplatedEmail)a *Referência AWS SDK para C\$1\$1 da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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);
}
}
}
```
+ Para obter detalhes da API, consulte [SendTemplatedEmail](https://docs.aws.amazon.com/goto/SdkForJavaV2/email-2010-12-01/SendTemplatedEmail)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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;
}
};
```
+ Para obter detalhes da API, consulte [SendTemplatedEmail](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/SendTemplatedEmailCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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
```
+ Para obter detalhes da API, consulte a [SendTemplatedEmail](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/SendTemplatedEmail)Referência da API *AWS SDK for Python (Boto3*).
------
#### [ SAP ABAP ]
**SDK para SAP ABAP**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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.
```
+ Para obter detalhes da API, consulte a [SendTemplatedEmail](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)referência da *API AWS SDK for SAP ABAP*.
------
# Use `UpdateTemplate` com um AWS SDK
Os exemplos de código a seguir mostram como usar o `UpdateTemplate`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Verificar uma identidade de e-mail e enviar mensagens](ses_example_ses_Scenario_SendEmail_section.md)
------
#### [ C\$1\$1 ]
**SDK para C\$1\$1**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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();
}
```
+ Para obter detalhes da API, consulte [UpdateTemplate](https://docs.aws.amazon.com/goto/SdkForCpp/email-2010-12-01/UpdateTemplate)a *Referência AWS SDK para C\$1\$1 da API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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;
}
};
```
+ Para obter detalhes da API, consulte [UpdateTemplate](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/UpdateTemplateCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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
```
+ Para obter detalhes da API, consulte a [UpdateTemplate](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/UpdateTemplate)Referência da API *AWS SDK for Python (Boto3*).
------
#### [ SAP ABAP ]
**SDK para SAP ABAP**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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.
```
+ Para obter detalhes da API, consulte a [UpdateTemplate](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)referência da *API AWS SDK for SAP ABAP*.
------
# Use `VerifyDomainIdentity` com um AWS SDK ou CLI
Os exemplos de código a seguir mostram como usar o `VerifyDomainIdentity`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto nos seguintes exemplos de código:
+ [Copiar identidades de domínio e e-mail entre regiões](ses_example_ses_Scenario_ReplicateIdentities_section.md)
+ [Verificar uma identidade de e-mail e enviar mensagens](ses_example_ses_Scenario_SendEmail_section.md)
------
#### [ CLI ]
**AWS CLI**
**Para verificar um domínio com o Amazon SES**
O exemplo a seguir usa o comando `verify-domain-identity` para verificar um domínio:
```
aws ses verify-domain-identity --domain example.com
```
Saída:
```
{
"VerificationToken": "eoEmxw+YaYhb3h3iVJHuXMJXqeu1q1/wwmvjuEXAMPLE"
}
```
Para concluir a verificação do domínio, você deverá adicionar um registro TXT com o token de verificação retornado às configurações de DNS do seu domínio. Para obter mais informações, consulte Verificar domínios no Amazon SES no *Guia do desenvolvedor do Amazon Simple Email Service*.
+ Para obter detalhes da API, consulte [VerifyDomainIdentity](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ses/verify-domain-identity.html)em *Referência de AWS CLI Comandos*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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;
}
};
```
+ Para obter detalhes da API, consulte [VerifyDomainIdentity](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/VerifyDomainIdentityCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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
```
+ Para obter detalhes da API, consulte a [VerifyDomainIdentity](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/VerifyDomainIdentity)Referência da API *AWS SDK for Python (Boto3*).
------
#### [ SAP ABAP ]
**SDK para SAP ABAP**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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.
```
+ Para obter detalhes da API, consulte a [VerifyDomainIdentity](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)referência da *API AWS SDK for SAP ABAP*.
------
# Use `VerifyEmailIdentity` com um AWS SDK ou CLI
Os exemplos de código a seguir mostram como usar o `VerifyEmailIdentity`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto nos seguintes exemplos de código:
+ [Copiar identidades de domínio e e-mail entre regiões](ses_example_ses_Scenario_ReplicateIdentities_section.md)
+ [Verificar uma identidade de e-mail e enviar mensagens](ses_example_ses_Scenario_SendEmail_section.md)
------
#### [ .NET ]
**SDK para .NET**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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;
}
```
+ Para obter detalhes da API, consulte [VerifyEmailIdentity](https://docs.aws.amazon.com/goto/DotNetSDKV3/email-2010-12-01/VerifyEmailIdentity)a *Referência AWS SDK para .NET da API*.
------
#### [ C\$1\$1 ]
**SDK para C\$1\$1**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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();
}
```
+ Para obter detalhes da API, consulte [VerifyEmailIdentity](https://docs.aws.amazon.com/goto/SdkForCpp/email-2010-12-01/VerifyEmailIdentity)a *Referência AWS SDK para C\$1\$1 da API*.
------
#### [ CLI ]
**AWS CLI**
**Para verificar um endereço de e-mail com o Amazon SES**
O exemplo a seguir usa o comando `verify-email-identity` para verificar um endereço de e-mail:
```
aws ses verify-email-identity --email-address user@example.com
```
Antes de enviar e-mails usando o Amazon SES, você deve verificar que o endereço ou domínio do qual você está enviando o email para provar que você é o proprietário. Se você ainda não tem acesso de produção, também precisará verificar todos os endereços de e-mail aos quais envia e-mails, exceto aqueles fornecidos pelo simulador de caixa de correio do Amazon SES.
Depois verify-email-identity de ser chamado, o endereço de e-mail receberá um e-mail de verificação. O usuário deve clicar no link do e-mail para concluir o processo de verificação.
Para saber mais, consulte Verificar endereços de e-mail no Amazon SES no *Guia do desenvolvedor do Amazon Simple Email Service*.
+ Para obter detalhes da API, consulte [VerifyEmailIdentity](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ses/verify-email-identity.html)em *Referência de AWS CLI Comandos*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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;
}
};
```
+ Para obter detalhes da API, consulte [VerifyEmailIdentity](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/VerifyEmailIdentityCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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
```
+ Para obter detalhes da API, consulte a [VerifyEmailIdentity](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/VerifyEmailIdentity)Referência da API *AWS SDK for Python (Boto3*).
------
#### [ Ruby ]
**SDK para Ruby**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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
```
+ Para obter detalhes da API, consulte [VerifyEmailIdentity](https://docs.aws.amazon.com/goto/SdkForRubyV3/email-2010-12-01/VerifyEmailIdentity)a *Referência AWS SDK para Ruby da API*.
------
#### [ SAP ABAP ]
**SDK para SAP ABAP**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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.
```
+ Para obter detalhes da API, consulte a [VerifyEmailIdentity](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)referência da *API AWS SDK for SAP ABAP*.
------
# Cenários para o Amazon SES usando AWS SDKs
Os exemplos de código a seguir mostram como implementar cenários comuns no Amazon SES com AWS SDKs. Esses casos mostram como realizar tarefas específicas chamando várias funções dentro do Amazon SES ou combinadas com outros Serviços da AWS. Cada cenário inclui um link para o código-fonte completo, onde podem ser encontradas instruções sobre como configurar e executar o código.
Os cenários têm como alvo um nível intermediário de experiência para ajudar você a compreender ações de serviço em contexto.
**Topics**
+ [Criar uma aplicação de transmissão do Amazon Transcribe](ses_example_cross_TranscriptionStreamingApp_section.md)
+ [Copiar identidades de domínio e e-mail entre regiões](ses_example_ses_Scenario_ReplicateIdentities_section.md)
+ [Criar uma aplicação Web para monitorar dados do DynamoDB](ses_example_cross_DynamoDBDataTracker_section.md)
+ [Criar uma aplicação Web para rastrear dados do Amazon Redshift](ses_example_cross_RedshiftDataTracker_section.md)
+ [Crie um rastreador de itens de trabalho do Aurora Sem Servidor](ses_example_cross_RDSDataTracker_section.md)
+ [Detectar EPI em imagens](ses_example_cross_RekognitionPhotoAnalyzerPPE_section.md)
+ [Detectar objetos em imagens](ses_example_cross_RekognitionPhotoAnalyzer_section.md)
+ [Detectar pessoas e objetos em um vídeo](ses_example_cross_RekognitionVideoDetection_section.md)
+ [Gerar credenciais para estabelecer conexão com um endpoint SMTP](ses_example_ses_Scenario_GenerateSmtpCredentials_section.md)
+ [Usar Step Functions para invocar funções do Lambda](ses_example_cross_ServerlessWorkflows_section.md)
+ [Verificar uma identidade de e-mail e enviar mensagens](ses_example_ses_Scenario_SendEmail_section.md)
# Criar uma aplicação de transmissão do Amazon Transcribe
O exemplo de código a seguir mostra como construir uma aplicação que registra, transcreve e traduz áudio ao vivo em tempo real, e envia os resultados por e-mail.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Mostra como usar o Amazon Transcribe para construir uma aplicação que registra, transcreve e traduz áudio ao vivo em tempo real, e envia os resultados por e-mail usando o Amazon Simple Email Service (Amazon SES).
Para obter o código-fonte completo e instruções sobre como configurar e executar, veja o exemplo completo em [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/transcribe-streaming-app).
**Serviços usados neste exemplo**
+ Amazon Comprehend
+ Amazon SES
+ Amazon Transcribe
+ Amazon Translate
------
# Copie as identidades de e-mail e domínio do Amazon SES de uma AWS região para outra usando um SDK AWS
O exemplo de código a seguir mostra como copiar as identidades de e-mail e domínio do Amazon SES de uma AWS região para outra. Quando as identidades de domínio são gerenciadas pelo Route 53, os registros de verificação são copiados para o domínio da região de destino.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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()
```
+ Para obter detalhes da API, consulte os tópicos a seguir na *Referência da API AWS SDK para Python (Boto3)*.
+ [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)
------
# Criar uma aplicação Web para monitorar dados do DynamoDB
O exemplo de código a seguir mostra como criar uma aplicação Web que monitora itens de trabalho em uma tabela do Amazon DynamoDB e usa o Amazon Simple Email Service (Amazon SES) para enviar relatórios.
------
#### [ .NET ]
**SDK para .NET**
Mostra como usar a API .NET do Amazon DynamoDB para construir uma aplicação Web dinâmica que monitora os dados de trabalho do DynamoDB.
Para obter o código-fonte completo e instruções sobre como configurar e executar, veja o exemplo completo em [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/DynamoDbItemTracker).
**Serviços usados neste exemplo**
+ DynamoDB
+ Amazon SES
------
#### [ Java ]
**SDK para Java 2.x**
Mostra como usar a API do Amazon DynamoDB para construir uma aplicação Web dinâmica que monitora os dados de trabalho do DynamoDB.
Para obter o código-fonte completo e instruções sobre como configurar e executar, veja o exemplo completo em [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/creating_dynamodb_web_app).
**Serviços usados neste exemplo**
+ DynamoDB
+ Amazon SES
------
#### [ Kotlin ]
**SDK para Kotlin**
Mostra como usar a API do Amazon DynamoDB para construir uma aplicação Web dinâmica que monitora os dados de trabalho do DynamoDB.
Para obter o código-fonte completo e instruções sobre como configurar e executar, veja o exemplo completo em [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/usecases/itemtracker_dynamodb).
**Serviços usados neste exemplo**
+ DynamoDB
+ Amazon SES
------
#### [ Python ]
**SDK para Python (Boto3)**
Mostra como usar o AWS SDK para Python (Boto3) para criar um serviço REST que rastreia itens de trabalho no Amazon DynamoDB e envia relatórios por e-mail usando o Amazon Simple Email Service (Amazon SES). Este exemplo usa a estrutura web Flask para lidar com o roteamento HTTP e se integra a uma página da Web do React para apresentar uma aplicação Web totalmente funcional.
+ Crie um serviço Flask REST que se integre com o. Serviços da AWS
+ Leia, grave e atualize itens de trabalho armazenados em uma tabela do DynamoDB.
+ Use o Amazon SES para enviar relatórios por e-mail de itens de trabalho.
Para obter o código-fonte completo e instruções sobre como configurar e executar, veja o exemplo completo no [Repositório de exemplos de AWS código](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/dynamodb_item_tracker) em GitHub.
**Serviços usados neste exemplo**
+ DynamoDB
+ Amazon SES
------
# Criar um rastreador de itens do Amazon Redshift
Os exemplos de código a seguir mostram como criar uma aplicação Web que rastreia e gera relatórios sobre itens de trabalho usando um banco de dados do Amazon Redshift.
------
#### [ Java ]
**SDK para Java 2.x**
Mostra como criar uma aplicação Web que rastreia e gera relatórios sobre itens de trabalho armazenados em um banco de dados do Amazon Redshift.
Para obter o código-fonte completo e instruções sobre como configurar uma API Spring REST que consulta dados do Amazon Redshift e para uso por um aplicativo React, veja o exemplo completo em. [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/CreatingSpringRedshiftRest)
**Serviços usados neste exemplo**
+ banco de dados de origem
+ Amazon SES
------
#### [ Kotlin ]
**SDK para Kotlin**
Mostra como criar uma aplicação Web que rastreia e gera relatórios sobre itens de trabalho armazenados em um banco de dados do Amazon Redshift.
Para obter o código-fonte completo e instruções sobre como configurar uma API Spring REST que consulta dados do Amazon Redshift e para uso por um aplicativo React, veja o exemplo completo em. [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/usecases/creating_redshift_application)
**Serviços usados neste exemplo**
+ banco de dados de origem
+ Amazon SES
------
# Crie um rastreador de itens de trabalho do Aurora Sem Servidor
Os exemplos de código a seguir mostram como criar uma aplicação Web que rastreia os itens de trabalho em um banco de dados do Amazon Aurora Sem Servidor e usa o Amazon Simple Email Service (Amazon SES) para enviar relatórios.
------
#### [ .NET ]
**SDK para .NET**
Mostra como usar o AWS SDK para .NET para criar um aplicativo web que rastreia itens de trabalho em um banco de dados Amazon Aurora e envia relatórios por e-mail usando o Amazon Simple Email Service (Amazon SES). Este exemplo usa um front-end criado com o React.js para interagir com um back-end RESTful do.NET.
+ Integre um aplicativo web React com AWS serviços.
+ Liste, adicione, atualize e exclua itens em uma tabela do Aurora.
+ Envie um relatório por e-mail dos itens de trabalho filtrados usando o Amazon SES.
+ Implante e gerencie recursos de exemplo com o AWS CloudFormation script incluído.
Para obter o código-fonte completo e instruções sobre como configurar e executar, veja o exemplo completo em [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/AuroraItemTracker).
**Serviços usados neste exemplo**
+ Aurora
+ Amazon RDS
+ Serviços de dados do Amazon RDS
+ Amazon SES
------
#### [ C\$1\$1 ]
**SDK para C\$1\$1**
Mostra como criar uma aplicação Web que rastreia e gera relatórios sobre itens de trabalho armazenados em um banco de dados do Amazon Aurora Sem Servidor.
Para obter o código-fonte completo e instruções sobre como configurar uma API REST C\$1\$1 que consulta dados do Amazon Aurora Serverless e para uso por um aplicativo React, veja o exemplo completo em. [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cross-service/serverless-aurora)
**Serviços usados neste exemplo**
+ Aurora
+ Amazon RDS
+ Serviços de dados do Amazon RDS
+ Amazon SES
------
#### [ Java ]
**SDK para Java 2.x**
Mostra como construir uma aplicação Web que monitora e gera relatórios sobre itens de trabalho armazenados em um banco de dados do Amazon RDS.
Para obter o código-fonte completo e instruções sobre como configurar uma API Spring REST que consulta dados do Amazon Aurora Serverless e para uso por um aplicativo React, veja o exemplo completo em. [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/Creating_Spring_RDS_Rest)
Para obter o código-fonte completo e instruções sobre como configurar e executar um exemplo que usa a API JDBC, consulte o exemplo completo em. [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/Creating_rds_item_tracker)
**Serviços usados neste exemplo**
+ Aurora
+ Amazon RDS
+ Serviços de dados do Amazon RDS
+ Amazon SES
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Mostra como usar o AWS SDK para JavaScript (v3) para criar um aplicativo web que rastreia itens de trabalho em um banco de dados Amazon Aurora e envia relatórios por e-mail usando o Amazon Simple Email Service (Amazon SES). Este exemplo usa um front-end criado com React.js para interagir com um back-end Node.js Express.
+ Integre um aplicativo web React.js com Serviços da AWS o.
+ Liste, adicione e atualize itens em uma tabela do Aurora.
+ Use o Amazon SES para enviar um relatório por e-mail dos itens de trabalho filtrados.
+ Implante e gerencie recursos de exemplo com o AWS CloudFormation script incluído.
Para obter o código-fonte completo e instruções sobre como configurar e executar, veja o exemplo completo em [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/aurora-serverless-app).
**Serviços usados neste exemplo**
+ Aurora
+ Amazon RDS
+ Serviços de dados do Amazon RDS
+ Amazon SES
------
#### [ Kotlin ]
**SDK para Kotlin**
Mostra como construir uma aplicação Web que monitora e gera relatórios sobre itens de trabalho armazenados em um banco de dados do Amazon RDS.
Para obter o código-fonte completo e instruções sobre como configurar uma API Spring REST que consulta dados do Amazon Aurora Serverless e para uso por um aplicativo React, veja o exemplo completo em. [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/usecases/serverless_rds)
**Serviços usados neste exemplo**
+ Aurora
+ Amazon RDS
+ Serviços de dados do Amazon RDS
+ Amazon SES
------
#### [ PHP ]
**SDK para PHP**
Mostra como usar o AWS SDK para PHP para criar uma aplicação web que rastreia itens de trabalho em um banco de dados do Amazon RDS e envia relatórios por e-mail usando o Amazon Simple Email Service (Amazon SES). Este exemplo usa um front-end criado com o React.js para interagir com um back-end RESTful PHP.
+ Integre um aplicativo web React.js com AWS serviços.
+ Liste, adicione, atualize e exclua itens em uma tabela do Amazon RDS.
+ Envie um relatório por e-mail dos itens de trabalho filtrados usando o Amazon SES.
+ Implante e gerencie recursos de exemplo com o AWS CloudFormation script incluído.
Para obter o código-fonte completo e instruções sobre como configurar e executar, veja o exemplo completo em [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/cross_service/aurora_item_tracker).
**Serviços usados neste exemplo**
+ Aurora
+ Amazon RDS
+ Serviços de dados do Amazon RDS
+ Amazon SES
------
#### [ Python ]
**SDK para Python (Boto3)**
Mostra como usar o AWS SDK para Python (Boto3) para criar um serviço REST que rastreia itens de trabalho em um banco de dados Amazon Aurora Serverless e envia relatórios por e-mail usando o Amazon Simple Email Service (Amazon SES). Este exemplo usa a estrutura web Flask para lidar com o roteamento HTTP e se integra a uma página da Web do React para apresentar uma aplicação Web totalmente funcional.
+ Crie um serviço Flask REST que se integre com o. Serviços da AWS
+ Leia, grave e atualize itens de trabalho armazenados em um banco de dados do Aurora Sem Servidor.
+ Crie um AWS Secrets Manager segredo que contenha as credenciais do banco de dados e use-o para autenticar chamadas para o banco de dados.
+ Use o Amazon SES para enviar relatórios por e-mail de itens de trabalho.
Para obter o código-fonte completo e instruções sobre como configurar e executar, veja o exemplo completo em [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/aurora_item_tracker).
**Serviços usados neste exemplo**
+ Aurora
+ Amazon RDS
+ Serviços de dados do Amazon RDS
+ Amazon SES
------
# Detecte PPE em imagens com o Amazon Rekognition usando um SDK AWS
Os exemplos de código a seguir mostram como criar uma aplicação que usa o Amazon Rekognition para detectar equipamentos de proteção individual (EPI) em imagens.
------
#### [ Java ]
**SDK para Java 2.x**
Mostra como criar uma AWS Lambda função que detecta imagens com equipamento de proteção individual.
Para obter o código-fonte completo e instruções sobre como configurar e executar, veja o exemplo completo em [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/creating_lambda_ppe).
**Serviços usados neste exemplo**
+ DynamoDB
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
------
# Detecte objetos em imagens com o Amazon Rekognition usando um SDK AWS
Os exemplos de código a seguir mostram como construir uma aplicação que usa o Amazon Rekognition para detectar objetos por categoria em imagens.
------
#### [ .NET ]
**SDK para .NET**
Mostra como usar a API .NET do Amazon Rekognition para construir uma aplicação que usa o Amazon Rekognition para identificar objetos por categoria em imagens localizadas em um bucket do Amazon Simple Storage Service (Amazon S3). A aplicação envia uma notificação por e-mail ao administrador com os resultados usando o Amazon Simple Email Service (Amazon SES).
Para obter o código-fonte completo e instruções sobre como configurar e executar, veja o exemplo completo em [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/PhotoAnalyzerApp).
**Serviços usados neste exemplo**
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
------
#### [ Java ]
**SDK para Java 2.x**
Mostra como usar a API Java do Amazon Rekognition para construir uma aplicação que usa o Amazon Rekognition para identificar objetos por categoria em imagens localizadas em um bucket do Amazon Simple Storage Service (Amazon S3). A aplicação envia uma notificação por e-mail ao administrador com os resultados usando o Amazon Simple Email Service (Amazon SES).
Para obter o código-fonte completo e instruções sobre como configurar e executar, veja o exemplo completo em [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/creating_photo_analyzer_app).
**Serviços usados neste exemplo**
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Mostra como usar o Amazon Rekognition AWS SDK para JavaScript com o para criar um aplicativo que usa o Amazon Rekognition para identificar objetos por categoria em imagens localizadas em um bucket do Amazon Simple Storage Service (Amazon S3). A aplicação envia uma notificação por e-mail ao administrador com os resultados usando o Amazon Simple Email Service (Amazon SES).
Aprenda como:
+ Criar um usuário não autenticado usando o Amazon Cognito.
+ Analisar imagens em busca de objetos usando o Amazon Rekognition.
+ Verificar um endereço de e-mail para o Amazon SES.
+ Enviar uma notificação por e-mail usando o Amazon SES.
Para obter o código-fonte completo e instruções sobre como configurar e executar, veja o exemplo completo em [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/photo_analyzer).
**Serviços usados neste exemplo**
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
------
#### [ Kotlin ]
**SDK para Kotlin**
Mostra como usar a API Kotlin do Amazon Rekognition para construir uma aplicação que usa o Amazon Rekognition para identificar objetos por categoria em imagens localizadas em um bucket do Amazon Simple Storage Service (Amazon S3). A aplicação envia uma notificação por e-mail ao administrador com os resultados usando o Amazon Simple Email Service (Amazon SES).
Para obter o código-fonte completo e instruções sobre como configurar e executar, veja o exemplo completo em [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/usecases/creating_photo_analyzer_app).
**Serviços usados neste exemplo**
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
------
#### [ Python ]
**SDK para Python (Boto3)**
Mostra como usar o AWS SDK para Python (Boto3) para criar um aplicativo web que permite fazer o seguinte:
+ Carregar fotos em um bucket do Amazon Simple Storage Service (Amazon S3).
+ Usar o Amazon Rekognition para analisar e rotular as fotos.
+ Usar o Amazon Simple Email Service (Amazon SES) para enviar relatórios de análise da imagem por e-mail.
Este exemplo contém dois componentes principais: uma página da Web criada com React e um serviço REST escrito em Python que é construído com Flask-. JavaScript RESTful
Você pode usar a página da Web do React para:
+ Exibir uma lista de imagens que estão armazenadas no bucket do S3.
+ Carregar imagens do computador para o bucket do S3.
+ Exibir imagens e rótulos que identificam os itens detectados na imagem.
+ Obter um relatório de todas as imagens no bucket do S3 e enviar um relatório por e-mail.
A página da Web chama o serviço REST. O serviço envia solicitações à AWS para realizar as seguintes ações:
+ Obter e filtrar a lista de imagens no bucket do S3.
+ Carregar fotos no bucket do S3.
+ Usar o Amazon Rekognition para analisar fotos individuais e obter uma lista dos rótulos que identifiquem os itens detectados nas fotos.
+ Analisar todas as fotos no bucket do S3 e usar o Amazon SES para enviar um relatório por e-mail.
Para obter o código-fonte completo e instruções sobre como configurar e executar, veja o exemplo completo em [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/photo_analyzer).
**Serviços usados neste exemplo**
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
------
# Detecte pessoas e objetos em um vídeo com o Amazon Rekognition usando um SDK AWS
Os exemplos de código a seguir mostram como detectar pessoas e objetos em um vídeo com o Amazon Rekognition.
------
#### [ Java ]
**SDK para Java 2.x**
Mostra como usar a API Java do Amazon Rekognition a fim de construir uma aplicação para detectar faces e objetos em vídeos localizados em um bucket do Amazon Simple Storage Service (Amazon S3). A aplicação envia uma notificação por e-mail ao administrador com os resultados usando o Amazon Simple Email Service (Amazon SES).
Para obter o código-fonte completo e instruções sobre como configurar e executar, veja o exemplo completo em [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/video_analyzer_application).
**Serviços usados neste exemplo**
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
+ Amazon SNS
+ Amazon SQS
------
#### [ Python ]
**SDK para Python (Boto3)**
Use o Amazon Rekognition para detectar faces, objetos e pessoas em vídeos iniciando trabalhos de detecção assíncrona. Este exemplo também configura o Amazon Rekognition para notificar um tópico do Amazon Simple Notification Service (Amazon SNS) quando os trabalhos são concluídos e inscreve uma fila do Amazon Simple Queue Service (Amazon SQS) no tópico. Quando a fila recebe uma mensagem sobre um trabalho, o trabalho é recuperado e os resultados são apresentados.
Este exemplo é melhor visualizado em GitHub. Para obter o código-fonte completo e instruções sobre como configurar e executar, veja o exemplo completo em [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/rekognition).
**Serviços usados neste exemplo**
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
+ Amazon SNS
+ Amazon SQS
------
# Gerar credenciais para estabelecer conexão com um endpoint SMTP do Amazon SES
O exemplo de código a seguir mostra como gerar credenciais para estabelecer conexão com um endpoint SMTP do Amazon SES.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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()
```
------
# Usar Step Functions para invocar funções do Lambda
O exemplo de código a seguir mostra como criar uma máquina de AWS Step Functions estado que invoca AWS Lambda funções em sequência.
------
#### [ Java ]
**SDK para Java 2.x**
Mostra como criar um fluxo de trabalho AWS sem servidor usando AWS Step Functions e. AWS SDK for Java 2.x Cada etapa do fluxo de trabalho é implementada usando uma AWS Lambda função.
Para obter o código-fonte completo e instruções sobre como configurar e executar, veja o exemplo completo em [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/creating_workflows_stepfunctions).
**Serviços usados neste exemplo**
+ DynamoDB
+ Lambda
+ Amazon SES
+ Step Functions
------
# Verifique uma identidade de e-mail e envie mensagens com o Amazon SES usando um AWS SDK
O exemplo de código a seguir mostra como:
+ Adicionar e verificar um endereço de e-mail com o Amazon SES.
+ Enviar uma mensagem de e-mail padrão.
+ Criar um modelo e envie uma mensagem de e-mail com modelo.
+ Enviar uma mensagem usando um servidor SMTP do Amazon SES.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/ses#code-examples).
Verifique um endereço de e-mail com o Amazon SES e envie mensagens.
```
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)
```
Crie funções para encapsular ações de identidade do 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
```
Crie funções para encapsular ações com modelo do 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
```
Crie funções para encapsular ações de e-mail do 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
```
+ Para obter detalhes da API, consulte os tópicos a seguir na *Referência da API AWS SDK para 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)
------