Guida al servizio di posta elettronica semplice (AWS SES) con Spring Boot e Spring Cloud

Introduzione

AWS SES (Servizio e-mail semplice) è un servizio di invio e ricezione di e-mail semplice da configurare. Di solito è difficile, complicato e noioso gestire un sistema di posta elettronica on-premise, quindi esternalizzare il processo è una scelta popolare.

Possiamo utilizzare Amazon SES per inviare e-mail transazionali, e-mail di marketing o qualsiasi altro tipo di e-mail di notifica ai nostri clienti. È una soluzione conveniente per le aziende di tutte le dimensioni che utilizzano le e-mail per connettersi con i propri clienti poiché è costruita sull'infrastruttura affidabile e scalabile di Amazon Web Services (AWS).

Per l'invio di e-mail in blocco, qualsiasi applicazione può interagire con Amazon SES. Paghiamo solo per le e-mail che effettivamente inviamo, siano esse e-mail transazionali o e-mail di marketing. Inoltre, Amazon SES supporta una serie di configurazioni, tra cui indirizzi IP dedicati, condivisi o di proprietà. Le aziende possono fare in modo che ogni e-mail conti con l'uso di dashboard e rapporti di deliverability sulle informazioni del mittente.

In questa guida configureremo un'istanza AWS SES in una regione e quindi ci integreremo con Spring Cloud per AWS che è un sottoprogetto di nuvola di primavera. Proveremo diversi scenari per inviare e-mail dalla nostra applicazione.

Nota: Puoi trovare tutto il codice sorgente utilizzato nella guida su Github.

Ciclo di vita dell'invio di un'e-mail tramite AWS SES

Diamo un'occhiata a come il ciclo di vita di un messaggio di posta elettronica inviato da un'applicazione raggiunge la casella di posta di destinazione:

• Un'applicazione, nel nostro caso, il codice Spring Cloud richiede ad AWS SES di inviare un'e-mail a uno o più destinatari.

• SES verifica inizialmente la richiesta e, se approvata, produce un messaggio di posta elettronica con le specifiche della richiesta. Questo messaggio di posta elettronica ha un'intestazione, un corpo e una busta ed è conforme a RFC 5322definizione del formato dei messaggi Internet di .

• SES trasmette quindi il messaggio al destinatario del destinatario tramite Internet. Non appena il messaggio viene consegnato a SES, viene spesso trasmesso immediatamente, con il tentativo di consegna iniziale che avviene in genere in pochi millisecondi.

• Ci sono diversi risultati in questo momento. Per esempio:

  • Consegna riuscita: il provider di servizi Internet (ISP) accetta l'e-mail e la invia al destinatario previsto.
  • Rimbalzo duro: Poiché l'indirizzo del destinatario non è valido, l'ISP rifiuta l'e-mail. L'ISP invia la notifica di hard bounce ad Amazon SES, che invia una notifica al mittente tramite e-mail o pubblicandola in un argomento Amazon Simple Notification Service (Amazon SNS) configurato per ricevere questa notifica.
  • Rimbalzo morbido: A causa di condizioni come la casella di posta del destinatario piena, il dominio non esistente o qualsiasi circostanza transitoria come l'ISP troppo occupato per elaborare la richiesta, l'ISP potrebbe non essere in grado di consegnare l'e-mail al destinatario. L'ISP quindi riprova l'e-mail fino a un certo numero di volte e invia a SES un messaggio di mancato recapito. Se SES non è in grado di consegnare l'e-mail entro il periodo di tempo specificato, pubblica l'evento in un argomento SNS o invia un messaggio di hard bounce via e-mail.
  • Denuncia: L'e-mail viene classificata come spam dal destinatario nel proprio programma di posta elettronica. Una notifica di reclamo viene trasmessa ad Amazon SES, che poi la inoltra al mittente se Amazon SES e l'ISP hanno stabilito un ciclo di feedback.
  • Autorisposta: l'ISP del destinatario notifica ad Amazon SES una risposta automatica dal destinatario, ad esempio un avviso di assenza dall'ufficio, e Amazon SES trasmette la notifica al mittente.

Quando la consegna non va a buon fine, Amazon SES restituisce un errore al mittente ed elimina l'e-mail.

Configurazione di Amazon SES

A differenza di qualsiasi altro servizio AWS, non è praticamente necessario creare un'istanza SES poiché tutti i nuovi account AWS vengono inseriti nella sandbox AWS SES per impostazione predefinita. Ogni account AWS ha accesso sandbox per AWS SES nelle regioni disponibili per impostazione predefinita.

Quando si utilizza la modalità sandbox, possiamo inviare e-mail solo a identità verificate. Un dominio o un indirizzo e-mail che utilizziamo per inviare un'e-mail è un'identità verificata. Dobbiamo costruire e convalidare ogni identità che intendiamo usare come a From, To, Source, Sender, o Return-Path indirizzo prima di poter inviare un'e-mail utilizzando SES in modalità sandbox. Utilizzando Amazon SES per verificare l'identità, possiamo provare la nostra proprietà e fermare l'uso illegale.

Per evitare frodi e preservare la reputazione di un indirizzo IP, AWS SES include limiti di invio di e-mail. Queste limitazioni specificano il numero massimo di e-mail al secondo e il limite giornaliero di e-mail per ciascun utente. Contattando l'AWS Support Center, potremmo stabilire tali quote per regione.

Verifichiamo le identità. Accedi alla console AWS e cerca "Servizio di posta elettronica semplice Amazon"

Quindi fare clic su "Crea identità” per aggiungere un indirizzo email o un dominio per la verifica. Nel nostro caso, aggiungeremo un'e-mail per la verifica.

Una volta creata l'identità, possiamo verificare i dettagli.

L'identità che abbiamo creato entra in "In attesa di verifica" palcoscenico. In questa fase, l'utente deve controllare l'e-mail di verifica da AWS e seguire le istruzioni per ottenere la verifica dell'e-mail.

Successivamente, dobbiamo recuperare "chiave di accesso" e "chiave segreta” per l'autenticazione e l'autorizzazione della nostra applicazione con SES. Per generarlo, dobbiamo creare un gruppo di utenti e aggiungere un utente a quel gruppo. Quando creiamo quell'utente, AWS genera una chiave di accesso e una chiave segreta. Quindi reindirizziamo a "IAM” nella console AWS e crea un gruppo di utenti.

Quindi dobbiamo aggiungere "Accesso amministratore” autorizzazione a quel gruppo per SES.

Infine, aggiungeremo un utente al gruppo sopra.

Successivamente, dobbiamo selezionare il gruppo per le autorizzazioni.

Infine, copia la chiave di accesso e la chiave segreta visualizzate sullo schermo per un ulteriore utilizzo.

Invio di e-mail tramite Spring Cloud Project

Impostazione del progetto

Avviamo un progetto Spring Cloud ed esaminiamo i casi d'uso per l'integrazione con SES. Il modo più semplice per iniziare con un progetto scheletro è tramite Inizializzazione di primavera:

Abbiamo aggiunto Primavera Web per RIPOSO MVC, Apache Freemarker per generare modelli di email basati su HTML, Mittente di posta Java per inviare un'e-mail e Chili (libreria di riduzione boilerplate opzionale) dipendenze. Inoltre, dobbiamo aggiungere dipendenze rilevanti per Spring Cloud AWS e SES. Per Spring Cloud AWS, aggiungeremo una distinta base separata per Spring Cloud AWS nel nostro pom.xml file utilizzando questo bloccare:

<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>

Infine, per aggiungere il supporto per SES, dobbiamo includere la dipendenza dal modulo che è disponibile come modulo iniziale spring-cloud-starter-aws-ses:

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

spring-cloud-starter-aws-ses include le dipendenze transitive per spring-cloud-starter-awse spring-cloud-aws-ses. spring-cloud-aws-ses Il modulo per SES contiene due classi: SimpleEmailServiceMailSender ed SimpleEmailServiceJavaMailSender.

• I SimpleEmailServiceMailSender class utilizza Amazon Simple Email Service per inviare e-mail. L'API Java Mail non è un requisito per questa implementazione. Può essere utilizzato per inviare messaggi di posta diretti privi di allegati.
• I SimpleEmailServiceJavaMailSender class abilita l'invio di email che contengono allegati e altri elementi mime.

Quindi questo copre tutti i nostri requisiti di base!

Configurazione dei fagioli

Come discusso sopra, dobbiamo definire due tipi di bean: SimpleEmailServiceMailSender ed SimpleEmailServiceJavaMailSender. Possiamo semplicemente passare la chiave di accesso e la chiave segreta come credenziali e configurare a MailSender bean che useremo per inviare email:

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

Per inviare e-mail con allegati è necessario configurare il file SimpleEmailServiceJavaMailSender che è un'implementazione del JavaMailSender interfaccia dall'astrazione della posta di Spring.

Definiremo anche le proprietà da cui recuperare le informazioni application.yml:

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

Invio di e-mail semplice

Possiamo inviare semplici e-mail utilizzando il SimpleEmailServiceMailSender bean che abbiamo configurato sopra. Definiamo un livello di servizio per utilizzare questo bean:

@Service
public class EmailService {

    @Autowired
    private MailSender mailSender;

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

Stiamo chiamando il send() metodo in MailSender bean per inviare la nostra email. Dobbiamo anche passare il SimpleMailMessage che conterrebbe attributi come from, to, il testo e l'oggetto della nostra email. Quindi, definiamo a Controller class per chiamare il servizio precedente utilizzando un'API REST:

@RestController
public class EmailController {

    @Autowired
    private EmailService emailService;

    @PostMapping("/sendEmail")
    public String sendMessage(@RequestBody EmailDetails emailDetails) {
        SimpleMailMessage simpleMailMessage = new SimpleMailMessage();
        simpleMailMessage.setFrom(emailDetails.getFromEmail());
        simpleMailMessage.setTo(emailDetails.getToEmail());
        simpleMailMessage.setSubject(emailDetails.getSubject());
        simpleMailMessage.setText(emailDetails.getBody());
        emailService.sendMessage(simpleMailMessage);

        return "Email sent successfully";
    }
}

Ora, se eseguiamo l'applicazione ed eseguiamo il seguente curl, invierà un'e-mail all'indirizzo e-mail verificato:

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'

Successivamente, possiamo accedere all'indirizzo di posta del destinatario e verificare se il destinatario ha ricevuto l'e-mail.

Invio di semplice e-mail con allegato

Definiremo un livello di servizio per passare l'allegato come mime e impostare gli altri attributi di posta elettronica come from, to, testo e oggetto:

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

Qui stiamo usando MimeMessageHelper per creare un'e-mail con un allegato. Infine, definiremo Controller strato per passare il SimpleMailMessage attributi:

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

Ora, se eseguiamo l'applicazione ed eseguiamo il seguente curl, invierà un'e-mail all'indirizzo e-mail verificato:

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'

Successivamente, possiamo accedere all'indirizzo di posta del destinatario e verificare se il destinatario ha ricevuto l'e-mail.

Invio modello e-mail con allegato

I casi d'uso precedenti che abbiamo visto sono utili per scenari di sviluppo o test, ma in produzione generalmente utilizziamo un modello di posta elettronica con variabili che verrebbero sostituite utilizzando le risposte di un'API. In precedenza avevamo aggiunto la dipendenza per Apache Freemarker. Lo useremo per definire un modello e caricarlo per l'elaborazione!

Per questo, definiamo prima un modello semplice, chiamandolo come email-template.ftl e posizionalo dentro templates cartella sotto 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>

Successivamente, dobbiamo definire una classe di configurazione per caricare il modello dal percorso e aggiungerlo come bean. Per questo, definiremo FreeMarkerConfigurationFactoryBean:

@Configuration
public class FreemarkerConfig {

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

Successivamente, definiremo il nostro livello di servizio per caricare questo modello e creare un messaggio finale da inviare a 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());
        }
    }

Infine, definiremo a Controller livello per trasmettere gli attributi dinamici dell'e-mail:

@RestController
public class EmailController {

    @Autowired
    private EmailService emailService;

    @PostMapping("/sendTemplateEmailWithAttachment")
    public String sendTemplateMessageWithAttachment(@RequestBody EmailDetails emailDetails) {
        SimpleMailMessage simpleMailMessage = new SimpleMailMessage();
        simpleMailMessage.setFrom(emailDetails.getFromEmail());
        simpleMailMessage.setTo(emailDetails.getToEmail());
        simpleMailMessage.setSubject(emailDetails.getSubject());
        simpleMailMessage.setText(emailDetails.getBody());
        emailService.sendTemplateMessageWithAttachment(simpleMailMessage);

        return "Email sent successfully";
    }
}

Ora, se eseguiamo l'applicazione ed eseguiamo il seguente curl, invierà un'e-mail all'indirizzo e-mail verificato:

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'

Successivamente, possiamo accedere all'indirizzo di posta del destinatario e verificare se il destinatario ha ricevuto l'e-mail:

Invio di e-mail personalizzate utilizzando i modelli in AWS SES

Nel caso d'uso precedente abbiamo utilizzato un modello statico per inviare e-mail. Come possiamo consentire la progettazione dinamica dei modelli per scopi diversi e diversi tipi di destinatari? AWS SES ci consente di creare modelli di email per inviare email personalizzate a una o più destinazioni in un'unica operazione.

Possiamo creare fino a 10,000 modelli di email per account Amazon SES. Ogni modello può avere una dimensione massima di 500 KB, incluse le parti di testo e HTML. Possiamo inviare fino a 50 destinazioni in ogni chiamata.

Quindi creiamo rapidamente un modello di email. Innanzitutto, possiamo definire un file JSON utilizzando il seguente modello:

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

Questo modello contiene i seguenti attributi:

• Nome modello: contiene il nome del modello.
• SoggettoParte: Contiene la riga dell'oggetto dell'e-mail. I tag sostitutivi potrebbero essere presenti su questa risorsa. Questi tag sono formattati come segue: {{tagname}}. È possibile inserire un valore per {{tagname}} per ogni destinazione quando si invia l'e-mail.
• HtmlPart: contiene il corpo HTML dell'e-mail e può contenere anche tag sostitutivi.
• TestoParte: Rappresenta il corpo del testo dell'e-mail. Questa versione dell'e-mail viene inviata ai destinatari i cui client di posta elettronica non visualizzano le e-mail HTML. I tag sostitutivi potrebbero essere presenti su questa risorsa.

Possiamo salvare questo file come mytemplate.json. Infine possiamo utilizzare un comando AWS CLI per creare il modello come segue:

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

Successivamente, definiamo un livello di servizio per definire gli attributi e inviare e-mail basate su modelli:

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

Possiamo aggiungere più Destination indirizzi per inviare e-mail in blocco a più destinatari. Stiamo usando il sendTemplatedEmail() metodo dal AmazonSimpleEmailService interfaccia per inviare questo modello di email. Abbiamo anche bisogno di passare i tag di sostituzione da sostituire nel testo HTML del nostro modello che abbiamo creato in precedenza.

Infine, definiremo a Controller layer per definire l'API REST per passare gli attributi:

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

Successivamente, quando eseguiamo l'app, possiamo eseguire quanto segue curl per inviare e-mail basate su modelli:

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'

Ora il destinatario può finalmente vedere un'e-mail basata su modello:

Richiedi l'accesso alla produzione

Infine, per inviare e-mail a qualsiasi destinatario, indipendentemente dal fatto che l'indirizzo o il dominio del destinatario sia convalidato, alla fine dobbiamo rimuovere il nostro account dalla sandbox. Tutte le nostre identità, incluso From, Source, Sendere Return-Path indirizzi, devono ancora essere verificati. Possiamo inviare una richiesta di accesso alla produzione dal "Account Dashboard” pagina come segue:

Possiamo inviare la richiesta compilando tutti i dettagli di cui sopra dalla console AWS. Lo stesso può essere inviato anche tramite AWS CLI. Ciò sarebbe utile quando è necessario richiedere l'accesso per un numero elevato di identità e si desidera automatizzare il processo.

Conclusione

Le idee chiave di Amazon Simple Email Service (SES) e le librerie offerte da Spring Cloud AWS per interfacciarsi con esso sono state trattate in questo articolo. Inoltre, abbiamo creato un'applicazione Spring Boot con un'API REST in grado di inviare e-mail tramite il modulo Spring Cloud AWS SES.

Ora dovresti avere una solida conoscenza di cos'è Amazon Simple Email Service (SES) e di come utilizzarlo per inviare e-mail.