Veiledning til enkel e-posttjeneste (AWS SES) med Spring Boot og Spring Cloud

Introduksjon

AWS SES (Simple Email Service) er en tjeneste som er enkel å konfigurere for sending og mottak av e-post. Det er vanligvis vanskelig, kresen og kjedelig å administrere et lokalt e-postsystem, så outsourcing av prosessen er et populært valg.

Vi kan bruke Amazon SES til å sende transaksjonelle e-poster, markedsførings-e-poster eller andre typer varslings-e-poster til våre kunder. Det er en rimelig løsning for bedrifter i alle størrelser som bruker e-post for å komme i kontakt med kundene sine siden den er bygget på den pålitelige og skalerbare infrastrukturen til Amazon Web Services (AWS).

For å sende massee-poster kan alle apper samhandle med Amazon SES. Vi betaler kun for e-postene vi faktisk sender, enten de er transaksjonelle e-poster eller markedsførings-e-poster. I tillegg støttes en rekke konfigurasjoner, inkludert dedikerte, delte eller eide IP-adresser, av Amazon SES. Bedrifter kan få hver e-post til å telle med bruk av dashboard for levering og rapporter om avsenderinformasjon.

I denne veiledningen skal vi konfigurere en AWS SES-instans i en region og deretter integrere med Spring Cloud for AWS som er et delprosjekt av Vårsky. Vi vil prøve ut forskjellige scenarier for å sende e-post fra applikasjonen vår.

OBS: Du finner all kildekoden som brukes i veiledningen på Github.

Livssyklus for å sende en e-post ved hjelp av AWS SES

La oss se på hvordan livssyklusen til en e-post sendt av en applikasjon når til destinasjonspostboksen:

• En applikasjon, i vårt tilfelle, Spring Cloud-koden ber AWS SES om å sende en e-post til en eller flere mottakere.

• SES bekrefter først forespørselen, og hvis den blir godkjent, produserer den en e-postmelding med forespørselens spesifikasjoner. Denne e-postmeldingen har en overskrift, brødtekst og konvolutt og er i samsvar med RFC 5322s definisjon av Internet Message Format.

• SES sender deretter meldingen til mottakerens mottaker over Internett. Så snart meldingen er overlevert til SES, blir den ofte overført med en gang, med det første leveringsforsøket som vanligvis finner sted i løpet av millisekunder.

• Det er flere utfall på dette tidspunktet. For eksempel:

  • Vellykket levering: Internett-leverandøren (ISP) godtar e-posten og sender den til den tiltenkte mottakeren.
  • Hard Bounce: Fordi mottakerens adresse er ugyldig, avviser Internett-leverandøren e-posten. Internett-leverandøren sender varselet om hardt retur til Amazon SES, som varsler avsenderen via e-post eller ved å publisere det til et Amazon Simple Notification Service-emne (Amazon SNS) som er satt opp for å motta denne varslingen.
  • Myk sprett: På grunn av forhold som at mottakerens innboks er full, at domenet ikke eksisterer, eller noen forbigående omstendigheter som at Internett-leverandøren er for opptatt til å behandle forespørselen, kan det hende at ISP ikke kan levere e-posten til mottakeren. Internett-leverandøren prøver deretter e-posten på nytt opptil et visst antall ganger og sender SES en myk returmelding. Hvis SES ikke er i stand til å levere e-posten innen den angitte tidsrammen, publiserer den enten hendelsen til et SNS-emne eller sender en hard returmelding via e-post.
  • Klage: E-posten er klassifisert som spam av mottakeren i deres e-postprogram. Et klagevarsel sendes til Amazon SES, som deretter videresender det til avsenderen hvis Amazon SES og ISP har etablert en tilbakemeldingssløyfe.
  • Autorespons: Mottakerens ISP varsler Amazon SES om et automatisert svar fra mottakeren, for eksempel en fraværsmelding, og Amazon SES sender varselet til avsenderen.

Når leveringen mislykkes, returnerer Amazon SES en feilmelding til avsenderen og sletter e-posten.

Sette opp Amazon SES

I motsetning til alle andre AWS-tjenester, er det praktisk talt ikke nødvendig å opprette en SES-forekomst, da alle nye AWS-kontoer er plassert i AWS SES-sandbox som standard. Hver AWS-konto har sandkassetilgang for AWS SES i de tilgjengelige regionene som standard.

Når vi bruker sandkassemodus, kan vi bare sende e-post til bekreftede identiteter. Et domene eller en e-postadresse som vi bruker til å sende en e-post er en bekreftet identitet. Vi må konstruere og validere hver identitet vi har tenkt å bruke som en From, To, Source, Sendereller Return-Path adresse før vi kan sende en e-post med SES i sandkassemodus. Ved å bruke Amazon SES for å bekrefte identiteten, kan vi bevise vårt eierskap og stoppe ulovlig bruk.

For å unngå svindel og bevare omdømmet til en IP-adresse, inkluderer AWS SES grenser for e-postsending. Disse begrensningene spesifiserer maksimalt antall e-poster per sekund og den daglige e-postgrensen for hver bruker. Ved å ta kontakt med AWS Support Center kan vi etablere slike kvoter etter region.

La oss verifisere identiteter. Logg på AWS-konsollen og søk etter "Enkel e -posttjeneste fra Amazon"

Klikk deretter på “Skap identitet" for å legge til en e-post eller et domene for bekreftelse. I vårt tilfelle skal vi legge til en e-post for bekreftelse.

Når identiteten er opprettet, kan vi bekrefte detaljene.

Identiteten vi skapte går inn i "Bekreftelse venter” scenen. På dette stadiet må brukeren sjekke bekreftelsesposten fra AWS og følge instruksjonene for å få e-posten bekreftet.

Deretter må vi hente "tilgangsnøkkel"Og"hemmelig nøkkel” for autentisering og godkjenning av applikasjonen vår med SES. For å generere det, må vi opprette en brukergruppe og legge til en bruker i den gruppen. Når vi oppretter den brukeren, genererer AWS en tilgangsnøkkel og hemmelig nøkkel. Så la oss omdirigere til "IAM” i AWS-konsollen og opprett brukergruppe.

Da må vi legge til "Administratortilgang” tillatelse til den gruppen for SES.

Til slutt vil vi legge til en bruker i gruppen ovenfor.

Deretter må vi velge gruppen for tillatelser.

Til slutt kopierer du tilgangsnøkkelen og den hemmelige nøkkelen som vises på skjermen for videre bruk.

Sende e-poster med Spring Cloud Project

Prosjektoppsett

La oss spinne opp et Spring Cloud-prosjekt og kjøre gjennom brukssakene for å integrere med SES. Den enkleste måten å starte med et skjelettprosjekt på er via Våren Initializr:

Vi har lagt til Vårweb for REST MVC, Apache Freemarker å generere HTML-baserte e-postmaler, Java Mail Sender å sende en e-post og Lombok (valgfritt boilerplate-reduserende bibliotek) avhengigheter. I tillegg må vi legge til relevante avhengigheter for Spring Cloud AWS og SES. For Spring Cloud AWS vil vi legge til en egen Spring Cloud AWS BOM i vår pom.xml fil ved hjelp av denne blokkere:

<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 slutt, for å legge til støtte for SES, må vi inkludere modulavhengigheten som er tilgjengelig 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 inkluderer de transitive avhengighetene for spring-cloud-starter-awsog spring-cloud-aws-ses. De spring-cloud-aws-ses modul for SES inneholder to klasser: SimpleEmailServiceMailSender og SimpleEmailServiceJavaMailSender.

• De SimpleEmailServiceMailSender klasse bruker Amazon Simple Email Service for å sende e-poster. Java Mail API er ikke et krav for denne implementeringen. Den kan brukes til å sende enkle e-postmeldinger uten vedlegg.
• De SimpleEmailServiceJavaMailSender klasse gjør det mulig å sende e-poster som inneholder vedlegg og andre mime-elementer.

Så dette dekker alle våre grunnleggende krav!

Konfigurere bønner

Som diskutert ovenfor, må vi definere to typer bønner: SimpleEmailServiceMailSender og SimpleEmailServiceJavaMailSender. Vi kan ganske enkelt gi tilgangsnøkkelen og den hemmelige nøkkelen som legitimasjon og konfigurere en MailSender bean som vi vil bruke til å sende e-poster:

@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 å sende e-post med vedlegg må vi konfigurere SimpleEmailServiceJavaMailSender som er en implementering av JavaMailSender grensesnitt fra Springs postabstraksjon.

Vi vil også definere egenskapene for å hente informasjonen fra application.yml:

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

Sender enkel e-post

Vi kan sende enkle e-poster ved å bruke SimpleEmailServiceMailSender bønne som vi konfigurerte ovenfor. La oss definere et servicelag for å bruke denne bønnen:

@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 å sende vår e-post. Vi må også bestå SimpleMailMessage som vil inneholde attributter som from, to, teksten og emnet for e-posten vår. Så la oss definere en Controller klasse for å kalle opp tjenesten ovenfor ved hjelp av 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";
    }
}

Nå, hvis vi kjører applikasjonen og kjører følgende krølle, vil den sende en e-post til den bekreftede 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'

Deretter kan vi logge inn på mottakerens e-postadresse og bekrefte om mottakeren har mottatt e-posten.

Sende enkel e-post med vedlegg

Vi vil definere et servicelag for å sende vedlegget som mime og angi de andre e-postattributtene 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 bruker vi MimeMessageHelper for å lage en e-post med et vedlegg. Til slutt vil vi definere Controller lag for å passere SimpleMailMessage attributter:

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

Nå, hvis vi kjører applikasjonen og kjører følgende krølle, vil den sende en e-post til den bekreftede 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'

Deretter kan vi logge inn på mottakerens e-postadresse og bekrefte om mottakeren har mottatt e-posten.

Sender mal e-post med vedlegg

De tidligere brukssakene vi hadde sett er gode for utviklings- eller testscenarier, men i produksjon bruker vi vanligvis en e-postmal med variabler som vil bli erstattet ved hjelp av svarene til en API. Vi hadde tidligere lagt til avhengigheten for Apache Freemarker. Vi vil bruke den til å definere en mal og laste den inn for å behandle!

For dette, la oss først definere en enkel mal, navngi den som email-template.ftl og plasser den i 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>

Deretter må vi definere en konfigurasjonsklasse for å laste malen fra banen og legge til som bean. For dette vil vi definere FreeMarkerConfigurationFactoryBean:

@Configuration
public class FreemarkerConfig {

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

Deretter vil vi definere tjenestelaget vårt for å laste denne malen og lage en siste melding som skal sendes 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 slutt vil vi definere en Controller lag for å sende de dynamiske e-postattributtene:

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

Nå, hvis vi kjører applikasjonen og kjører følgende krølle, vil den sende en e-post til den bekreftede 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'

Deretter kan vi logge inn på mottakerens e-postadresse og bekrefte om mottakeren har mottatt e-posten:

Sende personlig e-post ved hjelp av maler i AWS SES

I forrige use-case brukte vi en statisk mal for å sende e-poster. Hvordan kan vi gjøre det mulig å utforme maler dynamisk for ulike formål og ulike typer mottakere? AWS SES lar oss lage e-postmaler for å sende personlig tilpassede e-poster til en eller flere destinasjoner i en enkelt operasjon.

Vi kan lage opptil 10,000 500 e-postmaler per Amazon SES-konto. Hver mal kan være opptil 50 KB i størrelse, inkludert både tekst- og HTML-delen. Vi kan sende opptil XNUMX destinasjoner i hver samtale.

Så la oss raskt lage en e-postmal. Først kan vi definere en JSON-fil ved å bruke følgende mal:

{
  "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 malen inneholder følgende attributter:

• Malnavn: Denne inneholder navnet på malen.
• Emnedel: Dette inneholder e-postens emnelinje. Erstatningsetiketter kan være til stede på denne ressursen. Disse taggene er formatert som følger: {{tagname}}. Du kan angi en verdi for {{tagname}} for hver destinasjon når du sender e-posten.
• HtmlPart: Denne inneholder HTML-teksten til e-posten og den kan også inneholde erstatningskoder.
• Tekstdel: Dette representerer e-postens tekstbrødtekst. Denne versjonen av e-posten sendes til mottakere hvis e-postklienter ikke ser HTML-e-poster. Erstatningsetiketter kan være til stede på denne ressursen.

Vi kan lagre denne filen som mytemplate.json. Til slutt kan vi bruke en AWS CLI-kommando for å lage malen som følger:

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

La oss deretter definere et tjenestelag for å definere attributter og sende malte e-poster:

@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 legge til flere Destination adresser for å sende massee-post til flere mottakere. Vi bruker sendTemplatedEmail() metoden fra AmazonSimpleEmailService grensesnitt for å sende denne malte e-posten. Vi må også sende erstatningstaggene som skal erstattes i HTML-teksten til malen vår som vi opprettet tidligere.

Til slutt vil vi definere en Controller lag for å definere REST API for å sende attributtene:

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

Deretter, når vi kjører appen, kan vi utføre følgende curl for å sende malte e-poster:

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'

Nå får mottakeren endelig se en malt e-post:

Be om produksjonstilgang

Til slutt, for å sende e-post til enhver mottaker, uavhengig av om mottakerens adresse eller domene er validert, må vi til slutt ta kontoen vår ut av sandkassen. Alle våre identiteter, inkludert From, Source, Senderog Return-Path adresser, må fortsatt verifiseres. Vi kan sende inn en forespørsel om produksjonstilgang fra "Kontooversikt"-siden som følger:

Vi kan sende inn forespørselen og fylle ut alle detaljene ovenfor fra AWS-konsollen. Det samme kan også sendes inn ved hjelp av AWS CLI. Dette vil være nyttig når vi trenger å be om tilgang for et stort antall identiteter og ønsker å automatisere prosessen.

konklusjonen

Nøkkelideene til Amazon Simple Email Service (SES) og bibliotekene som tilbys av Spring Cloud AWS for å kommunisere med den, ble dekket i denne artikkelen. I tillegg har vi laget en Spring Boot-applikasjon med en REST API som kan sende e-poster gjennom Spring Cloud AWS SES-modulen.

Du bør nå ha en solid forståelse av hva Amazon Simple Email Service (SES) er og hvordan du bruker den til å sende e-post.