Beskrivning
AWS SES (Simple Email Service) är en enkel att ställa in tjänst för att skicka och ta emot e-post. Det är vanligtvis svårt, petigt och tråkigt att hantera ett lokalt e-postsystem, så outsourcing av processen är ett populärt val.
Vi kan använda Amazon SES för att skicka transaktions-e-postmeddelanden, marknadsförings-e-postmeddelanden eller någon annan typ av meddelande-e-postmeddelanden till våra kunder. Det är en prisvärd lösning för företag av alla storlekar som använder e-post för att få kontakt med sina kunder eftersom den är byggd på den pålitliga och skalbara infrastrukturen av Amazon Web Services (AWS).
För att skicka massmeddelanden kan alla program interagera med Amazon SES. Vi betalar bara för de e-postmeddelanden vi faktiskt skickar, oavsett om det är transaktionsmeddelanden eller marknadsföringsmeddelanden. Dessutom stöds en rad konfigurationer, inklusive dedikerade, delade eller ägda IP-adresser, av Amazon SES. Företag kan få varje e-post att räknas med hjälp av instrumentpaneler för leverans och rapporter om avsändarinformation.
I den här guiden ska vi konfigurera en AWS SES-instans i en region och sedan integrera med Spring Cloud för AWS som är ett delprojekt av Vårmoln. Vi kommer att prova olika scenarier för att skicka e-post från vår applikation.
Notera: Du kan hitta all källkod som används i guiden på Github.
Livscykeln för att skicka ett e-postmeddelande med AWS SES
Låt oss titta på hur livscykeln för ett e-postmeddelande som skickas av ett program når destinationens brevlåda:
-
En applikation, i vårt fall, Spring Cloud-koden begär att AWS SES skickar ett e-postmeddelande till en eller flera mottagare.
-
SES verifierar inledningsvis begäran, och om den godkänns, producerar ett e-postmeddelande med begärans specifikationer. Detta e-postmeddelande har en rubrik, brödtext och kuvert och överensstämmer med RFC 5322s definition av Internetmeddelandeformat.
-
SES sänder sedan meddelandet till mottagarens mottagare över Internet. Så fort meddelandet överlämnas till SES sänds det ofta direkt, med det första leveransförsöket som vanligtvis sker inom några millisekunder.
-
Det finns flera resultat vid denna tidpunkt. Till exempel:
- Lyckad leverans: Internetleverantören (ISP) accepterar e-postmeddelandet och skickar det till den avsedda mottagaren.
- Hård Bounce: Eftersom mottagarens adress är ogiltig, avvisar ISP e-postmeddelandet. Internetleverantören skickar det hårda studsmeddelandet tillbaka till Amazon SES, som meddelar avsändaren via e-post eller genom att publicera det till en Amazon Simple Notification Service (Amazon SNS)-ämne som är inställd för att ta emot detta meddelande.
- Mjuk studs: På grund av tillstånd som att mottagarens inkorg är full, att domänen inte existerar eller någon övergående omständighet som att Internetleverantören är för upptagen för att behandla förfrågan, kan det hända att ISP inte kan leverera e-postmeddelandet till mottagaren. ISP:n försöker sedan om e-postmeddelandet upp till ett visst antal gånger och skickar ett mjukt studsmeddelande till SES. Om SES inte kan leverera e-postmeddelandet inom den angivna tidsramen, publicerar den antingen händelsen till ett SNS-ämne eller skickar ett hårt avvisningsmeddelande via e-post.
- Reklamation: E-postmeddelandet klassificeras som spam av mottagaren i deras e-postprogram. Ett klagomålsmeddelande sänds till Amazon SES, som sedan vidarebefordrar det till avsändaren om Amazon SES och ISP har upprättat en återkopplingsslinga.
- Autosvar: Mottagarens ISP meddelar Amazon SES om ett automatiskt svar från mottagaren, till exempel ett meddelande om frånvaro, och Amazon SES skickar meddelandet till avsändaren.
När leveransen misslyckas returnerar Amazon SES ett felmeddelande till avsändaren och raderar e-postmeddelandet.
Konfigurera Amazon SES
Till skillnad från alla andra AWS-tjänster finns det praktiskt taget inget behov av att skapa en SES-instans eftersom alla nya AWS-konton placeras i AWS SES-sandlådan som standard. Varje AWS-konto har sandlådeåtkomst för AWS SES i de tillgängliga regionerna som standard.
När vi använder sandlådeläge kan vi bara skicka e-postmeddelanden till verifierade identiteter. En domän eller e-postadress som vi använder för att skicka ett e-postmeddelande är en verifierad identitet. Vi måste konstruera och validera varje identitet vi tänker använda som en From, To, Source, Sender, eller Return-Path adress innan vi kan skicka ett e-postmeddelande med SES i sandlådeläge. Genom att använda Amazon SES för att verifiera identiteten kan vi bevisa vårt ägande och stoppa illegal användning.
För att undvika bedrägerier och bevara ryktet för en IP-adress inkluderar AWS SES gränser för sändning av e-post. Dessa begränsningar anger det maximala antalet e-postmeddelanden per sekund och den dagliga e-postgränsen för varje användare. Genom att kontakta AWS Support Center kan vi fastställa sådana kvoter per region.
Låt oss verifiera identiteter. Logga in på AWS-konsolen och sök efter "Amazons enkla e -posttjänst"
Klicka sedan på “Skapa identitet” för att lägga till ett e-postmeddelande eller en domän för verifiering. I vårt fall kommer vi att lägga till ett e-postmeddelande för verifiering.
När identiteten är skapad kan vi verifiera detaljerna.
Identiteten som vi skapade går in i "Verifiering väntar" skede. I det här skedet måste användaren kontrollera verifieringsmailet från AWS och följa instruktionerna för att få e-postmeddelandet verifierat.
Därefter måste vi hämta "åtkomstnyckel"Och"hemlig nyckel” för autentisering och auktorisering av vår applikation med SES. För att skapa det måste vi skapa en användargrupp och lägga till en användare i den gruppen. När vi skapar den användaren genererar AWS en åtkomstnyckel och en hemlig nyckel. Så låt oss omdirigera till "IAM” i AWS Console och skapa användargrupp.
Då måste vi lägga till "Administratörsåtkomst” tillstånd till den gruppen för SES.
Slutligen kommer vi att lägga till en användare till ovanstående grupp.
Därefter måste vi välja gruppen för behörigheter.
Slutligen, kopiera åtkomstnyckeln och den hemliga nyckeln som visas på skärmen för vidare användning.
Skicka e-post med Spring Cloud Project
Projektinställning
Låt oss skapa ett Spring Cloud-projekt och gå igenom användningsfallen för att integrera med SES. Det enklaste sättet att börja med ett skelettprojekt är via Spring Initializr:
Vi har lagt till Vårwebben för REST MVC, Apache Freemarker för att skapa HTML-baserade e-postmallar, Java Mail Avsändare att skicka ett mail och Lombok (valfritt boilerplate-reducing library) beroenden. Dessutom måste vi lägga till relevanta beroenden för Spring Cloud AWS och SES. För Spring Cloud AWS kommer vi att lägga till en separat Spring Cloud AWS BOM i vår pom.xml fil med denna blockera:
<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>
Slutligen, för att lägga till stöd för SES, måste vi inkludera modulberoendet som är tillgängligt som en startmodul spring-cloud-starter-aws-ses:
<dependency>
<groupId>io.awspring.cloud</groupId>
<artifactId>spring-cloud-starter-aws-ses</artifactId>
</dependency>
spring-cloud-starter-aws-ses inkluderar de transitiva beroenden för spring-cloud-starter-awsoch spring-cloud-aws-ses. De spring-cloud-aws-ses modul för SES innehåller två klasser: SimpleEmailServiceMailSender och SimpleEmailServiceJavaMailSender.
- Smakämnen
SimpleEmailServiceMailSenderklass använder Amazon Simple Email Service för att skicka e-post. Java Mail API är inte ett krav för denna implementering. Den kan användas för att skicka enkla e-postmeddelanden utan bilagor. - Smakämnen
SimpleEmailServiceJavaMailSenderclass möjliggör sändning av e-postmeddelanden som innehåller bilagor och andra mimeelement.
Så detta täcker alla våra grundläggande krav!
Konfigurera bönor
Som diskuterats ovan måste vi definiera två typer av bönor: SimpleEmailServiceMailSender och SimpleEmailServiceJavaMailSender. Vi kan helt enkelt skicka åtkomstnyckeln och den hemliga nyckeln som autentiseringsuppgifter och konfigurera en MailSender bean som vi kommer att använda för att skicka e-postmeddelanden:
@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);
}
}
För att skicka e-postmeddelanden med bilagor måste vi konfigurera SimpleEmailServiceJavaMailSender som är en implementering av JavaMailSender gränssnitt från Springs e-postabstraktion.
Kolla in vår praktiska, praktiska guide för att lära dig Git, med bästa praxis, branschaccepterade standarder och medföljande fuskblad. Sluta googla Git-kommandon och faktiskt lära Det!
Vi kommer också att definiera egenskaperna att hämta informationen från application.yml:
cloud:
aws:
region:
static: eu-central-1
auto: false
stack:
auto: false
credentials:
access-key: ********
secret-key: **************************
Skickar enkelt mejl
Vi kan skicka enkla e-postmeddelanden med hjälp av SimpleEmailServiceMailSender böna som vi konfigurerade ovan. Låt oss definiera ett servicelager för att använda denna böna:
@Service
public class EmailService {
@Autowired
private MailSender mailSender;
public void sendMessage(SimpleMailMessage simpleMailMessage) {
this.mailSender.send(simpleMailMessage);
}
}
Vi ringer till send() metod i MailSender bean att skicka vår e-post. Vi måste också klara SimpleMailMessage som skulle innehålla attribut som from, to, texten och ämnet för vår e-post. Så låt oss definiera en Controller klass för att anropa tjänsten ovan med ett REST API:
@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";
}
}
Nu, om vi kör applikationen och kör följande curl kommer det att skicka ett e-postmeddelande till den verifierade e-postadressen:
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'
Därefter kan vi logga in på mottagarens e-postadress och verifiera om mottagaren har fått mejlet.
Skickar enkelt e-postmeddelande med bilaga
Vi kommer att definiera ett servicelager för att skicka bilagan som mime och ställa in de andra e-postattributen som from, to, text och ämne:
@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());
}
}
}
Här använder vi MimeMessageHelper för att skapa ett e-postmeddelande med en bilaga. Slutligen kommer vi att definiera Controller lager för att passera SimpleMailMessage attribut:
@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";
}
}
Nu, om vi kör applikationen och kör följande curl kommer det att skicka ett e-postmeddelande till den verifierade e-postadressen:
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'
Därefter kan vi logga in på mottagarens e-postadress och verifiera om mottagaren har fått mejlet.
Skickar mallmail med bilaga
De tidigare användningsfallen som vi hade sett är bra för utvecklings- eller testscenarier, men i produktionen använder vi vanligtvis en e-postmall med variabler som skulle ersättas med ett API:s svar. Vi hade tidigare lagt till beroendet för Apache Freemarker. Vi kommer att använda den för att definiera en mall och ladda den för att bearbeta!
För detta, låt oss först definiera en enkel mall, namnge den som email-template.ftl och placera den i templates mapp under 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>
Därefter måste vi definiera en konfigurationsklass för att ladda mallen från sökvägen och lägga till som böna. För detta kommer vi att definiera FreeMarkerConfigurationFactoryBean:
@Configuration
public class FreemarkerConfig {
@Primary
@Bean
public FreeMarkerConfigurationFactoryBean factoryBean() {
FreeMarkerConfigurationFactoryBean bean = new FreeMarkerConfigurationFactoryBean();
bean.setTemplateLoaderPath("classpath:/templates");
return bean;
}
}
Därefter kommer vi att definiera vårt servicelager för att ladda denna mall och skapa ett sista meddelande att skicka till 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());
}
}
Slutligen kommer vi att definiera en Controller lager för att skicka de dynamiska e-postattributen:
@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";
}
}
Nu, om vi kör applikationen och kör följande curl kommer det att skicka ett e-postmeddelande till den verifierade e-postadressen:
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'
Därefter kan vi logga in på mottagarens e-postadress och verifiera om mottagaren har fått e-postmeddelandet:
Skicka personlig e-post med mallar i AWS SES
I det tidigare användningsfallet använde vi en statisk mall för att skicka e-post. Hur kan vi möjliggöra att mallar utformas dynamiskt för olika ändamål och olika typer av mottagare? AWS SES tillåter oss att skapa e-postmallar för att skicka personliga e-postmeddelanden till en eller flera destinationer i en enda operation.
Vi kan skapa upp till 10,000 500 e-postmallar per Amazon SES-konto. Varje mall kan vara upp till 50KB stor, inklusive både text- och HTML-delar. Vi kan skicka upp till XNUMX destinationer i varje samtal.
Så låt oss snabbt skapa en e-postmall. Först kan vi definiera en JSON-fil med följande mall:
{
"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."
}
}
Denna mall innehåller följande attribut:
- Mallnamn: Detta innehåller namnet på mallen.
- Ämnesdel: Detta innehåller e-postmeddelandets ämnesrad. Ersättningstaggar kan finnas på den här tillgången. Dessa taggar är formaterade enligt följande:
{{tagname}}. Du kan ange ett värde för{{tagname}}för varje destination när du skickar e-postmeddelandet. - HtmlPart: Detta innehåller HTML-texten i e-postmeddelandet och det kan även innehålla ersättningstaggar.
- TextPart: Detta representerar e-postmeddelandets texttext. Denna version av e-postmeddelandet skickas till mottagare vars e-postklienter inte ser HTML-e-postmeddelanden. Ersättningstaggar kan finnas på den här tillgången.
Vi kan spara den här filen som mytemplate.json. Slutligen kan vi använda ett AWS CLI-kommando för att skapa mallen enligt följande:
$ aws ses create-template --cli-input-json file://mytemplate.json
Låt oss sedan definiera ett servicelager för att definiera attribut och skicka mallade e-postmeddelanden:
@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);
}
}
Vi kan lägga till flera Destination adresser för att skicka massmeddelanden till flera mottagare. Vi använder sendTemplatedEmail() metod från AmazonSimpleEmailService gränssnitt för att skicka detta mallade e-postmeddelande. Vi måste också skicka ersättningstaggarna som ska ersättas i HTML-texten i vår mall som vi skapade tidigare.
Slutligen kommer vi att definiera en Controller lager för att definiera REST API för att skicka attributen:
@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";
}
}
Därefter, när vi kör appen, kan vi köra följande curl för att skicka mallade e-postmeddelanden:
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'
Nu får mottagaren äntligen se ett mallformat e-postmeddelande:
Begär produktionsåtkomst
Slutligen, för att skicka e-postmeddelanden till någon mottagare, oavsett om mottagarens adress eller domän är validerad, måste vi i slutändan ta vårt konto ur sandlådan. Alla våra identiteter, inklusive From, Source, Senderoch Return-Path adresser, måste fortfarande verifieras. Vi kan skicka in en begäran om produktionsåtkomst från "Kontoöversikt" sida enligt följande:
Vi kan skicka in begäran och fylla i alla ovanstående detaljer från AWS Console. Detsamma kan också skickas med AWS CLI. Detta skulle vara användbart när vi behöver begära åtkomst för ett stort antal identiteter och vill automatisera processen.
Slutsats
Nyckelidéerna för Amazon Simple Email Service (SES) och biblioteken som erbjuds av Spring Cloud AWS för att samverka med den behandlades i den här artikeln. Dessutom skapade vi en Spring Boot-applikation med ett REST API som kan skicka e-post via Spring Cloud AWS SES-modulen.
Du bör nu ha en gedigen förståelse för vad Amazon Simple Email Service (SES) är och hur man använder den för att skicka e-post.
