\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");
}
}
```
+ API 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [SendEmail](https://docs.aws.amazon.com/goto/SdkForJavaV2/email-2010-12-01/SendEmail)을 참조하십시오.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
import { SendEmailCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";
const createSendEmailCommand = (toAddress, fromAddress) => {
return new SendEmailCommand({
Destination: {
/* required */
CcAddresses: [
/* more items */
],
ToAddresses: [
toAddress,
/* more To-email addresses */
],
},
Message: {
/* required */
Body: {
/* required */
Html: {
Charset: "UTF-8",
Data: "HTML_FORMAT_BODY",
},
Text: {
Charset: "UTF-8",
Data: "TEXT_FORMAT_BODY",
},
},
Subject: {
Charset: "UTF-8",
Data: "EMAIL_SUBJECT",
},
},
Source: fromAddress,
ReplyToAddresses: [
/* more items */
],
});
};
const run = async () => {
const sendEmailCommand = createSendEmailCommand(
"recipient@example.com",
"sender@example.com",
);
try {
return await sesClient.send(sendEmailCommand);
} catch (caught) {
if (caught instanceof Error && caught.name === "MessageRejected") {
/** @type { import('@aws-sdk/client-ses').MessageRejected} */
const messageRejectedError = caught;
return messageRejectedError;
}
throw caught;
}
};
```
+ API 세부 정보는 *AWS SDK for JavaScript API 참조*의 [SendEmail](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/SendEmailCommand)을 참조하십시오.
------
#### [ Python ]
**SDK for Python (Boto3)**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/ses#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
class SesMailSender:
"""Encapsulates functions to send emails with Amazon SES."""
def __init__(self, ses_client):
"""
:param ses_client: A Boto3 Amazon SES client.
"""
self.ses_client = ses_client
def send_email(self, source, destination, subject, text, html, reply_tos=None):
"""
Sends an email.
Note: If your account is in the Amazon SES sandbox, the source and
destination email accounts must both be verified.
:param source: The source email account.
:param destination: The destination email account.
:param subject: The subject of the email.
:param text: The plain text version of the body of the email.
:param html: The HTML version of the body of the email.
:param reply_tos: Email accounts that will receive a reply if the recipient
replies to the message.
:return: The ID of the message, assigned by Amazon SES.
"""
send_args = {
"Source": source,
"Destination": destination.to_service_format(),
"Message": {
"Subject": {"Data": subject},
"Body": {"Text": {"Data": text}, "Html": {"Data": html}},
},
}
if reply_tos is not None:
send_args["ReplyToAddresses"] = reply_tos
try:
response = self.ses_client.send_email(**send_args)
message_id = response["MessageId"]
logger.info(
"Sent mail %s from %s to %s.", message_id, source, destination.tos
)
except ClientError:
logger.exception(
"Couldn't send mail from %s to %s.", source, destination.tos
)
raise
else:
return message_id
```
+ API 세부 정보는 *AWS SDK for Python (Boto3) API 참조*의 [SendEmail](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/SendEmail)를 참조하세요.
------
#### [ Ruby ]
**SDK for Ruby**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/ses/v1#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
require 'aws-sdk-ses' # v2: require 'aws-sdk'
# Replace sender@example.com with your "From" address.
# This address must be verified with Amazon SES.
sender = 'sender@example.com'
# Replace recipient@example.com with a "To" address. If your account
# is still in the sandbox, this address must be verified.
recipient = 'recipient@example.com'
# Specify a configuration set. To use a configuration
# set, uncomment the next line and line 74.
# configsetname = "ConfigSet"
# The subject line for the email.
subject = 'Amazon SES test (AWS SDK for Ruby)'
# The HTML body of the email.
htmlbody =
'Amazon SES test (AWS SDK for Ruby)
'\
'This email was sent with '\
'Amazon SES using the '\
'AWS SDK for Ruby.'
# The email body for recipients with non-HTML email clients.
textbody = 'This email was sent with Amazon SES using the AWS SDK for Ruby.'
# Specify the text encoding scheme.
encoding = 'UTF-8'
# Create a new SES client in the us-west-2 region.
# Replace us-west-2 with the AWS Region you're using for Amazon SES.
ses = Aws::SES::Client.new(region: 'us-west-2')
# Try to send the email.
begin
# Provide the contents of the email.
ses.send_email(
destination: {
to_addresses: [
recipient
]
},
message: {
body: {
html: {
charset: encoding,
data: htmlbody
},
text: {
charset: encoding,
data: textbody
}
},
subject: {
charset: encoding,
data: subject
}
},
source: sender
# Uncomment the following line to use a configuration set.
# configuration_set_name: configsetname,
)
puts "Email sent to #{recipient}"
# If something goes wrong, display an error message.
rescue Aws::SES::Errors::ServiceError => e
puts "Email not sent. Error message: #{e}"
end
```
+ API 세부 정보는 *AWS SDK for Ruby API 참조*의 [SendEmail](https://docs.aws.amazon.com/goto/SdkForRubyV3/email-2010-12-01/SendEmail)을 참조하세요.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP API**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/ses#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
" Create message object
DATA(lo_subject) = NEW /aws1/cl_sescontent( iv_data = iv_subject ).
DATA(lo_text_body) = NEW /aws1/cl_sescontent( iv_data = iv_text ).
DATA(lo_html_body) = NEW /aws1/cl_sescontent( iv_data = iv_html ).
DATA(lo_body) = NEW /aws1/cl_sesbody(
io_text = lo_text_body
io_html = lo_html_body
).
DATA(lo_message) = NEW /aws1/cl_sesmessage(
io_subject = lo_subject
io_body = lo_body
).
TRY.
" Send email
DATA(lo_result) = lo_ses->sendemail(
iv_source = iv_source
io_destination = io_destination
io_message = lo_message
it_replytoaddresses = it_reply_tos
).
ov_msg_id = lo_result->get_messageid( ).
MESSAGE 'Email sent successfully' TYPE 'I'.
CATCH /aws1/cx_sesacctsendingpause00 INTO DATA(lo_ex1).
DATA(lv_error) = |Account sending paused: { lo_ex1->get_text( ) }|.
MESSAGE lv_error TYPE 'I'.
RAISE EXCEPTION lo_ex1.
CATCH /aws1/cx_sesmessagerejected INTO DATA(lo_ex2).
lv_error = |Message rejected: { lo_ex2->get_text( ) }|.
MESSAGE lv_error TYPE 'I'.
RAISE EXCEPTION lo_ex2.
CATCH /aws1/cx_rt_generic INTO DATA(lo_ex_generic).
lv_error = |An error occurred: { lo_ex_generic->get_text( ) }|.
MESSAGE lv_error TYPE 'I'.
RAISE EXCEPTION lo_ex_generic.
ENDTRY.
```
+ API 세부 정보는 *AWS SDK for SAP ABAP API 참조*의 [SendEmail](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)을 참조하세요.
------
# AWS SDK 또는 CLI와 `SendRawEmail` 함께 사용
다음 코드 예시는 `SendRawEmail`의 사용 방법을 보여 줍니다.
------
#### [ CLI ]
**AWS CLI**
**Amazon SES를 사용하여 원시 이메일 전송**
다음 예시에서는 `send-raw-email` 명령을 사용하여 TXT 첨부 파일이 있는 이메일을 보냅니다.
```
aws ses send-raw-email --raw-message file://message.json
```
출력:
```
{
"MessageId": "EXAMPLEf3f73d99b-c63fb06f-d263-41f8-a0fb-d0dc67d56c07-000000"
}
```
원시 메시지는 현재 디렉터리의 `message.json` 파일에 저장된 JSON 데이터 구조입니다. 이는 다음을 포함합니다.
```
{
"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--"
}
```
보시다시피 'Data'는 attachment.txt 첨부 파일을 포함하여 MIME 형식의 원시 이메일 콘텐츠 전체를 포함하는 하나의 긴 문자열입니다.
sender@example.com 및 recipient@example.com을 사용하려는 주소로 바꿉니다. 단, 발신자의 이메일 주소는 Amazon SES로 확인해야 합니다. Amazon SES에 대한 프로덕션 액세스 권한을 부여받기 전까지는 수신자의 이메일 주소도 확인해야 합니다. 단, 수신자가 Amazon SES 메일박스 시뮬레이터가 아닌 경우는 예외입니다. 확인에 대한 자세한 내용은 *Amazon Simple Email Service 개발자 안내서*의 Amazon SES에서 이메일 주소 및 도메인 확인을 참조하세요.
출력의 Message ID는 직접적인 send-raw-email 호출이 성공했음을 나타냅니다.
이메일을 받지 못한 경우 정크 박스를 확인해 보세요.
원시 이메일을 보내는 방법에 대한 자세한 내용은 *Amazon Simple Email Service 개발자 안내서*의 Amazon SES API를 사용하여 원시 이메일 전송을 참조하세요.
+ API 세부 정보는 *AWS CLI 명령 참조*의 [SendRawEmail](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ses/send-raw-email.html)을 참조하세요.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
[nodemailer](https://nodemailer.com/transports/ses)를 사용하여 첨부 파일이 있는 이메일을 보냅니다.
```
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);
}
},
);
});
};
```
+ API 세부 정보는 *AWS SDK for JavaScript API 참조*의 [SendRawEmail](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/SendRawEmailCommand)을 참조하세요.
------
# AWS SDK와 `SendTemplatedEmail` 함께 사용
다음 코드 예시는 `SendTemplatedEmail`의 사용 방법을 보여 줍니다.
작업 예제는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [이메일 ID 확인 및 메시지 전송](ses_example_ses_Scenario_SendEmail_section.md)
------
#### [ .NET ]
**SDK for .NET**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/SES#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
///
/// Send an email using a template.
///
/// Address of the sender.
/// Addresses of the recipients.
/// Name of the email template.
/// Data for the email template.
/// The messageId of the email.
public async Task SendTemplateEmailAsync(string sender, List recipients,
string templateName, object templateDataObject)
{
var messageId = "";
try
{
// Template data should be serialized JSON from either a class or a dynamic object.
var templateData = JsonSerializer.Serialize(templateDataObject);
var response = await _amazonSimpleEmailService.SendTemplatedEmailAsync(
new SendTemplatedEmailRequest
{
Source = sender,
Destination = new Destination
{
ToAddresses = recipients
},
Template = templateName,
TemplateData = templateData
});
messageId = response.MessageId;
}
catch (Exception ex)
{
Console.WriteLine("SendTemplateEmailAsync failed with exception: " + ex.Message);
}
return messageId;
}
```
+ API 세부 정보는 *AWS SDK for .NET API 참조*의 [SendTemplatedEmail](https://docs.aws.amazon.com/goto/DotNetSDKV3/email-2010-12-01/SendTemplatedEmail)을 참조하십시오.
------
#### [ C\$1\$1 ]
**SDK for C\$1\$1**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ses#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
//! Send a templated email to a list of recipients.
/*!
\param recipients; Vector of recipient email addresses.
\param templateName: The name of the template to use.
\param templateData: Map of key-value pairs for replacing text in template.
\param senderEmailAddress: Email address of sender. Ignored if empty string.
\param ccAddresses: Vector of cc addresses. Ignored if empty.
\param replyToAddress: Reply to email address. Ignored if empty string.
\param clientConfiguration: AWS client configuration.
\return bool: Function succeeded.
*/
bool AwsDoc::SES::sendTemplatedEmail(const Aws::Vector &recipients,
const Aws::String &templateName,
const Aws::Map &templateData,
const Aws::String &senderEmailAddress,
const Aws::Vector &ccAddresses,
const Aws::String &replyToAddress,
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::SES::SESClient sesClient(clientConfiguration);
Aws::SES::Model::Destination destination;
if (!ccAddresses.empty()) {
destination.WithCcAddresses(ccAddresses);
}
if (!recipients.empty()) {
destination.WithToAddresses(recipients);
}
Aws::SES::Model::SendTemplatedEmailRequest sendTemplatedEmailRequest;
sendTemplatedEmailRequest.SetDestination(destination);
sendTemplatedEmailRequest.SetTemplate(templateName);
std::ostringstream templateDataStream;
templateDataStream << "{";
size_t dataCount = 0;
for (auto &pair: templateData) {
templateDataStream << "\"" << pair.first << "\":\"" << pair.second << "\"";
dataCount++;
if (dataCount < templateData.size()) {
templateDataStream << ",";
}
}
templateDataStream << "}";
sendTemplatedEmailRequest.SetTemplateData(templateDataStream.str());
if (!senderEmailAddress.empty()) {
sendTemplatedEmailRequest.SetSource(senderEmailAddress);
}
if (!replyToAddress.empty()) {
sendTemplatedEmailRequest.AddReplyToAddresses(replyToAddress);
}
auto outcome = sesClient.SendTemplatedEmail(sendTemplatedEmailRequest);
if (outcome.IsSuccess()) {
std::cout << "Successfully sent templated message with ID "
<< outcome.GetResult().GetMessageId()
<< "." << std::endl;
}
else {
std::cerr << "Error sending templated message. "
<< outcome.GetError().GetMessage()
<< std::endl;
}
return outcome.IsSuccess();
}
```
+ API 세부 정보는 *AWS SDK for C\$1\$1 API 참조*의 [SendTemplatedEmail](https://docs.aws.amazon.com/goto/SdkForCpp/email-2010-12-01/SendTemplatedEmail)을 참조하십시오.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/ses#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sesv2.model.Destination;
import software.amazon.awssdk.services.sesv2.model.EmailContent;
import software.amazon.awssdk.services.sesv2.model.SendEmailRequest;
import software.amazon.awssdk.services.sesv2.model.SesV2Exception;
import software.amazon.awssdk.services.sesv2.SesV2Client;
import software.amazon.awssdk.services.sesv2.model.Template;
/**
* Before running this AWS SDK for Java (v2) example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*
* Also, make sure that you create a template. See the following documentation
* topic:
*
* https://docs.aws.amazon.com/ses/latest/dg/send-personalized-email-api.html
*/
public class SendEmailTemplate {
public static void main(String[] args) {
final String usage = """
Usage:
\s
Where:
template - The name of the email template.
sender - An email address that represents the sender.\s
recipient - An email address that represents the recipient.\s
""";
if (args.length != 3) {
System.out.println(usage);
System.exit(1);
}
String templateName = args[0];
String sender = args[1];
String recipient = args[2];
Region region = Region.US_EAST_1;
SesV2Client sesv2Client = SesV2Client.builder()
.region(region)
.build();
send(sesv2Client, sender, recipient, templateName);
}
public static void send(SesV2Client client, String sender, String recipient, String templateName) {
Destination destination = Destination.builder()
.toAddresses(recipient)
.build();
/*
* Specify both name and favorite animal (favoriteanimal) in your code when
* defining the Template object.
* If you don't specify all the variables in the template, Amazon SES doesn't
* send the email.
*/
Template myTemplate = Template.builder()
.templateName(templateName)
.templateData("{\n" +
" \"name\": \"Jason\"\n," +
" \"favoriteanimal\": \"Cat\"\n" +
"}")
.build();
EmailContent emailContent = EmailContent.builder()
.template(myTemplate)
.build();
SendEmailRequest emailRequest = SendEmailRequest.builder()
.destination(destination)
.content(emailContent)
.fromEmailAddress(sender)
.build();
try {
System.out.println("Attempting to send an email based on a template using the AWS SDK for Java (v2)...");
client.sendEmail(emailRequest);
System.out.println("email based on a template was sent");
} catch (SesV2Exception e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
}
```
+ API 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [SendTemplatedEmail](https://docs.aws.amazon.com/goto/SdkForJavaV2/email-2010-12-01/SendTemplatedEmail)을 참조하십시오.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
import { SendTemplatedEmailCommand } from "@aws-sdk/client-ses";
import {
getUniqueName,
postfix,
} from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";
/**
* Replace this with the name of an existing template.
*/
const TEMPLATE_NAME = getUniqueName("ReminderTemplate");
/**
* Replace these with existing verified emails.
*/
const VERIFIED_EMAIL = postfix(getUniqueName("Bilbo"), "@example.com");
const USER = { firstName: "Bilbo", emailAddress: VERIFIED_EMAIL };
/**
*
* @param { { emailAddress: string, firstName: string } } user
* @param { string } templateName - The name of an existing template in Amazon SES.
* @returns { SendTemplatedEmailCommand }
*/
const createReminderEmailCommand = (user, templateName) => {
return new SendTemplatedEmailCommand({
/**
* Here's an example of how a template would be replaced with user data:
* Template: Hello {{contact.firstName}},
Don't forget about the party gifts!
* Destination: Hello Bilbo,
Don't forget about the party gifts!
*/
Destination: { ToAddresses: [user.emailAddress] },
TemplateData: JSON.stringify({ contact: { firstName: user.firstName } }),
Source: VERIFIED_EMAIL,
Template: templateName,
});
};
const run = async () => {
const sendReminderEmailCommand = createReminderEmailCommand(
USER,
TEMPLATE_NAME,
);
try {
return await sesClient.send(sendReminderEmailCommand);
} catch (caught) {
if (caught instanceof Error && caught.name === "MessageRejected") {
/** @type { import('@aws-sdk/client-ses').MessageRejected} */
const messageRejectedError = caught;
return messageRejectedError;
}
throw caught;
}
};
```
+ API 세부 정보는 *AWS SDK for JavaScript API 참조*의 [SendTemplatedEmail](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/SendTemplatedEmailCommand)을 참조하세요.
------
#### [ Python ]
**SDK for Python (Boto3)**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/ses#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
class SesMailSender:
"""Encapsulates functions to send emails with Amazon SES."""
def __init__(self, ses_client):
"""
:param ses_client: A Boto3 Amazon SES client.
"""
self.ses_client = ses_client
def send_templated_email(
self, source, destination, template_name, template_data, reply_tos=None
):
"""
Sends an email based on a template. A template contains replaceable tags
each enclosed in two curly braces, such as {{name}}. The template data passed
in this function contains key-value pairs that define the values to insert
in place of the template tags.
Note: If your account is in the Amazon SES sandbox, the source and
destination email accounts must both be verified.
:param source: The source email account.
:param destination: The destination email account.
:param template_name: The name of a previously created template.
:param template_data: JSON-formatted key-value pairs of replacement values
that are inserted in the template before it is sent.
:return: The ID of the message, assigned by Amazon SES.
"""
send_args = {
"Source": source,
"Destination": destination.to_service_format(),
"Template": template_name,
"TemplateData": json.dumps(template_data),
}
if reply_tos is not None:
send_args["ReplyToAddresses"] = reply_tos
try:
response = self.ses_client.send_templated_email(**send_args)
message_id = response["MessageId"]
logger.info(
"Sent templated mail %s from %s to %s.",
message_id,
source,
destination.tos,
)
except ClientError:
logger.exception(
"Couldn't send templated mail from %s to %s.", source, destination.tos
)
raise
else:
return message_id
```
+ API 세부 정보는 *AWS SDK for Python (Boto3) API 참조*의 [SendTemplatedEmail](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/SendTemplatedEmail)를 참조하세요.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP API**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/ses#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
TRY.
" Send templated email
DATA(lo_result) = lo_ses->sendtemplatedemail(
iv_source = iv_source
io_destination = io_destination
iv_template = iv_template_name
iv_templatedata = iv_template_data
it_replytoaddresses = it_reply_tos
).
ov_msg_id = lo_result->get_messageid( ).
MESSAGE 'Templated email sent successfully' TYPE 'I'.
CATCH /aws1/cx_sestmpldoesnotexistex INTO DATA(lo_ex1).
DATA(lv_error) = |Template does not exist: { lo_ex1->get_text( ) }|.
MESSAGE lv_error TYPE 'I'.
RAISE EXCEPTION lo_ex1.
CATCH /aws1/cx_rt_generic INTO DATA(lo_ex_generic).
lv_error = |An error occurred: { lo_ex_generic->get_text( ) }|.
MESSAGE lv_error TYPE 'I'.
RAISE EXCEPTION lo_ex_generic.
ENDTRY.
```
+ API 세부 정보는 SDK for SAP ABAP API 참조의 [SendTemplatedEmail](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)을 참조하세요. *AWS *
------
# AWS SDK와 `UpdateTemplate` 함께 사용
다음 코드 예시는 `UpdateTemplate`의 사용 방법을 보여 줍니다.
작업 예제는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [이메일 ID 확인 및 메시지 전송](ses_example_ses_Scenario_SendEmail_section.md)
------
#### [ C\$1\$1 ]
**SDK for C\$1\$1**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ses#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
//! Update an Amazon Simple Email Service (Amazon SES) template.
/*!
\param templateName: The name of the template.
\param htmlPart: The HTML body of the email.
\param subjectPart: The subject line of the email.
\param textPart: The plain text version of the email.
\param clientConfiguration: AWS client configuration.
\return bool: Function succeeded.
*/
bool AwsDoc::SES::updateTemplate(const Aws::String &templateName,
const Aws::String &htmlPart,
const Aws::String &subjectPart,
const Aws::String &textPart,
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::SES::SESClient sesClient(clientConfiguration);
Aws::SES::Model::Template templateValues;
templateValues.SetTemplateName(templateName);
templateValues.SetSubjectPart(subjectPart);
templateValues.SetHtmlPart(htmlPart);
templateValues.SetTextPart(textPart);
Aws::SES::Model::UpdateTemplateRequest updateTemplateRequest;
updateTemplateRequest.SetTemplate(templateValues);
Aws::SES::Model::UpdateTemplateOutcome outcome = sesClient.UpdateTemplate(updateTemplateRequest);
if (outcome.IsSuccess()) {
std::cout << "Successfully updated template." << std::endl;
} else {
std::cerr << "Error updating template. " << outcome.GetError().GetMessage()
<< std::endl;
}
return outcome.IsSuccess();
}
```
+ API 세부 정보는 *AWS SDK for C\$1\$1 API 참조*의 [UpdateTemplate](https://docs.aws.amazon.com/goto/SdkForCpp/email-2010-12-01/UpdateTemplate)을 참조하십시오.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
import { UpdateTemplateCommand } from "@aws-sdk/client-ses";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";
const TEMPLATE_NAME = getUniqueName("TemplateName");
const HTML_PART = "Hello, World!
";
const createUpdateTemplateCommand = () => {
return new UpdateTemplateCommand({
Template: {
TemplateName: TEMPLATE_NAME,
HtmlPart: HTML_PART,
SubjectPart: "Example",
TextPart: "Updated template text.",
},
});
};
const run = async () => {
const updateTemplateCommand = createUpdateTemplateCommand();
try {
return await sesClient.send(updateTemplateCommand);
} catch (err) {
console.log("Failed to update template.", err);
return err;
}
};
```
+ API 세부 정보는 *AWS SDK for JavaScript API 참조*의 [UpdateTemplate](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/UpdateTemplateCommand)을 참조하세요.
------
#### [ Python ]
**SDK for Python (Boto3)**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/ses#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
class SesTemplate:
"""Encapsulates Amazon SES template functions."""
def __init__(self, ses_client):
"""
:param ses_client: A Boto3 Amazon SES client.
"""
self.ses_client = ses_client
self.template = None
self.template_tags = set()
def _extract_tags(self, subject, text, html):
"""
Extracts tags from a template as a set of unique values.
:param subject: The subject of the email.
:param text: The text version of the email.
:param html: The html version of the email.
"""
self.template_tags = set(re.findall(TEMPLATE_REGEX, subject + text + html))
logger.info("Extracted template tags: %s", self.template_tags)
def update_template(self, name, subject, text, html):
"""
Updates a previously created email template.
:param name: The name of the template.
:param subject: The subject of the email.
:param text: The plain text version of the email.
:param html: The HTML version of the email.
"""
try:
template = {
"TemplateName": name,
"SubjectPart": subject,
"TextPart": text,
"HtmlPart": html,
}
self.ses_client.update_template(Template=template)
logger.info("Updated template %s.", name)
self.template = template
self._extract_tags(subject, text, html)
except ClientError:
logger.exception("Couldn't update template %s.", name)
raise
```
+ API 세부 정보는 *AWS SDK for Python (Boto3) API 참조*의 [UpdateTemplate](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/UpdateTemplate)를 참조하세요.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP API**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/ses#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
DATA(lo_template) = NEW /aws1/cl_sestemplate(
iv_templatename = iv_name
iv_subjectpart = iv_subject
iv_textpart = iv_text
iv_htmlpart = iv_html
).
TRY.
lo_ses->updatetemplate( io_template = lo_template ).
MESSAGE 'Template updated successfully' TYPE 'I'.
CATCH /aws1/cx_sestmpldoesnotexistex INTO DATA(lo_ex1).
DATA(lv_error) = |Template does not exist: { lo_ex1->get_text( ) }|.
MESSAGE lv_error TYPE 'I'.
RAISE EXCEPTION lo_ex1.
CATCH /aws1/cx_sesinvalidtemplateex INTO DATA(lo_ex2).
lv_error = |Invalid template: { lo_ex2->get_text( ) }|.
MESSAGE lv_error TYPE 'I'.
RAISE EXCEPTION lo_ex2.
CATCH /aws1/cx_rt_generic INTO DATA(lo_ex_generic).
lv_error = |An error occurred: { lo_ex_generic->get_text( ) }|.
MESSAGE lv_error TYPE 'I'.
RAISE EXCEPTION lo_ex_generic.
ENDTRY.
```
+ API 세부 정보는 *AWS SDK for SAP ABAP API 참조*의 [UpdateTemplate](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)을 참조하세요.
------
# AWS SDK 또는 CLI와 `VerifyDomainIdentity` 함께 사용
다음 코드 예시는 `VerifyDomainIdentity`의 사용 방법을 보여 줍니다.
작업 예시는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [리전 전체에서 이메일 및 도메인 ID 복사](ses_example_ses_Scenario_ReplicateIdentities_section.md)
+ [이메일 ID 확인 및 메시지 전송](ses_example_ses_Scenario_SendEmail_section.md)
------
#### [ CLI ]
**AWS CLI**
**Amazon SES를 사용하여 도메인 확인**
다음 예시에서는 `verify-domain-identity` 명령을 사용하여 도메인을 확인합니다.
```
aws ses verify-domain-identity --domain example.com
```
출력:
```
{
"VerificationToken": "eoEmxw+YaYhb3h3iVJHuXMJXqeu1q1/wwmvjuEXAMPLE"
}
```
도메인 확인을 완료하려면 반환된 확인 토큰이 포함된 TXT 레코드를 도메인의 DNS 설정에 추가해야 합니다. 자세한 내용은 *Amazon Simple Email Service 개발자 안내서*의 Amazon SES에서 도메인 확인을 참조하세요.
+ API 세부 정보는 *AWS CLI 명령 참조*의 [VerifyDomainIdentity](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ses/verify-domain-identity.html)를 참조하세요.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
import { VerifyDomainIdentityCommand } from "@aws-sdk/client-ses";
import {
getUniqueName,
postfix,
} from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";
/**
* You must have access to the domain's DNS settings to complete the
* domain verification process.
*/
const DOMAIN_NAME = postfix(getUniqueName("Domain"), ".example.com");
const createVerifyDomainIdentityCommand = () => {
return new VerifyDomainIdentityCommand({ Domain: DOMAIN_NAME });
};
const run = async () => {
const VerifyDomainIdentityCommand = createVerifyDomainIdentityCommand();
try {
return await sesClient.send(VerifyDomainIdentityCommand);
} catch (err) {
console.log("Failed to verify domain.", err);
return err;
}
};
```
+ API 세부 정보는 *AWS SDK for JavaScript API 참조*의 [VerifyDomainIdentity](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/VerifyDomainIdentityCommand)를 참조하세요.
------
#### [ Python ]
**SDK for Python (Boto3)**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/ses#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
class SesIdentity:
"""Encapsulates Amazon SES identity functions."""
def __init__(self, ses_client):
"""
:param ses_client: A Boto3 Amazon SES client.
"""
self.ses_client = ses_client
def verify_domain_identity(self, domain_name):
"""
Starts verification of a domain identity. To complete verification, you must
create a TXT record with a specific format through your DNS provider.
For more information, see *Verifying a domain with Amazon SES* in the
Amazon SES documentation:
https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-domain-procedure.html
:param domain_name: The name of the domain to verify.
:return: The token to include in the TXT record with your DNS provider.
"""
try:
response = self.ses_client.verify_domain_identity(Domain=domain_name)
token = response["VerificationToken"]
logger.info("Got domain verification token for %s.", domain_name)
except ClientError:
logger.exception("Couldn't verify domain %s.", domain_name)
raise
else:
return token
```
+ API 세부 정보는 *AWS SDK for Python (Boto3) API 참조*의 [VerifyDomainIdentity](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/VerifyDomainIdentity)를 참조하세요.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP API**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/ses#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
TRY.
DATA(lo_result) = lo_ses->verifydomainidentity( iv_domain = iv_domain_name ).
ov_token = lo_result->get_verificationtoken( ).
MESSAGE 'Domain verification initiated' TYPE 'I'.
CATCH /aws1/cx_rt_generic INTO DATA(lo_ex).
DATA(lv_error) = |An error occurred: { lo_ex->get_text( ) }|.
MESSAGE lv_error TYPE 'I'.
RAISE EXCEPTION lo_ex.
ENDTRY.
```
+ API 세부 정보는 SDK for SAP ABAP API 참조의 [VerifyDomainIdentity](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)를 참조하세요. *AWS *
------
# AWS SDK 또는 CLI와 `VerifyEmailIdentity` 함께 사용
다음 코드 예시는 `VerifyEmailIdentity`의 사용 방법을 보여 줍니다.
작업 예시는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [리전 전체에서 이메일 및 도메인 ID 복사](ses_example_ses_Scenario_ReplicateIdentities_section.md)
+ [이메일 ID 확인 및 메시지 전송](ses_example_ses_Scenario_SendEmail_section.md)
------
#### [ .NET ]
**SDK for .NET**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/SES#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
///
/// Starts verification of an email identity. This request sends an email
/// from Amazon SES to the specified email address. To complete
/// verification, follow the instructions in the email.
///
/// Email address to verify.
/// True if successful.
public async Task VerifyEmailIdentityAsync(string recipientEmailAddress)
{
var success = false;
try
{
var response = await _amazonSimpleEmailService.VerifyEmailIdentityAsync(
new VerifyEmailIdentityRequest
{
EmailAddress = recipientEmailAddress
});
success = response.HttpStatusCode == HttpStatusCode.OK;
}
catch (Exception ex)
{
Console.WriteLine("VerifyEmailIdentityAsync failed with exception: " + ex.Message);
}
return success;
}
```
+ API 세부 정보는 *AWS SDK for .NET SDK API 참조*의 [VerifyEmailIdentity](https://docs.aws.amazon.com/goto/DotNetSDKV3/email-2010-12-01/VerifyEmailIdentity)를 참조하십시오.
------
#### [ C\$1\$1 ]
**SDK for C\$1\$1**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/ses#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
//! Add an email address to the list of identities associated with this account and
//! initiate verification.
/*!
\param emailAddress; The email address to add.
\param clientConfiguration: AWS client configuration.
\return bool: Function succeeded.
*/
bool AwsDoc::SES::verifyEmailIdentity(const Aws::String &emailAddress,
const Aws::Client::ClientConfiguration &clientConfiguration)
{
Aws::SES::SESClient sesClient(clientConfiguration);
Aws::SES::Model::VerifyEmailIdentityRequest verifyEmailIdentityRequest;
verifyEmailIdentityRequest.SetEmailAddress(emailAddress);
Aws::SES::Model::VerifyEmailIdentityOutcome outcome = sesClient.VerifyEmailIdentity(verifyEmailIdentityRequest);
if (outcome.IsSuccess())
{
std::cout << "Email verification initiated." << std::endl;
}
else
{
std::cerr << "Error initiating email verification. " << outcome.GetError().GetMessage()
<< std::endl;
}
return outcome.IsSuccess();
}
```
+ API 세부 정보는 *AWS SDK for C\$1\$1 SDK API 참조*의 [VerifyEmailIdentity](https://docs.aws.amazon.com/goto/SdkForCpp/email-2010-12-01/VerifyEmailIdentity)를 참조하세요.
------
#### [ CLI ]
**AWS CLI**
**Amazon SES로 이메일 주소 확인**
다음 예시에서는 `verify-email-identity` 명령을 사용하여 이메일 주소를 확인합니다.
```
aws ses verify-email-identity --email-address user@example.com
```
Amazon SES를 사용하여 이메일을 보내려면 발신 이메일 주소 또는 도메인이 사용자 본인의 소유인지 확인해야 합니다. 프로덕션 액세스 권한이 아직 없는 경우Amazon SES 메일박스 시뮬레이터에서 제공하는 이메일 주소를 제외하고 이메일을 전송하는 모든 이메일 주소도 확인해야 합니다.
verify-email-identity가 직접적으로 호출되면 해당 이메일 주소에 확인 이메일이 전송됩니다. 확인 프로세스를 완료하려면 이메일에 포함된 링크를 클릭해야 합니다.
자세한 내용은 *Amazon Simple Email Service 개발자 안내서*의 Amazon SES에서 이메일 주소 확인을 참조하세요.
+ API 세부 정보는 *AWS CLI 명령 참조*의 [VerifyEmailIdentity](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ses/verify-email-identity.html)를 참조하세요.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
// Import required AWS SDK clients and commands for Node.js
import { VerifyEmailIdentityCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";
const EMAIL_ADDRESS = "name@example.com";
const createVerifyEmailIdentityCommand = (emailAddress) => {
return new VerifyEmailIdentityCommand({ EmailAddress: emailAddress });
};
const run = async () => {
const verifyEmailIdentityCommand =
createVerifyEmailIdentityCommand(EMAIL_ADDRESS);
try {
return await sesClient.send(verifyEmailIdentityCommand);
} catch (err) {
console.log("Failed to verify email identity.", err);
return err;
}
};
```
+ API 세부 정보는 *AWS SDK for JavaScript SDK API 참조*의 [VerifyEmailIdentity](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/VerifyEmailIdentityCommand)를 참조하십시오.
------
#### [ Python ]
**SDK for Python (Boto3)**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/ses#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
class SesIdentity:
"""Encapsulates Amazon SES identity functions."""
def __init__(self, ses_client):
"""
:param ses_client: A Boto3 Amazon SES client.
"""
self.ses_client = ses_client
def verify_email_identity(self, email_address):
"""
Starts verification of an email identity. This function causes an email
to be sent to the specified email address from Amazon SES. To complete
verification, follow the instructions in the email.
:param email_address: The email address to verify.
"""
try:
self.ses_client.verify_email_identity(EmailAddress=email_address)
logger.info("Started verification of %s.", email_address)
except ClientError:
logger.exception("Couldn't start verification of %s.", email_address)
raise
```
+ API 세부 정보는 *AWS SDK for Python (Boto3) API 참조*의 [VerifyEmailIdentity](https://docs.aws.amazon.com/goto/boto3/email-2010-12-01/VerifyEmailIdentity)를 참조하세요.
------
#### [ Ruby ]
**SDK for Ruby**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/ses/v1#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
require 'aws-sdk-ses' # v2: require 'aws-sdk'
# Replace recipient@example.com with a "To" address.
recipient = 'recipient@example.com'
# Create a new SES resource in the us-west-2 region.
# Replace us-west-2 with the AWS Region you're using for Amazon SES.
ses = Aws::SES::Client.new(region: 'us-west-2')
# Try to verify email address.
begin
ses.verify_email_identity({
email_address: recipient
})
puts "Email sent to #{recipient}"
# If something goes wrong, display an error message.
rescue Aws::SES::Errors::ServiceError => e
puts "Email not sent. Error message: #{e}"
end
```
+ API 세부 정보는 *AWS SDK for Ruby SDK API 참조*의 [VerifyEmailIdentity](https://docs.aws.amazon.com/goto/SdkForRubyV3/email-2010-12-01/VerifyEmailIdentity)를 참조하세요.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP API**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/ses#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
TRY.
lo_ses->verifyemailidentity( iv_emailaddress = iv_email_address ).
MESSAGE 'Email verification initiated' TYPE 'I'.
CATCH /aws1/cx_rt_generic INTO DATA(lo_ex).
DATA(lv_error) = |An error occurred: { lo_ex->get_text( ) }|.
MESSAGE lv_error TYPE 'I'.
RAISE EXCEPTION lo_ex.
ENDTRY.
```
+ API 세부 정보는 SDK for SAP ABAP API 참조의 [VerifyEmailIdentity](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)를 참조하세요. *AWS *
------
# AWS SDKs를 사용한 Amazon SES 시나리오
다음 코드 예제에서는 Amazon SES AWS SDKs에서 일반적인 시나리오를 구현하는 방법을 보여줍니다. 이러한 시나리오에서는 Amazon SES 내에서 또는 다른 AWS 서비스와 결합된 상태에서 여러 함수를 직접적으로 호출하여 특정 태스크를 수행하는 방법을 보여줍니다. 각 시나리오에는 전체 소스 코드에 대한 링크가 포함되어 있습니다. 여기에서 코드를 설정 및 실행하는 방법에 대한 지침을 찾을 수 있습니다.
시나리오는 컨텍스트에 맞는 서비스 작업을 이해하는 데 도움이 되도록 중급 수준의 경험을 대상으로 합니다.
**Topics**
+ [Amazon Transcribe 스트리밍 앱 구축](ses_example_cross_TranscriptionStreamingApp_section.md)
+ [리전 전체에서 이메일 및 도메인 ID 복사](ses_example_ses_Scenario_ReplicateIdentities_section.md)
+ [DynamoDB 데이터를 추적하는 웹 애플리케이션 만들기](ses_example_cross_DynamoDBDataTracker_section.md)
+ [Amazon Redshift 데이터를 추적하는 웹 애플리케이션 만들기](ses_example_cross_RedshiftDataTracker_section.md)
+ [Aurora 서버리스 작업 항목 트래커 만들기](ses_example_cross_RDSDataTracker_section.md)
+ [이미지에서 PPE 감지](ses_example_cross_RekognitionPhotoAnalyzerPPE_section.md)
+ [이미지에서 객체 감지](ses_example_cross_RekognitionPhotoAnalyzer_section.md)
+ [동영상에서 사람과 객체 감지](ses_example_cross_RekognitionVideoDetection_section.md)
+ [SMTP 엔드포인트에 연결하는 자격 증명 생성](ses_example_ses_Scenario_GenerateSmtpCredentials_section.md)
+ [Step Functions를 사용하여 Lambda 함수 간접 호출](ses_example_cross_ServerlessWorkflows_section.md)
+ [이메일 ID 확인 및 메시지 전송](ses_example_ses_Scenario_SendEmail_section.md)
# Amazon Transcribe 스트리밍 앱 구축
다음 코드 예제에서는 라이브 오디오를 실시간으로 기록, 변환 및 번역하고 결과를 이메일로 보내는 앱을 구축하는 방법을 보여줍니다.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
Amazon Transcribe를 사용하여 라이브 오디오를 실시간으로 기록, 변환 및 번역하고 Amazon Simple Email Service(Amazon SES)를 사용하여 결과를 이메일로 전송하는 앱을 구축하는 방법을 보여줍니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/transcribe-streaming-app)에서 전체 예시를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Amazon Comprehend
+ Amazon SES
+ Amazon Transcribe
+ Amazon Translate
------
# AWS SDK를 사용하여 한 AWS 리전에서 다른 리전으로 Amazon SES 이메일 및 도메인 자격 증명 복사
다음 코드 예제에서는 Amazon SES 이메일 및 도메인 자격 증명을 한 AWS 리전에서 다른 리전으로 복사하는 방법을 보여줍니다. Route 53에서 도메인 ID를 관리하는 경우 확인 레코드가 대상 리전의 도메인에 복사됩니다.
------
#### [ Python ]
**SDK for Python (Boto3)**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/ses#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
import argparse
import json
import logging
from pprint import pprint
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def get_identities(ses_client):
"""
Gets the identities for the current Region. The Region is specified in the
Boto3 Amazon SES client object.
:param ses_client: A Boto3 Amazon SES client.
:return: The list of email identities and the list of domain identities.
"""
email_identities = []
domain_identities = []
try:
identity_paginator = ses_client.get_paginator("list_identities")
identity_iterator = identity_paginator.paginate(
PaginationConfig={"PageSize": 20}
)
for identity_page in identity_iterator:
for identity in identity_page["Identities"]:
if "@" in identity:
email_identities.append(identity)
else:
domain_identities.append(identity)
logger.info(
"Found %s email and %s domain identities.",
len(email_identities),
len(domain_identities),
)
except ClientError:
logger.exception("Couldn't get identities.")
raise
else:
return email_identities, domain_identities
def verify_emails(email_list, ses_client):
"""
Starts verification of a list of email addresses. Verification causes an email
to be sent to each address. To complete verification, the recipient must follow
the instructions in the email.
:param email_list: The list of email addresses to verify.
:param ses_client: A Boto3 Amazon SES client.
:return: The list of emails that were successfully submitted for verification.
"""
verified_emails = []
for email in email_list:
try:
ses_client.verify_email_identity(EmailAddress=email)
verified_emails.append(email)
logger.info("Started verification of %s.", email)
except ClientError:
logger.warning("Couldn't start verification of %s.", email)
return verified_emails
def verify_domains(domain_list, ses_client):
"""
Starts verification for a list of domain identities. This returns a token for
each domain, which must be registered as a TXT record with the DNS provider for
the domain.
:param domain_list: The list of domains to verify.
:param ses_client: A Boto3 Amazon SES client.
:return: The generated domain tokens to use to completed verification.
"""
domain_tokens = {}
for domain in domain_list:
try:
response = ses_client.verify_domain_identity(Domain=domain)
token = response["VerificationToken"]
domain_tokens[domain] = token
logger.info("Got verification token %s for domain %s.", token, domain)
except ClientError:
logger.warning("Couldn't get verification token for domain %s.", domain)
return domain_tokens
def get_hosted_zones(route53_client):
"""
Gets the Amazon Route 53 hosted zones for the current account.
:param route53_client: A Boto3 Route 53 client.
:return: The list of hosted zones.
"""
zones = []
try:
zone_paginator = route53_client.get_paginator("list_hosted_zones")
zone_iterator = zone_paginator.paginate(PaginationConfig={"PageSize": 20})
zones = [
zone for zone_page in zone_iterator for zone in zone_page["HostedZones"]
]
logger.info("Found %s hosted zones.", len(zones))
except ClientError:
logger.warning("Couldn't get hosted zones.")
return zones
def find_domain_zone_matches(domains, zones):
"""
Finds matches between Amazon SES verified domains and Route 53 hosted zones.
Subdomain matches are taken when found, otherwise root domain matches are taken.
:param domains: The list of domains to match.
:param zones: The list of hosted zones to match.
:return: The set of matched domain-zone pairs. When a match is not found, the
domain is included in the set with a zone value of None.
"""
domain_zones = {}
for domain in domains:
domain_zones[domain] = None
# Start at the most specific sub-domain and walk up to the root domain until a
# zone match is found.
domain_split = domain.split(".")
for index in range(0, len(domain_split) - 1):
sub_domain = ".".join(domain_split[index:])
for zone in zones:
# Normalize the zone name from Route 53 by removing the trailing '.'.
zone_name = zone["Name"][:-1]
if sub_domain == zone_name:
domain_zones[domain] = zone
break
if domain_zones[domain] is not None:
break
return domain_zones
def add_route53_verification_record(domain, token, zone, route53_client):
"""
Adds a domain verification TXT record to the specified Route 53 hosted zone.
When a TXT record already exists in the hosted zone for the specified domain,
the existing values are preserved and the new token is added to the list.
:param domain: The domain to add.
:param token: The verification token for the domain.
:param zone: The hosted zone where the domain verification record is added.
:param route53_client: A Boto3 Route 53 client.
"""
domain_token_record_set_name = f"_amazonses.{domain}"
record_set_paginator = route53_client.get_paginator("list_resource_record_sets")
record_set_iterator = record_set_paginator.paginate(
HostedZoneId=zone["Id"], PaginationConfig={"PageSize": 20}
)
records = []
for record_set_page in record_set_iterator:
try:
txt_record_set = next(
record_set
for record_set in record_set_page["ResourceRecordSets"]
if record_set["Name"][:-1] == domain_token_record_set_name
and record_set["Type"] == "TXT"
)
records = txt_record_set["ResourceRecords"]
logger.info(
"Existing TXT record found in set %s for zone %s.",
domain_token_record_set_name,
zone["Name"],
)
break
except StopIteration:
pass
records.append({"Value": json.dumps(token)})
changes = [
{
"Action": "UPSERT",
"ResourceRecordSet": {
"Name": domain_token_record_set_name,
"Type": "TXT",
"TTL": 1800,
"ResourceRecords": records,
},
}
]
try:
route53_client.change_resource_record_sets(
HostedZoneId=zone["Id"], ChangeBatch={"Changes": changes}
)
logger.info(
"Created or updated the TXT record in set %s for zone %s.",
domain_token_record_set_name,
zone["Name"],
)
except ClientError as err:
logger.warning(
"Got error %s. Couldn't create or update the TXT record for zone %s.",
err.response["Error"]["Code"],
zone["Name"],
)
def generate_dkim_tokens(domain, ses_client):
"""
Generates DKIM tokens for a domain. These must be added as CNAME records to the
DNS provider for the domain.
:param domain: The domain to generate tokens for.
:param ses_client: A Boto3 Amazon SES client.
:return: The list of generated DKIM tokens.
"""
dkim_tokens = []
try:
dkim_tokens = ses_client.verify_domain_dkim(Domain=domain)["DkimTokens"]
logger.info("Generated %s DKIM tokens for domain %s.", len(dkim_tokens), domain)
except ClientError:
logger.warning("Couldn't generate DKIM tokens for domain %s.", domain)
return dkim_tokens
def add_dkim_domain_tokens(hosted_zone, domain, tokens, route53_client):
"""
Adds DKIM domain token CNAME records to a Route 53 hosted zone.
:param hosted_zone: The hosted zone where the records are added.
:param domain: The domain to add.
:param tokens: The DKIM tokens for the domain to add.
:param route53_client: A Boto3 Route 53 client.
"""
try:
changes = [
{
"Action": "UPSERT",
"ResourceRecordSet": {
"Name": f"{token}._domainkey.{domain}",
"Type": "CNAME",
"TTL": 1800,
"ResourceRecords": [{"Value": f"{token}.dkim.amazonses.com"}],
},
}
for token in tokens
]
route53_client.change_resource_record_sets(
HostedZoneId=hosted_zone["Id"], ChangeBatch={"Changes": changes}
)
logger.info(
"Added %s DKIM CNAME records to %s in zone %s.",
len(tokens),
domain,
hosted_zone["Name"],
)
except ClientError:
logger.warning(
"Couldn't add DKIM CNAME records for %s to zone %s.",
domain,
hosted_zone["Name"],
)
def configure_sns_topics(identity, topics, ses_client):
"""
Configures Amazon Simple Notification Service (Amazon SNS) notifications for
an identity. The Amazon SNS topics must already exist.
:param identity: The identity to configure.
:param topics: The list of topics to configure. The choices are Bounce, Delivery,
or Complaint.
:param ses_client: A Boto3 Amazon SES client.
"""
for topic in topics:
topic_arn = input(
f"Enter the Amazon Resource Name (ARN) of the {topic} topic or press "
f"Enter to skip: "
)
if topic_arn != "":
try:
ses_client.set_identity_notification_topic(
Identity=identity, NotificationType=topic, SnsTopic=topic_arn
)
logger.info("Configured %s for %s notifications.", identity, topic)
except ClientError:
logger.warning(
"Couldn't configure %s for %s notifications.", identity, topic
)
def replicate(source_client, destination_client, route53_client):
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
print("-" * 88)
print(
f"Replicating Amazon SES identities and other configuration from "
f"{source_client.meta.region_name} to {destination_client.meta.region_name}."
)
print("-" * 88)
print(f"Retrieving identities from {source_client.meta.region_name}.")
source_emails, source_domains = get_identities(source_client)
print("Email addresses found:")
print(*source_emails)
print("Domains found:")
print(*source_domains)
print("Starting verification for email identities.")
dest_emails = verify_emails(source_emails, destination_client)
print("Getting domain tokens for domain identities.")
dest_domain_tokens = verify_domains(source_domains, destination_client)
# Get Route 53 hosted zones and match them with Amazon SES domains.
answer = input(
"Is the DNS configuration for your domains managed by Amazon Route 53 (y/n)? "
)
use_route53 = answer.lower() == "y"
hosted_zones = get_hosted_zones(route53_client) if use_route53 else []
if use_route53:
print("Adding or updating Route 53 TXT records for your domains.")
domain_zones = find_domain_zone_matches(dest_domain_tokens.keys(), hosted_zones)
for domain in domain_zones:
add_route53_verification_record(
domain, dest_domain_tokens[domain], domain_zones[domain], route53_client
)
else:
print(
"Use these verification tokens to create TXT records through your DNS "
"provider:"
)
pprint(dest_domain_tokens)
answer = input("Do you want to configure DKIM signing for your identities (y/n)? ")
if answer.lower() == "y":
# Build a set of unique domains from email and domain identities.
domains = {email.split("@")[1] for email in dest_emails}
domains.update(dest_domain_tokens)
domain_zones = find_domain_zone_matches(domains, hosted_zones)
for domain, zone in domain_zones.items():
answer = input(
f"Do you want to configure DKIM signing for {domain} (y/n)? "
)
if answer.lower() == "y":
dkim_tokens = generate_dkim_tokens(domain, destination_client)
if use_route53 and zone is not None:
add_dkim_domain_tokens(zone, domain, dkim_tokens, route53_client)
else:
print(
"Add the following DKIM tokens as CNAME records through your "
"DNS provider:"
)
print(*dkim_tokens, sep="\n")
answer = input(
"Do you want to configure Amazon SNS notifications for your identities (y/n)? "
)
if answer.lower() == "y":
for identity in dest_emails + list(dest_domain_tokens.keys()):
answer = input(
f"Do you want to configure Amazon SNS topics for {identity} (y/n)? "
)
if answer.lower() == "y":
configure_sns_topics(
identity, ["Bounce", "Delivery", "Complaint"], destination_client
)
print(f"Replication complete for {destination_client.meta.region_name}.")
print("-" * 88)
def main():
boto3_session = boto3.Session()
ses_regions = boto3_session.get_available_regions("ses")
parser = argparse.ArgumentParser(
description="Copies email address and domain identities from one AWS Region to "
"another. Optionally adds records for domain verification and DKIM "
"signing to domains that are managed by Amazon Route 53, "
"and sets up Amazon SNS notifications for events of interest."
)
parser.add_argument(
"source_region", choices=ses_regions, help="The region to copy from."
)
parser.add_argument(
"destination_region", choices=ses_regions, help="The region to copy to."
)
args = parser.parse_args()
source_client = boto3.client("ses", region_name=args.source_region)
destination_client = boto3.client("ses", region_name=args.destination_region)
route53_client = boto3.client("route53")
replicate(source_client, destination_client, route53_client)
if __name__ == "__main__":
main()
```
+ API 세부 정보는 *AWS SDK for Python (Boto3) API 참조*의 다음 주제를 참조하세요.
+ [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)
------
# DynamoDB 데이터를 추적하는 웹 애플리케이션 만들기
다음 코드 예제에서는 Amazon DynamoDB 테이블에서 작업 항목을 추적하고 Amazon Simple Email Service(Amazon SES)를 사용하여 보고서를 보내는 웹 애플리케이션 생성 방법을 보여 줍니다.
------
#### [ .NET ]
**SDK for .NET**
Amazon DynamoDB .NET API를 사용하여 DynamoDB 작업 데이터를 추적하는 동적 웹 애플리케이션을 만드는 방법을 보여줍니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/DynamoDbItemTracker)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ DynamoDB
+ Amazon SES
------
#### [ Java ]
**SDK for Java 2.x**
Amazon DynamoDB API를 사용하여 DynamoDB 작업 데이터를 추적하는 동적 웹 애플리케이션을 만드는 방법을 보여줍니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/creating_dynamodb_web_app)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ DynamoDB
+ Amazon SES
------
#### [ Kotlin ]
**SDK for Kotlin**
Amazon DynamoDB API를 사용하여 DynamoDB 작업 데이터를 추적하는 동적 웹 애플리케이션을 만드는 방법을 보여줍니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/usecases/itemtracker_dynamodb)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ DynamoDB
+ Amazon SES
------
#### [ Python ]
**SDK for Python(Boto3)**
AWS SDK for Python (Boto3) 를 사용하여 Amazon DynamoDB의 작업 항목을 추적하고 Amazon Simple Email Service(Amazon SES)를 사용하여 보고서를 이메일로 보내는 REST 서비스를 생성하는 방법을 보여줍니다. 이 예제는 Flask 웹 프레임워크를 사용하여 HTTP 라우팅을 처리하고 React 웹 페이지와 통합하여 완전한 기능을 갖춘 웹 애플리케이션을 제공합니다.
+ 와 통합되는 Flask REST 서비스를 빌드합니다 AWS 서비스.
+ DynamoDB 테이블에 저장된 작업 항목을 읽고, 쓰고, 업데이트합니다.
+ Amazon SES를 사용하여 작업 항목에 대한 이메일 보고서를 보냅니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 GitHub의 [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/dynamodb_item_tracker)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ DynamoDB
+ Amazon SES
------
# Amazon Redshift 항목 추적기 만들기
다음 코드 예제에서는 Amazon Redshift 데이터베이스를 사용한 작업 항목을 추적하고 보고하는 웹 애플리케이션을 생성하는 방법을 보여줍니다.
------
#### [ Java ]
**SDK for Java 2.x**
Amazon Redshift 데이터베이스에 저장된 작업 항목을 추적하고 보고하는 웹 애플리케이션을 만드는 방법을 보여줍니다.
Amazon Redshift 데이터를 쿼리하고 React 애플리케이션에서 사용하도록 Spring REST API를 설정하는 방법에 대한 지침과 전체 소스 코드는 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/CreatingSpringRedshiftRest)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Amazon Redshift
+ Amazon SES
------
#### [ Kotlin ]
**SDK for Kotlin**
Amazon Redshift 데이터베이스에 저장된 작업 항목을 추적하고 보고하는 웹 애플리케이션을 만드는 방법을 보여줍니다.
Amazon Redshift 데이터를 쿼리하고 React 애플리케이션에서 사용하도록 Spring REST API를 설정하는 방법에 대한 지침과 전체 소스 코드는 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/usecases/creating_redshift_application)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Amazon Redshift
+ Amazon SES
------
# Aurora 서버리스 작업 항목 트래커 만들기
다음 코드 예제는 Amazon Aurora Serverless 데이터베이스에서 작업 항목을 추적하고 Amazon Simple Email Service(Amazon SES)를 사용하여 보고서를 보내는 웹 애플리케이션을 만드는 방법을 보여 줍니다.
------
#### [ .NET ]
**SDK for .NET**
AWS SDK for .NET 를 사용하여 Amazon Aurora 데이터베이스의 작업 항목을 추적하고 Amazon Simple Email Service(Amazon SES)를 사용하여 보고서를 이메일로 보내는 웹 애플리케이션을 생성하는 방법을 보여줍니다. 이 예제에서는 RESTful .NET 백엔드와의 상호 작용을 위해 React.js로 빌드된 프런트엔드를 사용합니다.
+ React 웹 애플리케이션을 AWS 서비스와 통합합니다.
+ Aurora 테이블의 항목을 나열, 추가, 업데이트 및 삭제합니다.
+ Amazon SES를 사용하여 필터링된 작업 항목에 대한 이메일 보고서를 보냅니다.
+ 포함된 AWS CloudFormation 스크립트를 사용하여 예제 리소스를 배포하고 관리합니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/AuroraItemTracker)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Aurora
+ Amazon RDS
+ Amazon RDS 데이터 서비스
+ Amazon SES
------
#### [ C\$1\$1 ]
**SDK for C\$1\$1**
Amazon Aurora Serverless 데이터베이스에 저장된 작업 항목을 추적하고 보고하는 웹 애플리케이션을 만드는 방법을 보여줍니다.
Amazon Aurora Serverless 데이터를 쿼리하고 React 애플리케이션에서 사용하도록 C\$1\$1 REST API를 설정하는 방법에 대한 지침과 전체 소스 코드는 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cross-service/serverless-aurora)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Aurora
+ Amazon RDS
+ Amazon RDS 데이터 서비스
+ Amazon SES
------
#### [ Java ]
**SDK for Java 2.x**
Amazon RDS 데이터베이스에 저장된 작업 항목을 추적하고 보고하는 웹 애플리케이션을 만드는 방법을 보여줍니다.
Amazon Aurora Serverless 데이터를 쿼리하고 React 애플리케이션에서 사용하도록 Spring REST API를 설정하는 방법에 대한 지침과 전체 소스 코드는 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/Creating_Spring_RDS_Rest)에서 전체 예제를 참조하세요.
JDBC API를 사용한 예제를 설정하고 실행하는 방법에 대한 전체 소스 코드와 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/Creating_rds_item_tracker)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Aurora
+ Amazon RDS
+ Amazon RDS 데이터 서비스
+ Amazon SES
------
#### [ JavaScript ]
**SDK for JavaScript(v3)**
AWS SDK for JavaScript (v3)를 사용하여 Amazon Aurora 데이터베이스의 작업 항목을 추적하고 Amazon Simple Email Service(Amazon SES)를 사용하여 보고서를 이메일로 보내는 웹 애플리케이션을 생성하는 방법을 보여줍니다. 이 예제에서는 Express Node.js 백엔드와의 상호 작용을 위해 React.js로 빌드된 프런트엔드를 사용합니다.
+ React.js 웹 애플리케이션을와 통합합니다 AWS 서비스.
+ Aurora 테이블의 항목을 나열, 추가 및 업데이트합니다.
+ Amazon SES를 사용하여 필터링된 작업 항목에 대한 이메일 보고서를 보냅니다.
+ 포함된 AWS CloudFormation 스크립트를 사용하여 예제 리소스를 배포하고 관리합니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/aurora-serverless-app)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Aurora
+ Amazon RDS
+ Amazon RDS 데이터 서비스
+ Amazon SES
------
#### [ Kotlin ]
**SDK for Kotlin**
Amazon RDS 데이터베이스에 저장된 작업 항목을 추적하고 보고하는 웹 애플리케이션을 만드는 방법을 보여줍니다.
Amazon Aurora Serverless 데이터를 쿼리하고 React 애플리케이션에서 사용하도록 Spring REST API를 설정하는 방법에 대한 지침과 전체 소스 코드는 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/usecases/serverless_rds)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Aurora
+ Amazon RDS
+ Amazon RDS 데이터 서비스
+ Amazon SES
------
#### [ PHP ]
**SDK for PHP**
AWS SDK for PHP 를 사용하여 Amazon RDS 데이터베이스의 작업 항목을 추적하고 Amazon Simple Email Service(Amazon SES)를 사용하여 보고서를 이메일로 보내는 웹 애플리케이션을 생성하는 방법을 보여줍니다. 이 예제에서는 RESTful PHP 백엔드와의 상호 작용을 위해 React.js로 빌드된 프런트엔드를 사용합니다.
+ React.js 웹 애플리케이션을 AWS 서비스와 통합합니다.
+ Amazon RDS 테이블의 항목을 나열, 추가, 업데이트 및 삭제합니다.
+ Amazon SES를 사용하여 필터링된 작업 항목에 대한 이메일 보고서를 보냅니다.
+ 포함된 AWS CloudFormation 스크립트를 사용하여 예제 리소스를 배포하고 관리합니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/cross_service/aurora_item_tracker)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Aurora
+ Amazon RDS
+ Amazon RDS 데이터 서비스
+ Amazon SES
------
#### [ Python ]
**SDK for Python(Boto3)**
AWS SDK for Python (Boto3) 를 사용하여 Amazon Aurora Serverless 데이터베이스의 작업 항목을 추적하고 Amazon Simple Email Service(Amazon SES)를 사용하여 보고서를 이메일로 보내는 REST 서비스를 생성하는 방법을 보여줍니다. 이 예제는 Flask 웹 프레임워크를 사용하여 HTTP 라우팅을 처리하고 React 웹 페이지와 통합하여 완전한 기능을 갖춘 웹 애플리케이션을 제공합니다.
+ 와 통합되는 Flask REST 서비스를 빌드합니다 AWS 서비스.
+ Aurora Serverless 데이터베이스에 저장된 작업 항목을 읽고, 쓰고, 업데이트합니다.
+ 데이터베이스 자격 증명이 포함된 AWS Secrets Manager 보안 암호를 생성하고 이를 사용하여 데이터베이스에 대한 호출을 인증합니다.
+ Amazon SES를 사용하여 작업 항목에 대한 이메일 보고서를 보냅니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/aurora_item_tracker)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Aurora
+ Amazon RDS
+ Amazon RDS 데이터 서비스
+ Amazon SES
------
# AWS SDK를 사용하여 Amazon Rekognition으로 이미지에서 PPE 감지
다음 코드 예제에서는 Amazon Rekognition을 사용하여 이미지에서 개인 보호 장비(PPE)를 감지하는 앱을 구축하는 방법을 보여줍니다.
------
#### [ Java ]
**SDK for Java 2.x**
개인 보호 장비로 이미지를 감지하는 AWS Lambda 함수를 생성하는 방법을 보여줍니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/creating_lambda_ppe)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ DynamoDB
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
------
# AWS SDK를 사용하여 Amazon Rekognition으로 이미지의 객체 감지
다음 코드 예제에서는 Amazon Rekognition을 사용하여 이미지에서 범주별 객체를 감지하는 앱을 구축하는 방법을 보여줍니다.
------
#### [ .NET ]
**SDK for .NET**
Amazon Rekognition .NET을 사용하여 Amazon Simple Storage Service (Amazon S3) 버킷에 있는 이미지에서 범주별로 객체를 식별하기 위해 Amazon Rekognition을 사용하여 앱을 생성하는 방법을 보여줍니다. 이 앱은 Amazon Simple Email Service(Amazon SES)를 사용하여 결과와 함께 이메일 알림을 관리자에게 보냅니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/PhotoAnalyzerApp)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
------
#### [ Java ]
**SDK for Java 2.x**
Amazon Rekognition을 사용하여 Amazon Simple Storage Service(Amazon S3) 버킷에 있는 이미지에서 범주별로 객체를 식별하기 위해 Amazon Rekognition을 사용하여 앱을 만드는 방법을 보여줍니다. 이 앱은 Amazon Simple Email Service(Amazon SES)를 사용하여 결과와 함께 이메일 알림을 관리자에게 보냅니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/creating_photo_analyzer_app)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
------
#### [ JavaScript ]
**SDK for JavaScript(v3)**
와 함께 Amazon Rekognition AWS SDK for JavaScript 을 사용하여 Amazon Simple Storage Service(Amazon S3) 버킷에 있는 이미지에서 Amazon Rekognition을 사용하여 범주별로 객체를 식별하는 앱을 생성하는 방법을 보여줍니다. 이 앱은 Amazon Simple Email Service(Amazon SES)를 사용하여 결과와 함께 이메일 알림을 관리자에게 보냅니다.
다음 작업을 수행하는 방법에 대해 알아보세요.
+ Amazon Cognito를 사용하여 인증되지 않은 사용자를 만듭니다.
+ Amazon Rekognition을 사용하여 객체용 이미지를 분석합니다.
+ Amazon SES 이메일 주소를 확인합니다.
+ Amazon SES를 사용하여 이메일 알림을 전송합니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/photo_analyzer)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
------
#### [ Kotlin ]
**SDK for Kotlin**
Amazon Rekognition Kotlin API를 사용하여 Amazon Simple Storage Service(Amazon S3) 버킷에 있는 이미지에서 범주별로 객체를 식별하기 위해 Amazon Rekognition을 사용하여 앱을 만드는 방법을 보여줍니다. 이 앱은 Amazon Simple Email Service(Amazon SES)를 사용하여 결과와 함께 이메일 알림을 관리자에게 보냅니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/usecases/creating_photo_analyzer_app)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
------
#### [ Python ]
**SDK for Python(Boto3)**
를 사용하여 다음을 수행할 수 있는 웹 애플리케이션을 AWS SDK for Python (Boto3) 생성하는 방법을 보여줍니다.
+ 사진을 Amazon Simple Storage Service(Amazon S3) 버킷에 업로드합니다.
+ Amazon Rekognition을 사용하여 사진을 분석하고 레이블을 지정합니다.
+ Amazon Simple Email Service(Amazon SES)를 사용하여 이미지 분석에 대한 이메일 보고서를 보냅니다.
이 예제에는 두 가지 주요 구성 요소가 포함되어 있습니다. 바로 JavaScript로 작성되고 React로 빌드된 웹 페이지와 Python으로 작성되고 Flask-RESTful로 빌드된 REST 서비스입니다.
React 웹 페이지를 사용하여 다음을 수행할 수 있습니다.
+ S3 버킷에 저장된 이미지 목록을 표시합니다.
+ 컴퓨터에서 S3 버킷에 이미지를 업로드합니다.
+ 이미지에서 감지된 항목을 식별하는 이미지와 레이블을 표시합니다.
+ S3 버킷의 모든 이미지에 대한 보고서를 받고 보고서의 이메일을 보냅니다.
웹 페이지가 REST 서비스를 호출합니다. 서비스가 다음 작업을 수행하기 위해 AWS 에 요청을 전송합니다.
+ S3 버킷의 이미지 목록을 가져오고 필터링합니다.
+ S3 버킷에 사진을 업로드합니다.
+ Amazon Rekognition을 사용하여 개별 사진을 분석하고 사진에서 감지된 항목을 식별하는 레이블 목록을 가져옵니다.
+ S3 버킷의 모든 사진을 분석하고 Amazon SES를 사용하여 보고서를 이메일로 보냅니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/photo_analyzer)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
------
# AWS SDK를 사용하여 Amazon Rekognition을 사용하여 비디오에서 사람 및 객체 감지
다음 코드 예제에서는 Amazon Rekognition을 사용하여 동영상에서 사람과 객체를 감지하는 방법을 보여줍니다.
------
#### [ Java ]
**SDK for Java 2.x**
Amazon Rekognition Java API를 사용하여 Amazon Simple Storage Service(Amazon S3) 버킷에 있는 동영상에서 얼굴과 객체를 감지하기 위한 앱을 만드는 방법을 보여줍니다. 이 앱은 Amazon Simple Email Service(Amazon SES)를 사용하여 결과와 함께 이메일 알림을 관리자에게 보냅니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/video_analyzer_application)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
+ Amazon SNS
+ Amazon SQS
------
#### [ Python ]
**SDK for Python(Boto3)**
Amazon Rekognition을 사용하여 비동기식 감지 작업을 시작해 동영상의 얼굴, 객체 및 사람을 감지할 수 있습니다. 또한 이 예제에서는 작업이 완료되고 주제에 대한 Amazon Simple Queue Service(Amazon SQS) 대기열을 구독할 때 Amazon Simple Notification Service(Amazon SNS) 주제를 알리도록 Amazon Rekognition을 구성합니다. 대기열이 작업에 대한 메시지를 받으면 작업이 검색되고 결과가 출력됩니다.
이 예제는 GitHub에서 가장 잘 볼 수 있습니다. 전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/rekognition)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
+ Amazon SNS
+ Amazon SQS
------
# Amazon SES SMTP 엔드포인트에 연결하는 자격 증명 생성
다음 코드 예제에서는 Amazon SES SMTP 엔드포인트에 연결하는 자격 증명을 생성하는 방법을 보여줍니다.
------
#### [ Python ]
**SDK for Python (Boto3)**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/ses#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
#!/usr/bin/env python3
import hmac
import hashlib
import base64
import argparse
SMTP_REGIONS = [
"us-east-2", # US East (Ohio)
"us-east-1", # US East (N. Virginia)
"us-west-2", # US West (Oregon)
"ap-south-1", # Asia Pacific (Mumbai)
"ap-northeast-2", # Asia Pacific (Seoul)
"ap-southeast-1", # Asia Pacific (Singapore)
"ap-southeast-2", # Asia Pacific (Sydney)
"ap-northeast-1", # Asia Pacific (Tokyo)
"ca-central-1", # Canada (Central)
"eu-central-1", # Europe (Frankfurt)
"eu-west-1", # Europe (Ireland)
"eu-west-2", # Europe (London)
"eu-south-1", # Europe (Milan)
"eu-north-1", # Europe (Stockholm)
"sa-east-1", # South America (Sao Paulo)
"us-gov-west-1", # AWS GovCloud (US)
"us-gov-east-1", # AWS GovCloud (US)
]
# These values are required to calculate the signature. Do not change them.
DATE = "11111111"
SERVICE = "ses"
MESSAGE = "SendRawEmail"
TERMINAL = "aws4_request"
VERSION = 0x04
def sign(key, msg):
return hmac.new(key, msg.encode("utf-8"), hashlib.sha256).digest()
def calculate_key(secret_access_key, region):
if region not in SMTP_REGIONS:
raise ValueError(f"The {region} Region doesn't have an SMTP endpoint.")
signature = sign(("AWS4" + secret_access_key).encode("utf-8"), DATE)
signature = sign(signature, region)
signature = sign(signature, SERVICE)
signature = sign(signature, TERMINAL)
signature = sign(signature, MESSAGE)
signature_and_version = bytes([VERSION]) + signature
smtp_password = base64.b64encode(signature_and_version)
return smtp_password.decode("utf-8")
def main():
parser = argparse.ArgumentParser(
description="Convert a Secret Access Key to an SMTP password."
)
parser.add_argument("secret", help="The Secret Access Key to convert.")
parser.add_argument(
"region",
help="The AWS Region where the SMTP password will be used.",
choices=SMTP_REGIONS,
)
args = parser.parse_args()
print(calculate_key(args.secret, args.region))
if __name__ == "__main__":
main()
```
------
# Step Functions를 사용하여 Lambda 함수 간접 호출
다음 코드 예제에서는 AWS Lambda 함수를 순차적으로 호출하는 AWS Step Functions 상태 시스템을 생성하는 방법을 보여줍니다.
------
#### [ Java ]
**SDK for Java 2.x**
AWS Step Functions 및를 사용하여 AWS 서버리스 워크플로를 생성하는 방법을 보여줍니다 AWS SDK for Java 2.x. 각 워크플로 단계는 AWS Lambda 함수를 사용하여 구현됩니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/creating_workflows_stepfunctions)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ DynamoDB
+ Lambda
+ Amazon SES
+ 단계 함수
------
# AWS SDK를 사용하여 Amazon SES로 이메일 자격 증명 확인 및 메시지 전송
다음 코드 예제에서는 다음과 같은 작업을 수행하는 방법을 보여줍니다.
+ Amazon SES로 이메일 주소를 추가하고 확인합니다.
+ 표준 이메일 메시지를 보냅니다.
+ 템플릿을 만들고 템플릿 이메일 메시지를 보냅니다.
+ Amazon SES SMTP 서버를 사용하여 메시지를 보냅니다.
------
#### [ Python ]
**SDK for Python (Boto3)**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/ses#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
Amazon SES로 이메일 주소를 확인하고 메시지를 보냅니다.
```
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)
```
Amazon SES ID 작업을 래핑하는 함수를 만듭니다.
```
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
```
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
```
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
```
+ API 세부 정보는 *AWS SDK for Python (Boto3) API 참조*의 다음 주제를 참조하세요.
+ [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)
------