Gids voor eenvoudige e-mailservice (AWS SES) met Spring Boot en Spring Cloud

Introductie

AWS SES (eenvoudige e-mailservice) is een eenvoudig in te stellen service voor het verzenden en ontvangen van e-mail. Het is meestal moeilijk, kieskeurig en vervelend om een ​​lokaal e-mailsysteem te beheren, dus het uitbesteden van het proces is een populaire keuze.

We kunnen Amazon SES gebruiken om transactionele e-mails, marketing-e-mails of andere soorten notificatie-e-mails naar onze klanten te sturen. Het is een betaalbare oplossing voor bedrijven van elke omvang die e-mail gebruiken om in contact te komen met hun klanten, aangezien het is gebouwd op de betrouwbare en schaalbare infrastructuur van Amazon Web Services (AWS).

Voor het verzenden van bulk-e-mails kan elke toepassing communiceren met Amazon SES. We betalen alleen voor de e-mails die we daadwerkelijk verzenden, of het nu gaat om transactie-e-mails of marketing-e-mails. Bovendien wordt een reeks configuraties, waaronder speciale, gedeelde of eigen IP-adressen, ondersteund door Amazon SES. Bedrijven kunnen elke e-mail laten tellen met behulp van dashboards voor bezorging en rapporten over afzenderinformatie.

In deze handleiding gaan we een AWS SES-instantie in een regio configureren en vervolgens integreren Spring Cloud voor AWS dat is een deelproject van Lente Cloud. We zullen verschillende scenario's uitproberen om e-mails vanuit onze applicatie te verzenden.

Opmerking: U kunt alle gebruikte broncode vinden in de gids op GitHub.

Levenscyclus van het verzenden van een e-mail met AWS SES

Laten we eens kijken hoe de levenscyclus van een e-mail die door een toepassing wordt verzonden, de bestemmingsmailbox bereikt:

• Een applicatie, in ons geval de Spring Cloud-code, vraagt ​​AWS SES om een ​​e-mail te sturen naar een of meer ontvangers.

• SES verifieert in eerste instantie het verzoek, en als het wordt goedgekeurd, produceert het een e-mailbericht met de specificaties van het verzoek. Dit e-mailbericht heeft een koptekst, hoofdtekst en envelop en voldoet aan RFC 5322's Internet Message Format-definitie.

• SES verzendt het bericht vervolgens via internet naar de ontvanger van de ontvanger. Zodra het bericht aan SES is overgedragen, wordt het vaak meteen verzonden, waarbij de eerste bezorgpoging doorgaans binnen enkele milliseconden plaatsvindt.

• Op dit moment zijn er verschillende uitkomsten. Bijvoorbeeld:

  • Succesvolle levering: De internetprovider (ISP) accepteert de e-mail en stuurt deze naar de beoogde ontvanger.
  • Hard stuiteren: Omdat het adres van de ontvanger ongeldig is, weigert de ISP de e-mail. De ISP stuurt de hard bounce-melding terug naar Amazon SES, die de afzender op de hoogte stelt via e-mail of door deze te publiceren op een Amazon Simple Notification Service (Amazon SNS) -onderwerp dat is ingesteld om deze melding te ontvangen.
  • Zachte stuitering: Als de inbox van de ontvanger vol is, het domein niet bestaat of een voorbijgaande omstandigheid, zoals de ISP die het te druk heeft om het verzoek te verwerken, kan de ISP de e-mail mogelijk niet bij de ontvanger afleveren. De ISP probeert de e-mail vervolgens een bepaald aantal keren opnieuw en stuurt SES een soft bounce-bericht. Als SES de e-mail niet binnen het opgegeven tijdsbestek kan bezorgen, publiceert het de gebeurtenis naar een SNS-onderwerp of stuurt het een hard bounce-bericht via e-mail.
  • Klacht: De e-mail wordt door de ontvanger in zijn e-mailprogramma als spam geclassificeerd. Er wordt een klachtmelding verzonden naar Amazon SES, die deze vervolgens doorstuurt naar de afzender als Amazon SES en de ISP een feedbacklus hebben opgezet.
  • Automatisch Antwoord: De ontvangende ISP stelt Amazon SES op de hoogte van een automatisch antwoord van de ontvanger, zoals een afwezigheidsmelding, en Amazon SES geeft de melding door aan de afzender.

Wanneer de bezorging niet is gelukt, stuurt Amazon SES een fout terug naar de afzender en verwijdert de e-mail.

Amazon SES instellen

In tegenstelling tot andere AWS-services is het praktisch niet nodig om een ​​SES-instantie te maken, omdat alle nieuwe AWS-accounts standaard in de AWS SES-sandbox worden geplaatst. Elk AWS-account heeft standaard sandbox-toegang voor AWS SES in de beschikbare regio's.

Bij gebruik van de sandbox-modus kunnen we alleen e-mails verzenden naar geverifieerde identiteiten. Een domein of e-mailadres dat we gebruiken om een ​​e-mail te verzenden, is een geverifieerde identiteit. We moeten elke identiteit die we willen gebruiken construeren en valideren From, To, Source, Senderof Return-Path adres voordat we een e-mail kunnen sturen met SES in sandbox-modus. Door Amazon SES te gebruiken om de identiteit te verifiëren, kunnen we ons eigendom bewijzen en illegaal gebruik stoppen.

Om fraude te voorkomen en de reputatie van een IP-adres te behouden, bevat AWS SES limieten voor het verzenden van e-mail. Deze beperkingen specificeren het maximum aantal e-mails per seconde en de dagelijkse e-maillimiet voor elke gebruiker. Door contact op te nemen met het AWS Support Center kunnen we dergelijke quota per regio vaststellen.

Laten we identiteiten verifiëren. Log in op AWS Console en zoek naar "Amazon eenvoudige e-mailservice"

Klik vervolgens op "Identiteit creëren” om een ​​e-mail of een domein toe te voegen voor verificatie. In ons geval gaan we een e-mail toevoegen ter verificatie.

Zodra de identiteit is aangemaakt, kunnen we de details verifiëren.

De identiteit die we hebben gecreëerd gaat in “Verificatie in behandeling" fase. In dit stadium moet de gebruiker de verificatiemail van AWS controleren en de instructies volgen om de e-mail te laten verifiëren.

Vervolgens moeten we ophalen "toegangssleutel"En"geheime sleutel” voor de authenticatie en autorisatie van onze applicatie met SES. Om dat te genereren, moeten we een gebruikersgroep maken en een gebruiker aan die groep toevoegen. Wanneer we die gebruiker aanmaken, genereert AWS een toegangssleutel en geheime sleutel. Dus laten we doorverwijzen naar "IAM” in AWS Console en maak Gebruikersgroep aan.

Dan moeten we toevoegen "Beheerderstoegang"toestemming aan die groep voor SES.

Ten slotte voegen we een gebruiker toe aan de bovenstaande groep.

Vervolgens moeten we de groep voor machtigingen selecteren.

Kopieer ten slotte de toegangssleutel en geheime sleutel die op het scherm worden weergegeven voor verder gebruik.

E-mails verzenden met Spring Cloud Project

Project Setup

Laten we een Spring Cloud-project opstarten en de use-cases doornemen om te integreren met SES. De eenvoudigste manier om met een skeletproject te beginnen, is via Lente Initializr:

We hebben toegevoegd Lente Web voor REST MVC, Apache Freemarker om op HTML gebaseerde e-mailsjablonen te genereren, Java Mail-afzender om een ​​e-mail te sturen en Lombok (optionele standaardverminderende bibliotheek) afhankelijkheden. Daarnaast moeten we relevante afhankelijkheden toevoegen voor Spring Cloud AWS en SES. Voor Spring Cloud AWS voegen we een aparte Spring Cloud AWS BOM toe aan onze pom.xml bestand dit gebruiken 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>

Ten slotte moeten we, om de ondersteuning voor SES toe te voegen, de module-afhankelijkheid toevoegen die beschikbaar is als een startmodule spring-cloud-starter-aws-ses:

<dependency>
	<groupId>io.awspring.cloud</groupId>
	<artifactId>spring-cloud-starter-aws-ses</artifactId>
</dependency>

spring-cloud-starter-aws-ses omvat de transitieve afhankelijkheden voor spring-cloud-starter-aws en spring-cloud-aws-ses. De spring-cloud-aws-ses module voor SES bevat twee klassen: SimpleEmailServiceMailSender en SimpleEmailServiceJavaMailSender.

• De SimpleEmailServiceMailSender class gebruikt Amazon Simple Email Service om e-mails te verzenden. De Java Mail API is geen vereiste voor deze implementatie. Het kan worden gebruikt om eenvoudige e-mailberichten zonder bijlagen te verzenden.
• De SimpleEmailServiceJavaMailSender class maakt het verzenden van e-mails mogelijk die bijlagen en andere MIME-elementen bevatten.

Dit dekt dus al onze basisbehoeften!

Bonen configureren

Zoals hierboven besproken, moeten we twee soorten bonen definiëren: SimpleEmailServiceMailSender en SimpleEmailServiceJavaMailSender. We kunnen eenvoudig de toegangssleutel en geheime sleutel doorgeven als inloggegevens en een configureren MailSender bean die we zullen gebruiken om e-mails te verzenden:

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

Om e-mails met bijlagen te kunnen verzenden, moeten we de SimpleEmailServiceJavaMailSender wat een implementatie is van de JavaMailSender interface van de mail-abstractie van Spring.

We zullen ook de eigenschappen definiëren waaruit de informatie moet worden opgehaald application.yml:

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

Eenvoudige e-mail verzenden

We kunnen eenvoudige e-mails verzenden met behulp van de SimpleEmailServiceMailSender bean die we hierboven hebben geconfigureerd. Laten we een servicelaag definiëren om deze bean te gebruiken:

@Service
public class EmailService {

    @Autowired
    private MailSender mailSender;

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

We bellen de send() methode in de MailSender bean om onze e-mail te sturen. We moeten ook de SimpleMailMessage dat zou attributen bevatten zoals from, to, de tekst en het onderwerp van onze e-mail. Laten we dus a definiëren Controller class om de bovenstaande service aan te roepen met behulp van een 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";
    }
}

Als we nu de applicatie uitvoeren en de volgende curl uitvoeren, wordt er een e-mail verzonden naar het geverifieerde e-mailadres:

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'

Vervolgens kunnen we inloggen op het e-mailadres van de ontvanger en controleren of de ontvanger de e-mail heeft ontvangen.

Eenvoudige e-mail met bijlage verzenden

We zullen een servicelaag definiëren om de bijlage door te geven als mime en de andere e-mailattributen instellen zoals from, to, tekst en onderwerp:

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

Hier gebruiken we MimeMessageHelper om een ​​e-mail met een bijlage te maken. Ten slotte zullen we definiëren Controller laag om de te passeren SimpleMailMessage attributen:

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

Als we nu de applicatie uitvoeren en de volgende curl uitvoeren, wordt er een e-mail verzonden naar het geverifieerde e-mailadres:

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'

Vervolgens kunnen we inloggen op het e-mailadres van de ontvanger en controleren of de ontvanger de e-mail heeft ontvangen.

Sjabloon-e-mail met bijlage verzenden

De vorige use-cases die we hadden gezien, zijn goed voor ontwikkelings- of testscenario's, maar in productie gebruiken we over het algemeen een e-mailsjabloon met variabelen die zouden worden vervangen met behulp van de antwoorden van een API. We hadden eerder de afhankelijkheid voor toegevoegd Apache Freemarker. We zullen het gebruiken om een ​​sjabloon te definiëren en het te laden om te verwerken!

Laten we hiervoor eerst een eenvoudige sjabloon definiëren, noem deze als email-template.ftl en plaats het erin templates map onder 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>

Vervolgens moeten we een configuratieklasse definiëren om de sjabloon van het pad te laden en toe te voegen als bean. Hiervoor zullen we definiëren FreeMarkerConfigurationFactoryBean:

@Configuration
public class FreemarkerConfig {

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

Vervolgens zullen we onze servicelaag definiëren om deze sjabloon te laden en een laatste bericht maken om naar SES te sturen:

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

Ten slotte definiëren we a Controller laag om de dynamische e-mailattributen door te geven:

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

Als we nu de applicatie uitvoeren en de volgende curl uitvoeren, wordt er een e-mail verzonden naar het geverifieerde e-mailadres:

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'

Vervolgens kunnen we inloggen op het e-mailadres van de ontvanger en controleren of de ontvanger de e-mail heeft ontvangen:

Gepersonaliseerde e-mail verzenden met behulp van sjablonen in AWS SES

In de vorige use-case gebruikten we een statisch sjabloon om e-mails te verzenden. Hoe kunnen we ervoor zorgen dat sjablonen dynamisch worden ontworpen voor verschillende doeleinden en verschillende soorten ontvangers? Met AWS SES kunnen we e-mailsjablonen maken om gepersonaliseerde e-mails in één keer naar een of meer bestemmingen te sturen.

We kunnen tot 10,000 e-mailsjablonen per Amazon SES-account maken. Elke sjabloon kan maximaal 500 KB groot zijn, inclusief zowel de tekst als de HTML-gedeelten. We kunnen tot 50 bestemmingen per oproep verzenden.

Dus laten we snel een e-mailsjabloon maken. Eerst kunnen we een JSON-bestand definiëren met behulp van de volgende sjabloon:

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

Dit sjabloon bevat de volgende kenmerken:

• Sjabloonnaam: Dit bevat de naam van de sjabloon.
• OnderwerpDeel: Dit bevat de onderwerpregel van de e-mail. Er kunnen vervangende tags aanwezig zijn op dit item. Deze tags zijn als volgt opgemaakt: {{tagname}}. U kunt een waarde voor invullen {{tagname}} voor elke bestemming bij het verzenden van de e-mail.
• HtmlDeel: Dit bevat de HTML-tekst van de e-mail en kan ook vervangende tags bevatten.
• TekstDeel: Dit vertegenwoordigt de tekst van de e-mail. Deze versie van de e-mail wordt verzonden naar ontvangers wiens e-mailclients geen HTML-e-mails bekijken. Er kunnen vervangende tags aanwezig zijn op dit item.

We kunnen dit bestand opslaan als mytemplate.json. Eindelijk kunnen we een AWS CLI-opdracht gebruiken om de sjabloon als volgt te maken:

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

Laten we vervolgens een servicelaag definiëren om attributen te definiëren en sjabloon-e-mails te verzenden:

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

We kunnen er meerdere toevoegen Destination adressen om bulk-e-mails naar meerdere ontvangers te sturen. We gebruiken de sendTemplatedEmail() methode uit de AmazonSimpleEmailService interface om deze sjabloon-e-mail te verzenden. We moeten ook de vervangende tags doorgeven die moeten worden vervangen in de HTML-tekst van onze sjabloon die we eerder hebben gemaakt.

Ten slotte definiëren we a Controller laag om de REST API te definiëren om de attributen door te geven:

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

Wanneer we vervolgens de app uitvoeren, kunnen we het volgende uitvoeren curl sjabloon-e-mails verzenden:

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 krijgt de ontvanger eindelijk een e-mailsjabloon te zien:

Vraag productietoegang aan

Om e-mails naar elke ontvanger te kunnen sturen, ongeacht of het adres of domein van de ontvanger gevalideerd is, moeten we uiteindelijk ons ​​account uit de sandbox halen. Al onze identiteiten, inclusief From, Source, Sender en Return-Path adressen, moet nog geverifieerd worden. We kunnen een verzoek indienen voor productietoegang vanuit de "Account Dashboard" pagina als volgt:

We kunnen het verzoek indienen door alle bovenstaande gegevens van AWS Console in te vullen. Hetzelfde kan ook worden ingediend met behulp van AWS CLI. Dit zou handig zijn wanneer we toegang moeten vragen voor een groot aantal identiteiten en we het proces willen automatiseren.

Conclusie

De belangrijkste ideeën van Amazon Simple Email Service (SES) en de bibliotheken die door Spring Cloud AWS worden aangeboden om ermee te communiceren, werden in dit artikel behandeld. Daarnaast hebben we een Spring Boot-applicatie gemaakt met een REST API die e-mails kan verzenden via de Spring Cloud AWS SES-module.

U zou nu een goed begrip moeten hebben van wat Amazon Simple Email Service (SES) is en hoe u het kunt gebruiken om e-mails te verzenden.