Guide til Simple Email Service (AWS SES) med Spring Boot og Spring Cloud

Introduktion

AWS SES (Simple Email Service) er en service, der er nem at konfigurere til at sende og modtage e-mail. Det er normalt svært, kræsent og kedeligt at administrere et on-premise e-mail-system, så outsourcing af processen er et populært valg.

Vi kan bruge Amazon SES til at sende transaktions-e-mails, marketing-e-mails eller enhver anden form for notifikations-e-mails til vores kunder. Det er en overkommelig løsning for virksomheder i alle størrelser, der bruger e-mails til at forbinde med deres kunder, da den er bygget på den pålidelige og skalerbare infrastruktur af Amazon Web Services (AWS).

For at sende massemails kan enhver applikation interagere med Amazon SES. Vi betaler kun for de e-mails, vi rent faktisk sender, uanset om det er transaktions-e-mails eller marketing-e-mails. Derudover understøttes en række konfigurationer, herunder dedikerede, delte eller ejede IP-adresser af Amazon SES. Virksomheder kan få hver e-mail til at tælle med brugen af ​​leveringsdashboards og rapporter om afsenderoplysninger.

I denne guide skal vi konfigurere en AWS SES-instans i en region og derefter integrere med Spring Cloud til AWS som er et delprojekt af Forårssky. Vi vil prøve forskellige scenarier for at sende e-mails fra vores applikation.

Bemærk: Du kan finde al den anvendte kildekode i vejledningen på Github.

Livscyklus for at sende en e-mail ved hjælp af AWS SES

Lad os se på, hvordan livscyklussen for en e-mail sendt af en applikation når til destinationspostkassen:

• En applikation, i vores tilfælde, Spring Cloud-koden anmoder AWS SES om at sende en e-mail til en eller flere modtagere.

• SES verificerer i første omgang anmodningen, og hvis den er godkendt, producerer den en e-mail med anmodningens specifikationer. Denne e-mail-meddelelse har en overskrift, brødtekst og konvolut og overholder RFC 5322's definition af internetmeddelelsesformat.

• SES sender derefter beskeden til modtagerens modtager over internettet. Så snart beskeden er afleveret til SES, bliver den ofte transmitteret med det samme, hvor det indledende leveringsforsøg typisk finder sted i løbet af millisekunder.

• Der er flere resultater på dette tidspunkt. For eksempel:

  • Vellykket levering: Internetudbyderen (ISP) accepterer e-mailen og sender den til den tilsigtede modtager.
  • Hårdt Bounce: Fordi modtagerens adresse er ugyldig, afviser internetudbyderen e-mailen. Internetudbyderen sender den hårde afvisningsmeddelelse tilbage til Amazon SES, som underretter afsenderen via e-mail eller ved at udgive den til et Amazon Simple Notification Service-emne (Amazon SNS), der er sat op til at modtage denne meddelelse.
  • Blødt Bounce: På grund af forhold som at modtagerens indbakke er fuld, domænet ikke eksisterer eller en forbigående omstændighed som at internetudbyderen har for travlt til at behandle anmodningen, kan internetudbyderen muligvis ikke levere e-mailen til modtageren. Internetudbyderen prøver derefter e-mailen igen op til et bestemt antal gange og sender SES en soft bounce-besked. Hvis SES ikke er i stand til at levere e-mailen inden for den angivne tidsramme, udgiver den enten begivenheden til et SNS-emne eller sender en hård afvisningsmeddelelse via e-mail.
  • Klage: E-mailen klassificeres som spam af modtageren i deres e-mail-program. En klagemeddelelse sendes til Amazon SES, som derefter videresender den til afsenderen, hvis Amazon SES og internetudbyderen har etableret en feedback-loop.
  • Autorespons: Modtagerens internetudbyder giver Amazon SES besked om et automatisk svar fra modtageren, såsom en meddelelse om fravær, og Amazon SES videregiver meddelelsen til afsenderen.

Når leveringen ikke lykkes, returnerer Amazon SES en fejl til afsenderen og sletter e-mailen.

Opsætning af Amazon SES

I modsætning til alle andre AWS-tjenester er der praktisk talt ingen grund til at oprette en SES-instans, da alle nye AWS-konti placeres i AWS SES-sandkassen som standard. Hver AWS-konto har som standard sandkasseadgang til AWS SES i de tilgængelige regioner.

Når vi bruger sandkassetilstand, kan vi kun sende e-mails til bekræftede identiteter. Et domæne eller en e-mailadresse, som vi bruger til at sende en e-mail, er en bekræftet identitet. Vi skal konstruere og validere hver identitet, vi agter at bruge som en From, To, Source, Sender eller Return-Path adresse, før vi kan sende en e-mail ved hjælp af SES i sandkassetilstand. Ved at bruge Amazon SES til at bekræfte identiteten kan vi bevise vores ejerskab og stoppe ulovlig brug.

For at undgå svindel og bevare en IP-adresses omdømme inkluderer AWS SES grænser for afsendelse af e-mails. Disse begrænsninger angiver det maksimale antal e-mails pr. sekund og den daglige e-mail-grænse for hver bruger. Ved at kontakte AWS Support Center kan vi etablere sådanne kvoter efter region.

Lad os bekræfte identiteter. Log ind på AWS-konsollen og søg efter "Amazon Simple Email Service"

Klik derefter på “Skab identitet” for at tilføje en e-mail eller et domæne til bekræftelse. I vores tilfælde vil vi tilføje en e-mail til bekræftelse.

Når først identiteten er oprettet, kan vi verificere detaljerne.

Den identitet, vi skabte, går ind i "Bekræftelse afventer" scene. På dette trin skal brugeren tjekke bekræftelsesmailen fra AWS og følge instruktionerne for at få e-mailen bekræftet.

Dernæst skal vi hente "adgangsnøgle"Og"hemmelig nøgle” til godkendelse og godkendelse af vores applikation med SES. For at generere det, skal vi oprette en brugergruppe og tilføje en bruger til den gruppe. Når vi opretter denne bruger, genererer AWS en adgangsnøgle og en hemmelig nøgle. Så lad os omdirigere til "IAM” i AWS-konsollen og opret brugergruppe.

Så skal vi tilføje "Administratoradgang” tilladelse til den gruppe for SES.

Til sidst vil vi tilføje en bruger til ovenstående gruppe.

Dernæst skal vi vælge gruppen for tilladelser.

Til sidst kopierer du adgangsnøglen og den hemmelige nøgle, der vises på skærmen for yderligere brug.

Afsendelse af e-mails ved hjælp af Spring Cloud Project

Projektopsætning

Lad os oprette et Spring Cloud-projekt og gennemgå use-cases for at integrere med SES. Den nemmeste måde at starte med et skeletprojekt på er via Spring Initializr:

Vi har tilføjet Forårs Web for REST MVC, Apache Freemarker at generere HTML-baserede e-mailskabeloner, Java Mail Sender at sende en e-mail og Lombok (valgfrit boilerplate-reducerende bibliotek) afhængigheder. Derudover skal vi tilføje relevante afhængigheder til Spring Cloud AWS og SES. For Spring Cloud AWS tilføjer vi en separat Spring Cloud AWS BOM i vores pom.xml fil ved hjælp af denne 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>

Til sidst, for at tilføje understøttelse af SES, skal vi inkludere modulafhængigheden, som er tilgængelig som et 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 omfatter de transitive afhængigheder for spring-cloud-starter-awsog spring-cloud-aws-ses. Det spring-cloud-aws-ses modul til SES indeholder to klasser: SimpleEmailServiceMailSender , SimpleEmailServiceJavaMailSender.

• SimpleEmailServiceMailSender klasse bruger Amazon Simple Email Service til at sende e-mails. Java Mail API er ikke et krav for denne implementering. Det kan bruges til at sende ligetil e-mail-beskeder uden vedhæftede filer.
• SimpleEmailServiceJavaMailSender klasse gør det muligt at sende e-mails, der indeholder vedhæftede filer og andre mime-elementer.

Så dette dækker alle vores grundlæggende krav!

Konfiguration af bønner

Som diskuteret ovenfor skal vi definere to typer bønner: SimpleEmailServiceMailSender , SimpleEmailServiceJavaMailSender. Vi kan blot videregive adgangsnøglen og den hemmelige nøgle som legitimationsoplysninger og konfigurere en MailSender bean, som vi vil bruge til at sende e-mails:

@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);
    }
}

For at sende e-mails med vedhæftede filer skal vi konfigurere SimpleEmailServiceJavaMailSender som er en implementering af JavaMailSender interface fra Springs mailabstraktion.

Vi vil også definere de egenskaber, der skal hentes oplysningerne fra application.yml:

cloud:
  aws:
    region:
      static: eu-central-1
      auto: false
    stack:
      auto: false
    credentials:
      access-key: ********
      secret-key: **************************

Sender simpel e-mail

Vi kan sende simple e-mails ved hjælp af SimpleEmailServiceMailSender bønne, som vi konfigurerede ovenfor. Lad os definere et servicelag for at bruge denne bønne:

@Service
public class EmailService {

    @Autowired
    private MailSender mailSender;

    public void sendMessage(SimpleMailMessage simpleMailMessage) {
        this.mailSender.send(simpleMailMessage);
    }
}

Vi ringer til send() metode i MailSender bean at sende vores e-mail. Vi skal også bestå SimpleMailMessage der ville indeholde attributter som from, to, teksten og emnet for vores e-mail. Så lad os definere en Controller klasse for at kalde ovenstående service ved hjælp af en 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, hvis vi kører programmet og udfører følgende krølle, vil det sende en e-mail til den bekræftede e-mailadresse:

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'

Dernæst kan vi logge ind på modtagerens mailadresse og verificere om modtageren har modtaget mailen.

Afsendelse af simpel e-mail med vedhæftet fil

Vi vil definere et servicelag til at videregive den vedhæftede fil som mime og indstille de andre e-mail-attributter som from, to, tekst og emne:

@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());
        }
    }
}

Her bruger vi MimeMessageHelper at oprette en e-mail med en vedhæftet fil. Til sidst vil vi definere Controller lag for at passere SimpleMailMessage egenskaber:

@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, hvis vi kører programmet og udfører følgende krølle, vil det sende en e-mail til den bekræftede e-mailadresse:

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'

Dernæst kan vi logge ind på modtagerens mailadresse og verificere om modtageren har modtaget mailen.

Sender skabelon e-mail med vedhæftet fil

De tidligere use-cases, som vi havde set, er gode til udviklings- eller testscenarier, men i produktionen bruger vi generelt en e-mail-skabelon med variabler, der ville blive erstattet ved hjælp af en API's svar. Vi havde tidligere tilføjet afhængigheden for Apache Freemarker. Vi vil bruge den til at definere en skabelon og indlæse den til at behandle!

Til dette, lad os først definere en simpel skabelon, navngiv den som email-template.ftl og læg den ind templates mappe 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>

Dernæst skal vi definere en konfigurationsklasse for at indlæse skabelonen fra stien og tilføje som bean. Til dette vil vi definere FreeMarkerConfigurationFactoryBean:

@Configuration
public class FreemarkerConfig {

    @Primary
    @Bean
    public FreeMarkerConfigurationFactoryBean factoryBean() {
        FreeMarkerConfigurationFactoryBean bean = new FreeMarkerConfigurationFactoryBean();
        bean.setTemplateLoaderPath("classpath:/templates");
        return bean;
    }
}

Dernæst vil vi definere vores servicelag for at indlæse denne skabelon og oprette en endelig besked til at sende til 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());
        }
    }

Til sidst vil vi definere en Controller lag for at videregive de dynamiske e-mail-attributter:

@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, hvis vi kører programmet og udfører følgende krølle, vil det sende en e-mail til den bekræftede e-mailadresse:

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'

Dernæst kan vi logge ind på modtagerens mailadresse og bekræfte, om modtageren har modtaget mailen:

Afsendelse af personlig e-mail ved hjælp af skabeloner i AWS SES

I den tidligere use-case brugte vi en statisk skabelon til at sende e-mails. Hvordan kan vi gøre det muligt for skabeloner at blive designet dynamisk til forskellige formål og forskellige typer modtagere? AWS SES giver os mulighed for at oprette e-mail-skabeloner til at sende personlige e-mails til en eller flere destinationer i en enkelt operation.

Vi kan oprette op til 10,000 e-mailskabeloner pr. Amazon SES-konto. Hver skabelon kan være op til 500 KB stor, inklusive både tekst- og HTML-delen. Vi kan sende op til 50 destinationer i hvert opkald.

Så lad os hurtigt oprette en e-mail-skabelon. Først kan vi definere en JSON-fil ved hjælp af følgende skabelon:

{
  "Template": {
    "TemplateName": "MyTemplate",
    "SubjectPart": "Greetings from {{name}}!",
    "HtmlPart": "


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."
  }
}

Denne skabelon indeholder følgende attributter:

• Skabelonnavn: Dette indeholder navnet på skabelonen.
• Emnedel: Dette indeholder e-mailens emnelinje. Erstatningstags kan være til stede på dette aktiv. Disse tags er formateret som følger: {{tagname}}. Du kan indtaste en værdi for {{tagname}} for hver destination, når du sender e-mailen.
• HtmlPart: Dette indeholder HTML-teksten i e-mailen, og det kan også indeholde erstatningstags.
• Tekstdel: Dette repræsenterer e-mailens tekstbrød. Denne version af e-mailen sendes til modtagere, hvis e-mail-klienter ikke ser HTML-e-mails. Erstatningstags kan være til stede på dette aktiv.

Vi kan gemme denne fil som mytemplate.json. Endelig kan vi bruge en AWS CLI-kommando til at oprette skabelonen som følger:

$ aws ses create-template --cli-input-json file://mytemplate.json

Lad os derefter definere et servicelag til at definere attributter og sende skabelonformede e-mails:

@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 tilføje flere Destination adresser til at sende massemails til flere modtagere. Vi bruger sendTemplatedEmail() metode fra AmazonSimpleEmailService interface til at sende denne skabelon-e-mail. Vi skal også sende de erstatningstags, der skal erstattes, i HTML-teksten i vores skabelon, som vi oprettede tidligere.

Til sidst vil vi definere en Controller lag for at definere REST API'et for at videregive attributterne:

@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";
    }
}

Dernæst, når vi kører appen, kan vi udføre følgende curl for at sende skabelon e-mails:

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 kan modtageren endelig se en skabelon e-mail:

Anmod om produktionsadgang

Endelig, for at sende e-mails til enhver modtager, uanset om modtagerens adresse eller domæne er valideret, skal vi i sidste ende tage vores konto ud af sandkassen. Alle vores identiteter, inklusive From, Source, Senderog Return-Path adresser, skal stadig verificeres. Vi kan indsende en anmodning om produktionsadgang fra "Kontoudashboard” side som følger:

Vi kan indsende anmodningen ved at udfylde alle ovenstående detaljer fra AWS Console. Det samme kan også indsendes ved hjælp af AWS CLI. Dette ville være nyttigt, når vi skal anmode om adgang til et stort antal identiteter og gerne vil automatisere processen.

Konklusion

Nøgleideerne til Amazon Simple Email Service (SES) og bibliotekerne, der tilbydes af Spring Cloud AWS til at interface med det, blev dækket i denne artikel. Derudover oprettede vi en Spring Boot-applikation med en REST API, der kan sende e-mails gennem Spring Cloud AWS SES-modulet.

Du bør nu have en solid forståelse af, hvad Amazon Simple Email Service (SES) er, og hvordan du bruger det til at sende e-mails.