Guía de Simple Email Service (AWS SES) con Spring Boot y Spring Cloud

Introducción

AWS SES (Servicio de correo electrónico simple) es un servicio de envío y recepción de correo electrónico fácil de configurar. Por lo general, es difícil, quisquilloso y tedioso administrar un sistema de correo electrónico en las instalaciones, por lo que la externalización del proceso es una opción popular.

Podemos utilizar Amazon SES para enviar correos electrónicos transaccionales, correos electrónicos de marketing o cualquier otro tipo de correo electrónico de notificación a nuestros clientes. Es una solución asequible para empresas de todos los tamaños que usan correos electrónicos para conectarse con sus clientes, ya que se basa en la infraestructura confiable y escalable de Servicios Web de Amazon (AWS).

Para el envío masivo de correos electrónicos, cualquier aplicación puede interactuar con Amazon SES. Solo pagamos por los correos electrónicos que enviamos, ya sean correos electrónicos transaccionales o de marketing. Además, Amazon SES admite una variedad de configuraciones, incluidas direcciones IP dedicadas, compartidas o propias. Las empresas pueden hacer que cada correo electrónico cuente con el uso de paneles de entrega e informes sobre la información del remitente.

En esta guía, configuraremos una instancia de AWS SES en una región y luego la integraremos con Nube de primavera para AWS que es un subproyecto de Nube de primavera. Probaremos diferentes escenarios para enviar correos electrónicos desde nuestra aplicación.

Nota: Puede encontrar todo el código fuente utilizado en la guía en Github.

Ciclo de vida del envío de un correo electrónico mediante AWS SES

Veamos cómo el ciclo de vida de un correo electrónico enviado por una aplicación llega al buzón de destino:

• Una aplicación, en nuestro caso, el código de Spring Cloud solicita a AWS SES que envíe un correo electrónico a uno o más destinatarios.

• SES verifica inicialmente la solicitud y, si se aprueba, produce un mensaje de correo electrónico con las especificaciones de la solicitud. Este mensaje de correo electrónico tiene un encabezado, cuerpo y sobre y cumple con RFC 5322Definición de formato de mensaje de Internet.

• SES luego transmite el mensaje al receptor del destinatario a través de Internet. Tan pronto como el mensaje se entrega a SES, a menudo se transmite de inmediato, y el intento de entrega inicial generalmente se lleva a cabo en cuestión de milisegundos.

• Hay varios resultados en este momento. Por ejemplo:

  • Entrega exitosa: El proveedor de servicios de Internet (ISP) acepta el correo electrónico y lo envía al destinatario previsto.
  • Rebote duro: Debido a que la dirección del destinatario no es válida, el ISP rechaza el correo electrónico. El ISP devuelve la notificación de rebote permanente a Amazon SES, que notifica al remitente por correo electrónico o mediante su publicación en un tema de Amazon Simple Notification Service (Amazon SNS) configurado para recibir esta notificación.
  • Rebote suave: debido a condiciones como que la bandeja de entrada del destinatario esté llena, el dominio no exista o cualquier circunstancia pasajera, como que el ISP esté demasiado ocupado para procesar la solicitud, es posible que el ISP no pueda entregar el correo electrónico al destinatario. Luego, el ISP vuelve a intentar el correo electrónico hasta un cierto número de veces y envía a SES un mensaje de rebote suave. Si SES no puede entregar el correo electrónico dentro del período de tiempo especificado, publica el evento en un tema de SNS o envía un mensaje de rebote permanente por correo electrónico.
  • Queja: El correo electrónico es clasificado como spam por el receptor en su programa de correo electrónico. Se transmite una notificación de queja a Amazon SES, que luego la transmite al remitente si Amazon SES y el ISP tienen establecido un circuito de retroalimentación.
  • Respuesta automática: el ISP del destinatario notifica a Amazon SES de una respuesta automática del receptor, como un aviso de fuera de la oficina, y Amazon SES pasa la notificación al remitente.

Cuando la entrega no se realiza correctamente, Amazon SES devuelve un error al remitente y elimina el correo electrónico.

Configuración de Amazon SES

A diferencia de cualquier otro servicio de AWS, prácticamente no es necesario crear una instancia de SES, ya que todas las cuentas nuevas de AWS se colocan en el entorno de pruebas de AWS SES de forma predeterminada. Cada cuenta de AWS tiene acceso a la zona de pruebas para AWS SES en las regiones disponibles de forma predeterminada.

Cuando usamos el modo sandbox, solo podemos enviar correos electrónicos a identidades verificadas. Un dominio o dirección de correo electrónico que usamos para enviar un correo electrónico es una identidad verificada. Debemos construir y validar cada identidad que pretendemos utilizar como From, To, Source, Sendero Return-Path antes de que podamos enviar un correo electrónico usando SES en modo sandbox. Al usar Amazon SES para verificar la identidad, podemos probar nuestra propiedad y detener el uso ilegal.

Para evitar el fraude y preservar la reputación de una dirección IP, AWS SES incluye límites de envío de correo electrónico. Estas limitaciones especifican la cantidad máxima de correos electrónicos por segundo y el límite de correo electrónico diario para cada usuario. Al ponernos en contacto con el Centro de soporte de AWS, podemos establecer dichas cuotas por región.

Verifiquemos identidades. Inicie sesión en la consola de AWS y busque "Servicio de correo electrónico simple de Amazon"

Luego haz clic en "Crear identidad” para agregar un correo electrónico o un dominio para la verificación. En nuestro caso, vamos a agregar un correo electrónico para la verificación.

Una vez creada la identidad, podemos verificar los detalles.

La identidad que creamos entra en “Verificación pendiente" escenario. En esta etapa, el usuario debe verificar el correo de verificación de AWS y seguir las instrucciones para verificar el correo electrónico.

A continuación, tenemos que buscar "llave de acceso y llave secreta” para la autenticación y autorización de nuestra aplicación con SES. Para generar eso, necesitamos crear un grupo de usuarios y agregar un usuario a ese grupo. Cuando creamos ese Usuario, AWS genera una clave de acceso y una clave secreta. Así que vamos a redirigir a “AMI” en la consola de AWS y cree un grupo de usuarios.

Entonces necesitamos agregar “AdministradorAcceso” permiso a ese grupo para SES.

Finalmente, agregaremos un Usuario al grupo anterior.

A continuación, debemos seleccionar el grupo para los permisos.

Finalmente, copie la clave de acceso y la clave secreta que se muestran en la pantalla para su uso posterior.

Envío de correos electrónicos usando Spring Cloud Project

Configuración del proyecto

Iniciemos un proyecto de Spring Cloud y analicemos los casos de uso para integrarlo con SES. La forma más fácil de comenzar con un proyecto de esqueleto es a través de Primavera Initializr:

Hemos añadido Telaraña de primavera para resto mvc, Marcador libre de Apache para generar plantillas de correo electrónico basadas en HTML, Remitente de correo Java para enviar un correo electrónico y Lombok (biblioteca reductora de repeticiones opcional) dependencias. Además, necesitamos agregar dependencias relevantes para Spring Cloud AWS y SES. Para Spring Cloud AWS, agregaremos un BOM de Spring Cloud AWS separado en nuestro pom.xml archivo usando este bloque:

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

Finalmente, para agregar el soporte para SES, debemos incluir la dependencia del módulo que está disponible como módulo de inicio. spring-cloud-starter-aws-ses:

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

spring-cloud-starter-aws-ses incluye las dependencias transitivas para spring-cloud-starter-awsy spring-cloud-aws-ses. spring-cloud-aws-ses módulo para SES contiene dos clases: SimpleEmailServiceMailSender y SimpleEmailServiceJavaMailSender.

• El SimpleEmailServiceMailSender class utiliza Amazon Simple Email Service para enviar correos electrónicos. La API de correo de Java no es un requisito para esta implementación. Puede usarse para enviar mensajes de correo sencillos sin archivos adjuntos.
• El SimpleEmailServiceJavaMailSender La clase permite el envío de correos electrónicos que contienen archivos adjuntos y otros elementos MIME.

¡Así que esto cubre todos nuestros requisitos básicos!

Configuración de frijoles

Como se discutió anteriormente, necesitamos definir dos tipos de frijoles: SimpleEmailServiceMailSender y SimpleEmailServiceJavaMailSender. Simplemente podemos pasar la clave de acceso y la clave secreta como credenciales y configurar un MailSender bean que usaremos para enviar correos electrónicos:

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

Para enviar correos electrónicos con archivos adjuntos, debemos configurar el SimpleEmailServiceJavaMailSender que es una implementación del JavaMailSender interfaz de la abstracción de correo de Spring.

También definiremos las propiedades para recuperar la información de application.yml:

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

Envío de correo electrónico sencillo

Podemos enviar correos electrónicos simples usando el SimpleEmailServiceMailSender bean que configuramos arriba. Definamos una capa de servicio para usar este bean:

@Service
public class EmailService {

    @Autowired
    private MailSender mailSender;

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

Estamos llamando al send() método en el MailSender bean para enviar nuestro correo electrónico. También tenemos que pasar el SimpleMailMessage que contendría atributos como from, to, el texto y el asunto de nuestro correo electrónico. Entonces, definamos un Controller class para llamar al servicio anterior usando una 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";
    }
}

Ahora, si ejecutamos la aplicación y ejecutamos el siguiente curl, enviará un correo electrónico a la dirección de correo electrónico verificada:

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'

A continuación, podemos iniciar sesión en la dirección de correo del destinatario y verificar si el destinatario ha recibido el correo electrónico.

Envío de correo electrónico simple con archivo adjunto

Definiremos una capa de servicio para pasar el archivo adjunto como mimo y estableceremos los otros atributos de correo electrónico como from, to, texto y asunto:

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

Aquí estamos usando MimeMessageHelper para crear un correo electrónico con un archivo adjunto. Finalmente, definiremos Controller capa para pasar el SimpleMailMessage atributos:

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

Ahora, si ejecutamos la aplicación y ejecutamos el siguiente curl, enviará un correo electrónico a la dirección de correo electrónico verificada:

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'

A continuación, podemos iniciar sesión en la dirección de correo del destinatario y verificar si el destinatario ha recibido el correo electrónico.

Envío de plantilla de correo electrónico con archivo adjunto

Los casos de uso anteriores que habíamos visto son buenos para escenarios de desarrollo o prueba, pero en producción, generalmente usamos una plantilla de correo electrónico con variables que se reemplazarían usando las respuestas de una API. Anteriormente habíamos agregado la dependencia para Marcador libre de Apache. ¡Lo usaremos para definir una plantilla y cargarla para procesar!

Para esto, primero definamos una plantilla simple, asígnele el nombre email-template.ftl y colocarlo en templates carpeta debajo 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>

A continuación, debemos definir una clase de configuración para cargar la plantilla desde la ruta y agregarla como bean. Para ello definiremos FreeMarkerConfigurationFactoryBean:

@Configuration
public class FreemarkerConfig {

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

A continuación, definiremos nuestra capa de servicio para cargar esta plantilla y crear un mensaje final para enviar 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());
        }
    }

Finalmente, definiremos un Controller capa para pasar los atributos de correo electrónico dinámico:

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

Ahora, si ejecutamos la aplicación y ejecutamos el siguiente curl, enviará un correo electrónico a la dirección de correo electrónico verificada:

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'

A continuación, podemos iniciar sesión en la dirección de correo del destinatario y verificar si el destinatario ha recibido el correo electrónico:

Envío de correo electrónico personalizado mediante plantillas en AWS SES

En el caso de uso anterior, usamos una plantilla estática para enviar correos electrónicos. ¿Cómo podemos permitir que las plantillas se diseñen dinámicamente para diferentes propósitos y diferentes tipos de destinatarios? AWS SES nos permite crear plantillas de correo electrónico para enviar correos electrónicos personalizados a uno o más destinos en una sola operación.

Podemos crear hasta 10,000 500 plantillas de correo electrónico por cuenta de Amazon SES. Cada plantilla puede tener un tamaño de hasta 50 KB, incluidas las partes de texto y HTML. Podemos enviar hasta XNUMX destinos en cada llamada.

Así que vamos a crear rápidamente una plantilla de correo electrónico. Primero, podemos definir un archivo JSON usando la siguiente plantilla:

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

Esta plantilla contiene los siguientes atributos:

• Nombre de la plantilla: Contiene el nombre de la plantilla.
• AsuntoParte: Contiene la línea de asunto del correo electrónico. Es posible que haya etiquetas de reemplazo en este recurso. Estas etiquetas tienen el siguiente formato: {{tagname}}. Puede introducir un valor para {{tagname}} para cada destino al enviar el correo electrónico.
• Parte Html: Contiene el cuerpo HTML del correo electrónico y también puede contener etiquetas de reemplazo.
• ParteTexto: Esto representa el cuerpo del texto del correo electrónico. Esta versión del correo electrónico se envía a destinatarios cuyos clientes de correo electrónico no ven correos electrónicos HTML. Es posible que haya etiquetas de reemplazo en este recurso.

Podemos guardar este archivo como mytemplate.json. Finalmente, podemos usar un comando de AWS CLI para crear la plantilla de la siguiente manera:

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

A continuación, definamos una capa de servicio para definir atributos y enviar correos electrónicos con plantillas:

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

Podemos agregar varios Destination direcciones para enviar correos electrónicos masivos a múltiples destinatarios. estamos usando el sendTemplatedEmail() método del AmazonSimpleEmailService interfaz para enviar este correo electrónico con plantilla. También necesitamos pasar las etiquetas de reemplazo para ser reemplazadas en el texto HTML de nuestra plantilla que creamos anteriormente.

Finalmente, definiremos un Controller capa para definir la API REST para pasar los atributos:

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

A continuación, cuando ejecutamos la aplicación, podemos ejecutar lo siguiente curl para enviar correos electrónicos con plantillas:

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'

Ahora el destinatario finalmente puede ver un correo electrónico con plantilla:

Solicitar acceso a producción

Finalmente, para poder enviar correos electrónicos a cualquier destinatario, independientemente de si la dirección o el dominio del destinatario están validados, en última instancia debemos sacar nuestra cuenta de la caja de arena. Todas nuestras identidades, incluyendo From, Source, Sendery Return-Path direcciones, aún deben ser verificadas. Podemos enviar una solicitud de acceso a Producción desde el “Cuenta Dashboard” página de la siguiente manera:

Podemos enviar la solicitud completando todos los detalles anteriores desde la consola de AWS. Lo mismo también se puede enviar mediante AWS CLI. Esto sería útil cuando necesitemos solicitar acceso para una gran cantidad de identidades y nos gustaría automatizar el proceso.

Conclusión

En este artículo se trataron las ideas clave de Amazon Simple Email Service (SES) y las bibliotecas que ofrece Spring Cloud AWS para interactuar con él. Además, creamos una aplicación Spring Boot con una API REST que puede enviar correos electrónicos a través del módulo Spring Cloud AWS SES.

Ahora debería tener una comprensión sólida de lo que es Amazon Simple Email Service (SES) y cómo utilizarlo para enviar correos electrónicos.