Wprowadzenie
AWS SES (prosta usługa e-mail) to prosta w konfiguracji usługa wysyłania i odbierania wiadomości e-mail. Zarządzanie lokalnym systemem poczty e-mail jest zwykle trudne, skomplikowane i żmudne, dlatego outsourcing tego procesu jest popularnym wyborem.
Możemy używać Amazon SES do wysyłania e-maili transakcyjnych, e-maili marketingowych lub innego rodzaju e-maili z powiadomieniami do naszych klientów. Jest to niedrogie rozwiązanie dla firm każdej wielkości, które używają poczty e-mail do łączenia się z klientami, ponieważ jest zbudowane na niezawodnej i skalowalnej infrastrukturze Amazon Web Services (AWS).
Do masowego wysyłania wiadomości e-mail dowolna aplikacja może wchodzić w interakcję z Amazon SES. Płacimy tylko za e-maile, które faktycznie wysyłamy, niezależnie od tego, czy są to e-maile transakcyjne, czy e-maile marketingowe. Ponadto Amazon SES obsługuje szereg konfiguracji, w tym dedykowane, współdzielone lub własne adresy IP. Firmy mogą liczyć każdy e-mail za pomocą pulpitów nawigacyjnych dostarczalności i raportów dotyczących informacji o nadawcy.
W tym przewodniku skonfigurujemy instancję AWS SES w regionie, a następnie zintegrujemy ją Wiosenna chmura dla AWS który jest podprojektem Wiosenna chmura. Wypróbujemy różne scenariusze wysyłania e-maili z naszej aplikacji.
Uwaga: Możesz znaleźć cały kod źródłowy użyty w przewodniku na Github.
Cykl życia wysyłania wiadomości e-mail z wykorzystaniem AWS SES
Przyjrzyjmy się, jak cykl życia wiadomości e-mail wysłanej przez aplikację dociera do docelowej skrzynki pocztowej:
-
Aplikacja, w naszym przypadku kod Spring Cloud, żąda od AWS SES wysłania wiadomości e-mail do jednego lub większej liczby odbiorców.
-
SES wstępnie weryfikuje żądanie, a jeśli zostanie zatwierdzone, wysyła wiadomość e-mail ze specyfikacją żądania. Ta wiadomość e-mail ma nagłówek, treść i kopertę i jest zgodna RFC 5322Definicja formatu wiadomości internetowych firmy.
-
SES przesyła następnie wiadomość do odbiorcy przez Internet. Gdy tylko wiadomość zostanie przekazana do SES, jest często przesyłana od razu, przy czym pierwsza próba dostarczenia zwykle trwa kilka milisekund.
-
W tej chwili jest kilka wyników. Na przykład:
- Pomyślna dostawa: Dostawca usług internetowych (ISP) akceptuje wiadomość e-mail i wysyła ją do zamierzonego odbiorcy.
- Twarde odbicie: ponieważ adres odbiorcy jest nieprawidłowy, dostawca usług internetowych odrzuca wiadomość e-mail. Dostawca usług internetowych odsyła twarde powiadomienie zwrotne do Amazon SES, który powiadamia nadawcę pocztą elektroniczną lub publikując je w temacie usługi Amazon Simple Notification Service (Amazon SNS) skonfigurowanym do otrzymywania tego powiadomienia.
- Miękkie odbicie: ze względu na warunki, takie jak zapełniona skrzynka odbiorcza odbiorcy, nieistniejąca domena lub inne przejściowe okoliczności, takie jak zbyt duży zajęty dostawca usług internetowych, aby przetworzyć żądanie, dostawca usług internetowych może nie być w stanie dostarczyć wiadomości e-mail do odbiorcy. Następnie dostawca usług internetowych ponawia próbę wysłania wiadomości e-mail do określonej liczby razy i wysyła SES komunikat o miękkim odrzuceniu. Jeśli SES nie może dostarczyć wiadomości e-mail w określonym czasie, albo publikuje wydarzenie w temacie SNS, albo wysyła wiadomość e-mail z twardym odbiciem.
- Skarga: wiadomość e-mail jest klasyfikowana jako spam przez odbiorcę w jego programie pocztowym. Powiadomienie o reklamacji jest przesyłane do Amazon SES, który następnie przekazuje je nadawcy, jeśli Amazon SES i dostawca usług internetowych mają ustanowioną pętlę informacji zwrotnych.
- Odpowiedź automatyczna: dostawca usług internetowych odbiorcy powiadamia Amazon SES o automatycznej odpowiedzi od odbiorcy, takiej jak powiadomienie o nieobecności w biurze, a Amazon SES przekazuje powiadomienie nadawcy.
Gdy dostawa się nie powiedzie, Amazon SES zwraca błąd do nadawcy i usuwa wiadomość e-mail.
Konfigurowanie Amazon SES
W przeciwieństwie do innych usług AWS praktycznie nie ma potrzeby tworzenia instancji SES, ponieważ wszystkie nowe konta AWS są domyślnie umieszczane w piaskownicy AWS SES. Każde konto AWS ma domyślnie dostęp do piaskownicy dla AWS SES w dostępnych regionach.
W trybie piaskownicy możemy wysyłać e-maile tylko do zweryfikowanych tożsamości. Domena lub adres e-mail, którego używamy do wysyłania wiadomości e-mail, to zweryfikowana tożsamość. Musimy skonstruować i zweryfikować każdą tożsamość, której zamierzamy użyć jako From, To, Source, Senderlub Return-Path adres, zanim będziemy mogli wysłać wiadomość e-mail za pomocą SES w trybie piaskownicy. Używając Amazon SES do weryfikacji tożsamości, możemy udowodnić naszą własność i powstrzymać nielegalne użycie.
Aby uniknąć oszustw i zachować reputację adresu IP, AWS SES zawiera limity wysyłania wiadomości e-mail. Te ograniczenia określają maksymalną liczbę wiadomości e-mail na sekundę oraz dzienny limit wiadomości e-mail dla każdego użytkownika. Kontaktując się z Centrum wsparcia AWS, możemy ustalić takie limity według regionu.
Zweryfikujmy tożsamości. Zaloguj się do konsoli AWS i wyszukaj „Prosta usługa e-mail Amazon"
Następnie kliknij „Stwórz tożsamość”, aby dodać adres e-mail lub domenę do weryfikacji. W naszym przypadku dodamy adres e-mail do weryfikacji.
Po utworzeniu tożsamości możemy zweryfikować szczegóły.
Tożsamość, którą stworzyliśmy, przechodzi do „Oczekuje na weryfikację" etap. Na tym etapie użytkownik musi sprawdzić pocztę weryfikacyjną z AWS i postępować zgodnie z instrukcjami, aby zweryfikować wiadomość e-mail.
Następnie musimy pobrać „klucz dostępu"I"sekretny klucz” w celu uwierzytelnienia i autoryzacji naszej aplikacji z SES. Aby to wygenerować, musimy utworzyć grupę użytkowników i dodać użytkownika do tej grupy. Kiedy tworzymy tego użytkownika, AWS generuje klucz dostępu i tajny klucz. Przekierujmy więc do „IAM” w konsoli AWS i utwórz grupę użytkowników.
Następnie musimy dodać „Dostęp administratora” uprawnienia do tej grupy dla SES.
Na koniec dodamy Użytkownika do powyższej grupy.
Następnie musimy wybrać grupę uprawnień.
Na koniec skopiuj klucz dostępu i tajny klucz wyświetlone na ekranie do dalszego wykorzystania.
Wysyłanie wiadomości e-mail za pomocą Spring Cloud Project
Konfiguracja projektu
Uruchommy projekt Spring Cloud i przejrzyjmy przypadki użycia w celu integracji z SES. Najprostszym sposobem na rozpoczęcie projektu szkieletowego jest przejście przez Wiosna Initializr:
Dodaliśmy Wiosenna sieć dla REST MVC, Apache Freemarkera do generowania szablonów wiadomości e-mail w formacie HTML, Nadawca poczty Java wysłać e-mail i Lombok (opcjonalna biblioteka redukująca szablony) zależności. Dodatkowo musimy dodać odpowiednie zależności dla Spring Cloud AWS i SES. W przypadku Spring Cloud AWS dodamy osobny BOM Spring Cloud AWS w naszym pom.xml plik za pomocą tego blok:
<dependencyManagement>
<dependencies>
<dependency>
<groupId>io.awspring.cloud</groupId>
<artifactId>spring-cloud-aws-dependencies</artifactId>
<version>2.3.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
Wreszcie, aby dodać obsługę SES, musimy uwzględnić zależność modułu, która jest dostępna jako moduł startowy spring-cloud-starter-aws-ses:
<dependency>
<groupId>io.awspring.cloud</groupId>
<artifactId>spring-cloud-starter-aws-ses</artifactId>
</dependency>
spring-cloud-starter-aws-ses zawiera zależności przechodnie dla spring-cloud-starter-aws, spring-cloud-aws-ses, spring-cloud-aws-ses moduł dla SES zawiera dwie klasy: SimpleEmailServiceMailSender i SimpleEmailServiceJavaMailSender.
- Połączenia
SimpleEmailServiceMailSenderclass wykorzystuje usługę Amazon Simple Email Service do wysyłania wiadomości e-mail. Interfejs Java Mail API nie jest wymagany dla tej implementacji. Może być używany do wysyłania prostych wiadomości e-mail pozbawionych załączników. - Połączenia
SimpleEmailServiceJavaMailSenderklasa umożliwia wysyłanie wiadomości e-mail zawierających załączniki i inne elementy MIME.
To obejmuje wszystkie nasze podstawowe wymagania!
Konfigurowanie fasoli
Jak omówiono powyżej, musimy zdefiniować dwa rodzaje ziaren: SimpleEmailServiceMailSender i SimpleEmailServiceJavaMailSender. Możemy po prostu przekazać klucz dostępu i klucz tajny jako poświadczenia i skonfigurować plik MailSender bean, którego będziemy używać do wysyłania e-maili:
@Configuration
public class SesConfig {
@Value("${cloud.aws.credentials.access-key}")
private String accessKey;
@Value("${cloud.aws.credentials.secret-key}")
private String secretKey;
@Value("${cloud.aws.region.static}")
private String region;
@Bean
public AmazonSimpleEmailService amazonSimpleEmailService() {
BasicAWSCredentials credentials = new BasicAWSCredentials(accessKey, secretKey);
return AmazonSimpleEmailServiceClientBuilder.standard()
.withCredentials(new AWSStaticCredentialsProvider(credentials))
.withRegion(region)
.build();
}
@Bean
public MailSender mailSender(AmazonSimpleEmailService amazonSimpleEmailService) {
return new SimpleEmailServiceMailSender(amazonSimpleEmailService);
}
@Bean
public JavaMailSender javaMailSender(AmazonSimpleEmailService amazonSimpleEmailService) {
return new SimpleEmailServiceJavaMailSender(amazonSimpleEmailService);
}
}
Aby wysyłać e-maile z załącznikami musimy skonfigurować plik SimpleEmailServiceJavaMailSender która jest implementacją tzw JavaMailSender interfejs z abstrakcji poczty Springa.
Zapoznaj się z naszym praktycznym, praktycznym przewodnikiem dotyczącym nauki Git, zawierającym najlepsze praktyki, standardy przyjęte w branży i dołączoną ściągawkę. Zatrzymaj polecenia Google Git, a właściwie uczyć się to!
Zdefiniujemy również właściwości, z których mają być pobierane informacje application.yml:
cloud:
aws:
region:
static: eu-central-1
auto: false
stack:
auto: false
credentials:
access-key: ********
secret-key: **************************
Wysyłanie prostego e-maila
Możemy wysyłać proste e-maile za pomocą SimpleEmailServiceMailSender bean, który skonfigurowaliśmy powyżej. Zdefiniujmy warstwę usługi, aby użyć tego komponentu bean:
@Service
public class EmailService {
@Autowired
private MailSender mailSender;
public void sendMessage(SimpleMailMessage simpleMailMessage) {
this.mailSender.send(simpleMailMessage);
}
}
Dzwonimy do send() metoda w MailSender fasola, aby wysłać nasz e-mail. Musimy też przejść tzw SimpleMailMessage który zawierałby atrybuty takie jak from, to, tekst i temat naszego e-maila. Zdefiniujmy więc a Controller class, aby wywołać powyższą usługę za pomocą interfejsu API REST:
@RestController
public class EmailController {
@Autowired
private EmailService emailService;
@PostMapping("/sendEmail")
public String sendMessage(@RequestBody EmailDetails emailDetails) {
SimpleMailMessage simpleMailMessage = new SimpleMailMessage();
simpleMailMessage.setFrom(emailDetails.getFromEmail());
simpleMailMessage.setTo(emailDetails.getToEmail());
simpleMailMessage.setSubject(emailDetails.getSubject());
simpleMailMessage.setText(emailDetails.getBody());
emailService.sendMessage(simpleMailMessage);
return "Email sent successfully";
}
}
Teraz, jeśli uruchomimy aplikację i wykonamy następujące zwinięcie, wyśle wiadomość e-mail na zweryfikowany adres e-mail:
curl -i -X POST
-H "Content-Type:application/json"
-d
'{
"fromEmail": "[email protected]",
"toEmail": "[email protected]",
"subject": "test email",
"body": "Hi, This is a test email."
}'
'http://localhost:8080/sendEmail'
Następnie możemy zalogować się na adres pocztowy odbiorcy i zweryfikować, czy odbiorca otrzymał wiadomość e-mail.
Wysyłanie prostego e-maila z załącznikiem
Zdefiniujemy warstwę usługi, aby przekazać załącznik jako MIME i ustawić inne atrybuty wiadomości e-mail, takie jak from, to, tekst i temat:
@Service
public class EmailService {
@Autowired
private JavaMailSender javaMailSender;
public void sendMessageWithAttachment(SimpleMailMessage simpleMailMessage) {
try {
MimeMessage message = javaMailSender.createMimeMessage();
MimeMessageHelper helper = new MimeMessageHelper(
message,
MimeMessageHelper.MULTIPART_MODE_MIXED_RELATED,
StandardCharsets.UTF_8.name());
helper.addAttachment("logo.png", new ClassPathResource("logo.png"));
helper.setTo(Objects.requireNonNull(simpleMailMessage.getTo()));
helper.setText(Objects.requireNonNull(simpleMailMessage.getText()));
helper.setSubject(Objects.requireNonNull(simpleMailMessage.getSubject()));
helper.setFrom(Objects.requireNonNull(simpleMailMessage.getFrom()));
javaMailSender.send(message);
} catch (MessagingException e) {
System.err.println("Exception: " + e.getMessage());
}
}
}
Tutaj korzystamy MimeMessageHelper aby utworzyć wiadomość e-mail z załącznikiem. Na koniec zdefiniujemy Controller warstwa do przejścia SimpleMailMessage atrybuty:
@RestController
public class EmailController {
@Autowired
private EmailService emailService;
@PostMapping("/sendEmailWithAttachment")
public String sendMessageWithAttachment(@RequestBody EmailDetails emailDetails) {
SimpleMailMessage simpleMailMessage = new SimpleMailMessage();
simpleMailMessage.setFrom(emailDetails.getFromEmail());
simpleMailMessage.setTo(emailDetails.getToEmail());
simpleMailMessage.setSubject(emailDetails.getSubject());
simpleMailMessage.setText(emailDetails.getBody());
emailService.sendMessageWithAttachment(simpleMailMessage);
return "Email sent successfully";
}
}
Teraz, jeśli uruchomimy aplikację i wykonamy następujące zwinięcie, wyśle wiadomość e-mail na zweryfikowany adres e-mail:
curl -i -X POST
-H "Content-Type:application/json"
-d
'{
"fromEmail": "[email protected]",
"toEmail": "[email protected]",
"subject": "test email",
"body": "Hi, This is a test email with attachment."
}'
'http://localhost:8080/sendEmailWithAttachment'
Następnie możemy zalogować się na adres pocztowy odbiorcy i zweryfikować, czy odbiorca otrzymał wiadomość e-mail.
Wysyłanie szablonu wiadomości e-mail z załącznikiem
Poprzednie przypadki użycia, które widzieliśmy, są dobre dla scenariuszy programistycznych lub testowych, ale w produkcji zazwyczaj używamy szablonu wiadomości e-mail ze zmiennymi, które zostałyby zastąpione przy użyciu odpowiedzi interfejsu API. Wcześniej dodaliśmy zależność dla Apache Freemarkera. Wykorzystamy go do zdefiniowania szablonu i załadowania go do procesu!
W tym celu najpierw zdefiniujmy prosty szablon, nazwijmy go jako email-template.ftl i umieść go w templates folder pod resources:
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>StackAbuse Email</title>
</head>
<body>
<table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td align="center" valign="top" bgcolor="#838383"
style="background-color: #838383;"><br> <br>
<table width="600" border="0" cellspacing="0" cellpadding="0">
<tr>
<td align="center" valign="top" bgcolor="#d3be6c"
style="background-color: #d3be6c; font-family: Arial,
Helvetica, sans-serif; font-size: 13px; color: #000000;
padding: 0px 15px 10px 15px;">
<div style="font-size: 48px; color:blue;">
<b>StackAbuse</b>
</div>
<div style="font-size: 24px; color: #555100;">
<br> Sending Email using Spring Cloud with <b>FreeMarker</b> template !!! <br>
</div>
<div>
<br> Want to learn a new technology or become an in-demand full-stack developer?<br>
<br> We teach the skills you need to level up in your career.<br>
<br>"Sharing knowledge is the biggest learning" <br> <br>
<br> <br> <b>${Name}</b><br>${location}<br>
<br>
</div>
</td>
</tr>
</table> <br> <br></td>
</tr>
</table>
</body>
</html>
Następnie musimy zdefiniować klasę konfiguracji, aby załadować szablon ze ścieżki i dodać jako komponent bean. W tym celu zdefiniujemy FreeMarkerConfigurationFactoryBean:
@Configuration
public class FreemarkerConfig {
@Primary
@Bean
public FreeMarkerConfigurationFactoryBean factoryBean() {
FreeMarkerConfigurationFactoryBean bean = new FreeMarkerConfigurationFactoryBean();
bean.setTemplateLoaderPath("classpath:/templates");
return bean;
}
}
Następnie zdefiniujemy naszą warstwę usług, aby załadować ten szablon i utworzyć ostateczną wiadomość do wysłania do SES:
@Service
public class EmailService {
@Autowired
private JavaMailSender javaMailSender;
@Autowired
private Configuration config;
public void sendTemplateMessageWithAttachment(SimpleMailMessage simpleMailMessage) {
try {
MimeMessage message = javaMailSender.createMimeMessage();
MimeMessageHelper helper = new MimeMessageHelper(
message,
MimeMessageHelper.MULTIPART_MODE_MIXED_RELATED,
StandardCharsets.UTF_8.name());
Template t = config.getTemplate("email-template.ftl");
Map model = new HashMap();
model.put("Name", "StackAbuse Admin");
model.put("location", "Bangalore, India");
String html = FreeMarkerTemplateUtils.processTemplateIntoString(t, model);
helper.addAttachment("logo.png", new ClassPathResource("logo.png"));
helper.setTo(Objects.requireNonNull(simpleMailMessage.getTo()));
helper.setText(html, true);
helper.setSubject(Objects.requireNonNull(simpleMailMessage.getSubject()));
helper.setFrom(Objects.requireNonNull(simpleMailMessage.getFrom()));
javaMailSender.send(message);
} catch (MessagingException | IOException | TemplateException e) {
System.err.println("Exception: " + e.getMessage());
}
}
Na koniec zdefiniujemy a Controller warstwa, aby przekazać dynamiczne atrybuty wiadomości e-mail:
@RestController
public class EmailController {
@Autowired
private EmailService emailService;
@PostMapping("/sendTemplateEmailWithAttachment")
public String sendTemplateMessageWithAttachment(@RequestBody EmailDetails emailDetails) {
SimpleMailMessage simpleMailMessage = new SimpleMailMessage();
simpleMailMessage.setFrom(emailDetails.getFromEmail());
simpleMailMessage.setTo(emailDetails.getToEmail());
simpleMailMessage.setSubject(emailDetails.getSubject());
simpleMailMessage.setText(emailDetails.getBody());
emailService.sendTemplateMessageWithAttachment(simpleMailMessage);
return "Email sent successfully";
}
}
Teraz, jeśli uruchomimy aplikację i wykonamy następujące zwinięcie, wyśle wiadomość e-mail na zweryfikowany adres e-mail:
curl -i -X POST
-H "Content-Type:application/json"
-d
'{
"fromEmail": "[email protected]",
"toEmail": "[email protected]",
"subject": "test email",
"body": "Hi, This is a test template email with attachment."
}'
'http://localhost:8080/sendTemplateEmailWithAttachment'
Następnie możemy zalogować się na adres pocztowy odbiorcy i zweryfikować, czy odbiorca otrzymał wiadomość e-mail:
Wysyłanie spersonalizowanych wiadomości e-mail za pomocą szablonów w AWS SES
W poprzednim przypadku użycia używaliśmy statycznego szablonu do wysyłania e-maili. Jak możemy umożliwić dynamiczne projektowanie szablonów dla różnych celów i różnych typów odbiorców? AWS SES pozwala nam tworzyć szablony wiadomości e-mail w celu wysyłania spersonalizowanych wiadomości e-mail do jednego lub więcej miejsc docelowych w ramach jednej operacji.
Możemy utworzyć do 10,000 500 szablonów wiadomości e-mail na konto Amazon SES. Każdy szablon może mieć rozmiar do 50 KB, wliczając zarówno część tekstową, jak i HTML. W jednym połączeniu możemy wysłać do XNUMX miejsc docelowych.
Stwórzmy więc szybko szablon wiadomości e-mail. Najpierw możemy zdefiniować plik JSON za pomocą następującego szablonu:
{
"Template": {
"TemplateName": "MyTemplate",
"SubjectPart": "Greetings from {{name}}!",
"HtmlPart": "StackAbuse Email
StackAbuse
Sending Email using Spring Cloud with AWS SES Email template !!!
Want to learn a new technology or become an in-demand full-stack developer?
We teach the skills you need to level up in your career.
"Sharing knowledge is the biggest learning"
{{name}}
{{location}}
",
"TextPart": "Dear {{name}},rnHere is your StackAbuse Email."
}
}
Ten szablon zawiera następujące atrybuty:
- Nazwa Szablonu: Zawiera nazwę szablonu.
- TematCzęść: Zawiera wiersz tematu wiadomości e-mail. Na tym zasobie mogą znajdować się tagi zastępcze. Tagi te są sformatowane w następujący sposób:
{{tagname}}. Możesz wprowadzić wartość dla{{tagname}}dla każdego miejsca docelowego podczas wysyłania wiadomości e-mail. - Część HTML: zawiera treść HTML wiadomości e-mail i może również zawierać znaczniki zastępcze.
- Część tekstowa: reprezentuje treść wiadomości e-mail. Ta wersja wiadomości e-mail jest wysyłana do odbiorców, których klienty poczty e-mail nie wyświetlają wiadomości e-mail w formacie HTML. Na tym zasobie mogą znajdować się tagi zastępcze.
Możemy zapisać ten plik jako mytemplate.json. Na koniec możemy użyć polecenia AWS CLI, aby utworzyć szablon w następujący sposób:
$ aws ses create-template --cli-input-json file://mytemplate.json
Następnie zdefiniujmy warstwę usługi, aby zdefiniować atrybuty i wysyłać e-maile z szablonami:
@Service
public class EmailService {
@Autowired
private AmazonSimpleEmailService simpleEmailService;
public void sendTemplatedMessage(SimpleMailMessage simpleMailMessage) {
Destination destination = new Destination();
List toAddresses = new ArrayList();
String[] emails = simpleMailMessage.getTo();
Collections.addAll(toAddresses, Objects.requireNonNull(emails));
destination.setToAddresses(toAddresses);
SendTemplatedEmailRequest templatedEmailRequest = new SendTemplatedEmailRequest();
templatedEmailRequest.withDestination(destination);
templatedEmailRequest.withTemplate("MyTemplate");
templatedEmailRequest.withTemplateData("{ "name":"StackAbuse Admin", "location": "Bangalore, India"}");
templatedEmailRequest.withSource(simpleMailMessage.getFrom());
simpleEmailService.sendTemplatedEmail(templatedEmailRequest);
}
}
Możemy dodać wiele Destination adresy do masowego wysyłania wiadomości e-mail do wielu odbiorców. Używamy sendTemplatedEmail() metoda z AmazonSimpleEmailService interfejs do wysłania tego szablonu wiadomości e-mail. Musimy również przekazać znaczniki zastępcze, które mają zostać zastąpione w tekście HTML naszego szablonu, który stworzyliśmy wcześniej.
Na koniec zdefiniujemy a Controller warstwa do zdefiniowania interfejsu API REST w celu przekazania atrybutów:
@RestController
public class EmailController {
@Autowired
private EmailService emailService;
@PostMapping("/sendAWSTemplatedEmail")
public String sendTemplatedMessage(@RequestBody EmailDetails emailDetails) {
SimpleMailMessage simpleMailMessage = new SimpleMailMessage();
simpleMailMessage.setFrom(emailDetails.getFromEmail());
simpleMailMessage.setTo(emailDetails.getToEmail());
simpleMailMessage.setSubject(emailDetails.getSubject());
simpleMailMessage.setText(emailDetails.getBody());
emailService.sendTemplatedMessage(simpleMailMessage);
return "Email sent successfully";
}
}
Następnie, po uruchomieniu aplikacji, możemy wykonać następujące czynności curl aby wysłać e-maile z szablonami:
curl -i -X POST
-H "Content-Type:application/json"
-d
'{
"fromEmail": "[email protected]",
"toEmail": "[email protected]",
"subject": "Greetings from StackAbuse Admin",
"body": "Hi, This is a AWS templated email."
}'
'http://localhost:8080/sendAWSTemplatedEmail'
Teraz odbiorca wreszcie widzi e-mail z szablonem:
Poproś o dostęp do produkcji
Wreszcie, aby wysyłać e-maile do dowolnego odbiorcy, niezależnie od tego, czy adres odbiorcy lub domena są zweryfikowane, musimy ostatecznie wyjąć nasze konto z piaskownicy. Wszystkie nasze tożsamości, w tym From, Source, Sender, Return-Path adresy, muszą jeszcze zostać zweryfikowane. Możemy złożyć wniosek o dostęp do produkcji z poziomu „Panel konta” w następujący sposób:
Możemy przesłać żądanie, wypełniając wszystkie powyższe dane z konsoli AWS. To samo można również przesłać za pomocą AWS CLI. Byłoby to pomocne, gdy musimy poprosić o dostęp do dużej liczby tożsamości i chcielibyśmy zautomatyzować ten proces.
Wnioski
W tym artykule omówiono kluczowe idee usługi Amazon Simple Email Service (SES) i bibliotek oferowanych przez Spring Cloud AWS do łączenia się z nią. Dodatkowo stworzyliśmy aplikację Spring Boot z REST API, która może wysyłać e-maile przez moduł Spring Cloud AWS SES.
Powinieneś teraz dobrze zrozumieć, czym jest usługa Amazon Simple Email Service (SES) i jak jej używać do wysyłania wiadomości e-mail.
