Introducere
AWS SES (Serviciul simplu de e-mail) este un serviciu de trimitere și primire a e-mailurilor ușor de configurat. De obicei, este dificil, captivant și plictisitor să gestionezi un sistem de e-mail local, așa că externalizarea procesului este o alegere populară.
Putem folosi Amazon SES pentru a trimite e-mailuri tranzacționale, e-mailuri de marketing sau orice alt tip de e-mailuri de notificare clienților noștri. Este o soluție accesibilă pentru companiile de toate dimensiunile care folosesc e-mailurile pentru a se conecta cu clienții lor, deoarece este construită pe infrastructura de încredere și scalabilă a Amazon Web Services (AWS).
Pentru trimiterea de e-mailuri în bloc, orice aplicație poate interacționa cu Amazon SES. Plătim doar pentru e-mailurile pe care le trimitem efectiv, fie că sunt e-mailuri tranzacționale sau e-mailuri de marketing. În plus, o serie de configurații, inclusiv adrese IP dedicate, partajate sau deținute, sunt acceptate de Amazon SES. Companiile pot face ca fiecare e-mail să conteze prin utilizarea tablourilor de bord și a rapoartelor privind livrarea informațiilor despre expeditor.
În acest ghid vom configura o instanță AWS SES într-o regiune și apoi vom integra cu Spring Cloud pentru AWS care este un subproiect al Norul de primăvară. Vom încerca diferite scenarii pentru a trimite e-mailuri din aplicația noastră.
Notă: Puteți găsi tot codul sursă folosit în ghidul de pe Github.
Ciclul de viață al trimiterii unui e-mail folosind AWS SES
Să ne uităm la modul în care ciclul de viață al unui e-mail trimis de o aplicație ajunge la cutia poștală de destinație:
-
O aplicație, în cazul nostru, codul Spring Cloud solicită AWS SES să trimită un e-mail către unul sau mai mulți destinatari.
-
SES verifică inițial cererea și, dacă este aprobată, produce un mesaj de e-mail cu specificațiile cererii. Acest mesaj de e-mail are un antet, un corp și un plic și este conform RFC 5322definiția formatului de mesaje de internet a lui.
-
SES transmite apoi mesajul către receptorul destinatarului prin Internet. De îndată ce mesajul este transmis către SES, acesta este adesea transmis imediat, încercarea inițială de livrare având loc de obicei în câteva milisecunde.
-
Există mai multe rezultate în acest moment. De exemplu:
- Livrare reușită: Furnizorul de servicii Internet (ISP) acceptă e-mailul și îl trimite destinatarului vizat.
- Salt greu: Deoarece adresa destinatarului este nevalidă, ISP-ul respinge e-mailul. ISP-ul trimite înapoi notificarea de respingere greu către Amazon SES, care notifică expeditorul prin e-mail sau publicând-o la un subiect Amazon Simple Notification Service (Amazon SNS) configurat pentru a primi această notificare.
- Bounce moale: Din cauza unor condiții precum căsuța de e-mail a destinatarului este plină, domeniul nu există sau orice circumstanță trecătoare, cum ar fi ISP-ul prea ocupat pentru a procesa cererea, ISP-ul ar putea să nu poată livra e-mailul destinatarului. Apoi ISP-ul reîncearcă e-mailul de până la un anumit număr de ori și trimite SES un mesaj de respingere soft. Dacă SES nu poate livra e-mailul în intervalul de timp specificat, fie publică evenimentul la un subiect SNS, fie trimite un mesaj de respingere greu prin e-mail.
- plângere: E-mailul este clasificat ca spam de către destinatar în programul său de e-mail. O notificare de reclamație este transmisă către Amazon SES, care apoi o transmite expeditorului dacă Amazon SES și ISP-ul au stabilit o buclă de feedback.
- Răspuns automat: ISP-ul destinatar notifică Amazon SES cu privire la un răspuns automat din partea destinatarului, cum ar fi o notificare de absență a biroului, iar Amazon SES transmite notificarea expeditorului.
Când livrarea nu reușește, Amazon SES returnează o eroare expeditorului și șterge e-mailul.
Configurarea Amazon SES
Spre deosebire de orice alte servicii AWS, practic nu este nevoie să creați o instanță SES, deoarece toate conturile AWS noi sunt plasate implicit în sandbox-ul AWS SES. Fiecare cont AWS are în mod implicit acces sandbox pentru AWS SES în regiunile disponibile.
Când folosim modul sandbox, putem trimite e-mailuri numai către identitățile verificate. Un domeniu sau o adresă de e-mail pe care o folosim pentru a trimite un e-mail este o identitate verificată. Trebuie să construim și să validăm fiecare identitate pe care intenționăm să o folosim ca a From, To, Source, Sender, Sau Return-Path adresa înainte de a putea trimite un e-mail utilizând SES în modul sandbox. Utilizând Amazon SES pentru a verifica identitatea, ne putem dovedi proprietatea și putem opri utilizarea ilegală.
Pentru a evita frauda și pentru a păstra reputația unei adrese IP, AWS SES include limite de trimitere de e-mail. Aceste limitări specifică numărul maxim de e-mailuri pe secundă și limita zilnică de e-mail pentru fiecare utilizator. Luând legătura cu Centrul de asistență AWS, este posibil să stabilim astfel de cote în funcție de regiune.
Să verificăm identitățile. Conectați-vă la Consola AWS și căutați „Serviciul de e-mail simplu Amazon"
Apoi faceți clic pe „Creați identitate” pentru a adăuga un e-mail sau un domeniu pentru verificare. În cazul nostru, vom adăuga un e-mail pentru verificare.
Odată ce identitatea este creată, putem verifica detaliile.
Identitatea pe care am creat-o merge în „Verificare în așteptare” etapa. În această etapă, utilizatorul trebuie să verifice e-mailul de verificare de la AWS și să urmeze instrucțiunile pentru a obține verificarea e-mailului.
Apoi, trebuie să luăm „cheie de acces"Și"cheie secreta” pentru autentificarea și autorizarea aplicației noastre cu SES. Pentru a genera asta, trebuie să creăm un grup de utilizatori și să adăugăm un utilizator la acel grup. Când creăm acel utilizator, AWS generează o cheie de acces și o cheie secretă. Deci, să redirecționăm către „IAM” în Consola AWS și creați un grup de utilizatori.
Apoi trebuie să adăugăm „AdministratorAcces” permisiunea respectivului grup pentru SES.
În cele din urmă, vom adăuga un utilizator la grupul de mai sus.
Apoi, trebuie să selectăm grupul pentru permisiuni.
În cele din urmă, copiați cheia de acces și cheia secretă afișate pe ecran pentru utilizare ulterioară.
Trimiterea de e-mailuri folosind Spring Cloud Project
Configurare proiect
Să dezvoltăm un proiect Spring Cloud și să parcurgem cazurile de utilizare pentru a ne integra cu SES. Cel mai simplu mod de a începe cu un proiect schelet este via Spring Initializr:
Am adăugat Spring Web pentru REST MVC, Apache Freemarker pentru a genera șabloane de e-mail bazate pe HTML, Java Mail Sender pentru a trimite un e-mail și Lombok (bibliotecă opțională de reducere a standardelor) dependențe. În plus, trebuie să adăugăm dependențe relevante pentru Spring Cloud AWS și SES. Pentru Spring Cloud AWS, vom adăuga un Spring Cloud AWS BOM separat în documentul nostru pom.xml fișier folosind acesta bloc:
<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>
În cele din urmă, pentru a adăuga suport pentru SES, trebuie să includem dependența de modul care este disponibilă ca modul de pornire spring-cloud-starter-aws-ses:
<dependency>
<groupId>io.awspring.cloud</groupId>
<artifactId>spring-cloud-starter-aws-ses</artifactId>
</dependency>
spring-cloud-starter-aws-ses include dependenţele tranzitive pt spring-cloud-starter-aws, și spring-cloud-aws-ses. spring-cloud-aws-ses modulul pentru SES conține două clase: SimpleEmailServiceMailSender și SimpleEmailServiceJavaMailSender.
-
SimpleEmailServiceMailSenderclasa utilizează Amazon Simple Email Service pentru a trimite e-mailuri. API-ul Java Mail nu este o cerință pentru această implementare. Poate fi folosit pentru a trimite mesaje e-mail simple, lipsite de atașamente. -
SimpleEmailServiceJavaMailSenderclasa permite trimiterea de e-mailuri care conțin atașamente și alte elemente mime.
Deci aceasta acoperă toate cerințele noastre de bază!
Configurarea Beans
După cum am discutat mai sus, trebuie să definim două tipuri de fasole: SimpleEmailServiceMailSender și SimpleEmailServiceJavaMailSender. Putem pur și simplu să transmitem cheia de acces și cheia secretă ca acreditări și să configuram a MailSender bean pe care îl vom folosi pentru a trimite e-mailuri:
@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);
}
}
Pentru a trimite e-mailuri cu atașamente trebuie să configuram SimpleEmailServiceJavaMailSender care este o implementare a JavaMailSender interfață din abstracția e-mailului Spring.
Consultați ghidul nostru practic și practic pentru a învăța Git, cu cele mai bune practici, standarde acceptate de industrie și fisa de cheat incluse. Opriți căutarea pe Google a comenzilor Git și de fapt învăţa aceasta!
Vom defini, de asemenea, proprietățile din care să recuperăm informațiile application.yml:
cloud:
aws:
region:
static: eu-central-1
auto: false
stack:
auto: false
credentials:
access-key: ********
secret-key: **************************
Trimiterea unui e-mail simplu
Putem trimite e-mailuri simple folosind SimpleEmailServiceMailSender bean pe care l-am configurat mai sus. Să definim un nivel de serviciu pentru a utiliza acest bean:
@Service
public class EmailService {
@Autowired
private MailSender mailSender;
public void sendMessage(SimpleMailMessage simpleMailMessage) {
this.mailSender.send(simpleMailMessage);
}
}
Noi sunăm la send() metoda din MailSender bean pentru a ne trimite e-mailul. De asemenea, trebuie să trecem SimpleMailMessage care ar conține atribute precum from, to, textul și subiectul e-mailului nostru. Deci, să definim a Controller clasă pentru a apela serviciul de mai sus folosind un 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";
}
}
Acum, dacă rulăm aplicația și executăm următorul curl, acesta va trimite un e-mail la adresa de e-mail verificată:
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'
Apoi, ne putem autentifica la adresa de e-mail a destinatarului și putem verifica dacă destinatarul a primit e-mailul.
Trimiterea unui e-mail simplu cu atașament
Vom defini un nivel de serviciu pentru a trece atașamentul ca mime și vom seta celelalte atribute de e-mail ca from, to, text și subiect:
@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());
}
}
}
Aici folosim MimeMessageHelper pentru a crea un e-mail cu un atașament. În final, vom defini Controller strat pentru a trece SimpleMailMessage atribute:
@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";
}
}
Acum, dacă rulăm aplicația și executăm următorul curl, acesta va trimite un e-mail la adresa de e-mail verificată:
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'
Apoi, ne putem autentifica la adresa de e-mail a destinatarului și putem verifica dacă destinatarul a primit e-mailul.
Trimiterea unui e-mail șablon cu atașament
Cazurile de utilizare anterioare pe care le-am văzut sunt bune pentru scenarii de dezvoltare sau de testare, dar în producție, în general, folosim un șablon de e-mail cu variabile care ar fi înlocuite folosind răspunsurile unui API. Am adăugat mai devreme dependența pentru Apache Freemarker. Îl vom folosi pentru a defini un șablon și îl vom încărca pentru procesare!
Pentru aceasta, să definim mai întâi un șablon simplu, să-l denumim ca email-template.ftl si pune-l in templates dosarul de sub 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>
Apoi, trebuie să definim o clasă de configurare pentru a încărca șablonul din cale și a adăuga ca bean. Pentru aceasta, vom defini FreeMarkerConfigurationFactoryBean:
@Configuration
public class FreemarkerConfig {
@Primary
@Bean
public FreeMarkerConfigurationFactoryBean factoryBean() {
FreeMarkerConfigurationFactoryBean bean = new FreeMarkerConfigurationFactoryBean();
bean.setTemplateLoaderPath("classpath:/templates");
return bean;
}
}
În continuare, vom defini nivelul nostru de servicii pentru a încărca acest șablon și a crea un mesaj final pentru a-l trimite către 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());
}
}
În final, vom defini a Controller strat pentru a transmite atributele dinamice de 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";
}
}
Acum, dacă rulăm aplicația și executăm următorul curl, acesta va trimite un e-mail la adresa de e-mail verificată:
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'
Apoi, ne putem autentifica la adresa de e-mail a destinatarului și putem verifica dacă destinatarul a primit e-mailul:
Trimiterea de e-mailuri personalizate folosind șabloane în AWS SES
În cazul de utilizare anterior, am folosit un șablon static pentru a trimite e-mailuri. Cum putem permite ca șabloanele să fie proiectate dinamic pentru diferite scopuri și diferite tipuri de destinatari? AWS SES ne permite să creăm șabloane de e-mail pentru a trimite e-mailuri personalizate către una sau mai multe destinații într-o singură operațiune.
Putem crea până la 10,000 de șabloane de e-mail pentru fiecare cont Amazon SES. Fiecare șablon poate avea o dimensiune de până la 500 KB, incluzând atât părțile text, cât și HTML. Putem trimite până la 50 de destinații în fiecare apel.
Deci, să creăm rapid un șablon de e-mail. În primul rând, putem defini un fișier JSON folosind următorul șablon:
{
"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."
}
}
Acest șablon conține următoarele atribute:
- Nume șablon: Acesta conține numele șablonului.
- SubiectPartea: Acesta deține subiectul e-mailului. Etichetele de înlocuire pot fi prezente pe acest material. Aceste etichete sunt formatate după cum urmează:
{{tagname}}. Puteți introduce o valoare pentru{{tagname}}pentru fiecare destinație la trimiterea e-mailului. - HtmlPart: Acesta conține corpul HTML al e-mailului și poate conține și etichete de înlocuire.
- TextPart: Acesta reprezintă corpul textului e-mailului. Această versiune a e-mailului este trimisă destinatarilor ai căror clienți de e-mail nu vizualizează e-mailurile HTML. Etichetele de înlocuire pot fi prezente pe acest material.
Putem salva acest fișier ca mytemplate.json. În cele din urmă, putem folosi o comandă AWS CLI pentru a crea șablonul după cum urmează:
$ aws ses create-template --cli-input-json file://mytemplate.json
În continuare, să definim un nivel de serviciu pentru a defini atributele și a trimite e-mailuri cu șablon:
@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);
}
}
Putem adăuga mai multe Destination adrese pentru a trimite e-mailuri în bloc către mai mulți destinatari. Noi folosim sendTemplatedEmail() metoda din AmazonSimpleEmailService interfață pentru a trimite acest e-mail șablon. De asemenea, trebuie să trecem etichetele de înlocuire pentru a fi înlocuite în textul HTML al șablonului nostru pe care l-am creat mai devreme.
În final, vom defini a Controller strat pentru a defini API-ul REST pentru a transmite atributele:
@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";
}
}
Apoi, când rulăm aplicația, putem executa următoarele curl pentru a trimite e-mailuri șablon:
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'
Acum, destinatarul poate vedea în sfârșit un e-mail tip șablon:
Solicitați acces la producție
În cele din urmă, pentru a trimite e-mail-uri oricărui destinatar, indiferent dacă adresa sau domeniul destinatarului este validată, în cele din urmă trebuie să ne scoatem contul din sandbox. Toate identitățile noastre, inclusiv From, Source, Sender, și Return-Path adrese, trebuie încă verificate. Putem trimite o cerere de acces la producție din „Tabloul de bord al contului” pagina după cum urmează:
Putem trimite cererea completând toate detaliile de mai sus din Consola AWS. Același lucru poate fi trimis și folosind AWS CLI. Acest lucru ar fi util atunci când trebuie să solicităm acces pentru un număr mare de identități și dorim să automatizăm procesul.
Concluzie
Ideile cheie ale Amazon Simple Email Service (SES) și bibliotecile oferite de Spring Cloud AWS pentru a interfața cu acesta au fost tratate în acest articol. În plus, am creat o aplicație Spring Boot cu un API REST care poate trimite e-mailuri prin modulul Spring Cloud AWS SES.
Acum ar trebui să înțelegeți bine ce este Amazon Simple Email Service (SES) și cum să îl utilizați pentru a trimite e-mailuri.
