Guia para o Simple Email Service (AWS SES) com Spring Boot e Spring Cloud

Introdução

AWS SES (Serviço de e-mail simples) é um serviço de envio e recebimento de e-mail simples de configurar. Geralmente é difícil, meticuloso e tedioso gerenciar um sistema de e-mail local, portanto, terceirizar o processo é uma escolha popular.

Podemos usar o Amazon SES para enviar e-mails transacionais, e-mails de marketing ou qualquer outro tipo de e-mail de notificação para nossos clientes. É uma solução acessível para empresas de todos os tamanhos que usam e-mails para se conectar com seus clientes, pois é construída sobre a infraestrutura confiável e escalável de Amazon Web Services (AWS).

Para enviar e-mails em massa, qualquer aplicativo pode interagir com o Amazon SES. Pagamos apenas pelos e-mails que realmente enviamos, sejam eles e-mails transacionais ou e-mails de marketing. Além disso, uma variedade de configurações, incluindo endereços IP dedicados, compartilhados ou próprios, são compatíveis com o Amazon SES. As empresas podem fazer valer cada e-mail com o uso de painéis de entregabilidade e relatórios sobre as informações do remetente.

Neste guia, vamos configurar uma instância do AWS SES em uma região e, em seguida, integrar com Spring Cloud para AWS que é um subprojeto de nuvem de primavera. Vamos experimentar diferentes cenários para enviar e-mails do nosso aplicativo.

Observação: Você pode encontrar todo o código-fonte usado no guia em Github.

Ciclo de vida do envio de um e-mail usando o AWS SES

Vejamos como o ciclo de vida de um email enviado por um aplicativo chega à caixa de correio de destino:

• Um aplicativo, no nosso caso, o código Spring Cloud solicita que o AWS SES envie um e-mail para um ou mais destinatários.

• O SES verifica inicialmente a solicitação e, caso seja aprovada, produz uma mensagem de e-mail com as especificações da solicitação. Esta mensagem de e-mail tem cabeçalho, corpo e envelope e está em conformidade com RFC 5322definição de formato de mensagem da Internet.

• O SES então transmite a mensagem para o receptor do destinatário pela Internet. Assim que a mensagem é entregue ao SES, geralmente é transmitida imediatamente, com a tentativa de entrega inicial geralmente ocorrendo em questão de milissegundos.

• Existem vários resultados neste momento. Por exemplo:

  • Entrega bem-sucedida: O provedor de serviços de Internet (ISP) aceita o e-mail e o envia ao destinatário pretendido.
  • Salto forte: como o endereço do destinatário é inválido, o ISP rejeita o e-mail. O ISP envia a notificação de devolução definitiva ao Amazon SES, que notifica o remetente por e-mail ou publicando-a em um tópico do Amazon Simple Notification Service (Amazon SNS) configurado para receber essa notificação.
  • Salto suave: devido a condições como a caixa de entrada do destinatário estar cheia, o domínio não existir ou qualquer circunstância passageira, como o ISP estar muito ocupado para processar a solicitação, o ISP pode não conseguir entregar o e-mail ao destinatário. O ISP então repete o e-mail até um certo número de vezes e envia ao SES uma mensagem de devolução suave. Se o SES não conseguir entregar o e-mail dentro do prazo especificado, ele publicará o evento em um tópico do SNS ou enviará uma mensagem de devolução definitiva por e-mail.
  • Queixa: O e-mail é classificado como spam pelo destinatário em seu programa de e-mail. Uma notificação de reclamação é transmitida ao Amazon SES, que a retransmite ao remetente se o Amazon SES e o ISP tiverem um ciclo de feedback estabelecido.
  • Resposta Automática: o ISP destinatário notifica o Amazon SES sobre uma resposta automática do destinatário, como um aviso de ausência temporária, e o Amazon SES passa a notificação ao remetente.

Quando a entrega não é bem-sucedida, o Amazon SES retorna um erro ao remetente e exclui o e-mail.

Configurando o Amazon SES

Ao contrário de qualquer outro serviço da AWS, praticamente não há necessidade de criar uma instância do SES, pois todas as novas contas da AWS são colocadas na sandbox do AWS SES por padrão. Cada conta da AWS tem acesso sandbox para AWS SES nas regiões disponíveis por padrão.

Ao usar o modo sandbox, só podemos enviar e-mails para identidades verificadas. Um domínio ou endereço de e-mail que usamos para enviar um e-mail é uma identidade verificada. Devemos construir e validar cada identidade que pretendemos usar como From, To, Source, Senderou Return-Path endereço antes que possamos enviar um e-mail usando SES no modo sandbox. Ao usar o Amazon SES para verificar a identidade, podemos provar nossa propriedade e interromper o uso ilegal.

Para evitar fraudes e preservar a reputação de um endereço IP, o AWS SES inclui limites de envio de e-mail. Essas limitações especificam o número máximo de emails por segundo e o limite diário de emails para cada usuário. Ao entrar em contato com o AWS Support Center, podemos estabelecer essas cotas por região.

Vamos verificar as identidades. Faça login no Console AWS e pesquise por “Serviço de e-mail simples da Amazon"

Então clique em “Criar Identidade” para adicionar um e-mail ou domínio para verificação. No nosso caso, vamos adicionar um e-mail para verificação.

Uma vez que a identidade é criada, podemos verificar os detalhes.

A identidade que criamos vai para “Verificação pendente" palco. Nesse estágio, o usuário precisa verificar o e-mail de verificação da AWS e seguir as instruções para verificar o e-mail.

Em seguida, precisamos buscar “chave de acesso"E"chave secreta” para a autenticação e autorização de nosso aplicativo com SES. Para gerar isso, precisamos criar um grupo de usuários e adicionar um usuário a esse grupo. Quando criamos esse usuário, a AWS gera uma chave de acesso e uma chave secreta. Então vamos redirecionar para “IAM” no Console AWS e crie um grupo de usuários.

Então precisamos adicionar “Acesso de administrador” permissão para esse grupo para SES.

Por fim, adicionaremos um usuário ao grupo acima.

Em seguida, precisamos selecionar o grupo para permissões.

Finalmente, copie a chave de acesso e a chave secreta exibidas na tela para uso posterior.

Enviando e-mails usando o Spring Cloud Project

Configuração do Projeto

Vamos criar um projeto Spring Cloud e percorrer os casos de uso para integrar com o SES. A maneira mais fácil de começar com um projeto esqueleto é via Spring Initializer:

Nós adicionamos Primavera Web para REST MVC, Apache FreemarkerName para gerar modelos de e-mail baseados em HTML, Java Mail Remetente para enviar um e-mail e Lombok (biblioteca de redução de clichê opcional). Além disso, precisamos adicionar dependências relevantes para Spring Cloud AWS e SES. Para Spring Cloud AWS, adicionaremos uma BOM Spring Cloud AWS separada em nosso pom.xml arquivo usando este quadra:

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

Por fim, para adicionar o suporte para SES, precisamos incluir a dependência do módulo que está disponível como módulo inicial spring-cloud-starter-aws-ses:

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

spring-cloud-starter-aws-ses inclui as dependências transitivas para spring-cloud-starter-aws e spring-cloud-aws-ses. O spring-cloud-aws-ses módulo para SES contém duas classes: SimpleEmailServiceMailSender e SimpleEmailServiceJavaMailSender.

• A SimpleEmailServiceMailSender class utiliza o Amazon Simple Email Service para enviar e-mails. A API Java Mail não é um requisito para esta implementação. Ele pode ser usado para enviar mensagens de correio diretas sem anexos.
• A SimpleEmailServiceJavaMailSender class habilita o envio de emails que contêm anexos e outros elementos mime.

Portanto, isso cobre todos os nossos requisitos básicos!

Configurando Beans

Como discutido acima, precisamos definir dois tipos de beans: SimpleEmailServiceMailSender e SimpleEmailServiceJavaMailSender. Podemos simplesmente passar a chave de acesso e a chave secreta como credenciais e configurar um MailSender bean que usaremos para enviar e-mails:

@Configuration
public class SesConfig {

    @Value("${cloud.aws.credentials.access-key}")
    private String accessKey;

    @Value("${cloud.aws.credentials.secret-key}")
    private String secretKey;

    @Value("${cloud.aws.region.static}")
    private String region;

    @Bean
    public AmazonSimpleEmailService amazonSimpleEmailService() {
        BasicAWSCredentials credentials = new BasicAWSCredentials(accessKey, secretKey);
        return AmazonSimpleEmailServiceClientBuilder.standard()
                .withCredentials(new AWSStaticCredentialsProvider(credentials))
                .withRegion(region)
                .build();
    }

    @Bean
    public MailSender mailSender(AmazonSimpleEmailService amazonSimpleEmailService) {
        return new SimpleEmailServiceMailSender(amazonSimpleEmailService);
    }

    @Bean
    public JavaMailSender javaMailSender(AmazonSimpleEmailService amazonSimpleEmailService) {
        return new SimpleEmailServiceJavaMailSender(amazonSimpleEmailService);
    }
}

Para enviar e-mails com anexos, precisamos configurar o SimpleEmailServiceJavaMailSender que é uma implementação do JavaMailSender interface da abstração de correio do Spring.

Também definiremos as propriedades para recuperar as informações de application.yml:

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

Envio de e-mail simples

Podemos enviar e-mails simples usando o SimpleEmailServiceMailSender bean que configuramos acima. Vamos definir uma camada de serviço para usar este bean:

@Service
public class EmailService {

    @Autowired
    private MailSender mailSender;

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

Estamos chamando o send() método no MailSender bean para enviar nosso e-mail. Também precisamos passar o SimpleMailMessage que conteria atributos como from, to, o texto e o assunto do nosso e-mail. Então, vamos definir um Controller class para chamar o serviço acima usando uma 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";
    }
}

Agora, se executarmos o aplicativo e executarmos o seguinte curl, ele enviará um e-mail para o endereço de e-mail verificado:

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'

Em seguida, podemos fazer login no endereço de e-mail do destinatário e verificar se o destinatário recebeu o e-mail.

Enviando e-mail simples com anexo

Vamos definir uma camada de serviço para passar o anexo como mime e definir os outros atributos de email como from, to, texto e assunto:

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

Aqui estamos usando MimeMessageHelper para criar um e-mail com um anexo. Por fim, definiremos Controller camada para passar 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";
    }
}

Agora, se executarmos o aplicativo e executarmos o seguinte curl, ele enviará um e-mail para o endereço de e-mail verificado:

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'

Em seguida, podemos fazer login no endereço de e-mail do destinatário e verificar se o destinatário recebeu o e-mail.

Envio de e-mail de modelo com anexo

Os casos de uso anteriores que vimos são bons para cenários de desenvolvimento ou teste, mas na produção geralmente usamos um modelo de email com variáveis ​​que seriam substituídas usando as respostas de uma API. Anteriormente adicionamos a dependência para Apache FreemarkerName. Vamos usá-lo para definir um modelo e carregá-lo para processar!

Para isso, vamos primeiro definir um modelo simples, nomeá-lo como email-template.ftl e coloque-o em templates pasta sob 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>

Em seguida, precisamos definir uma classe de configuração para carregar o modelo do caminho e adicionar como bean. Para isso, definiremos FreeMarkerConfigurationFactoryBean:

@Configuration
public class FreemarkerConfig {

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

Em seguida, vamos definir nossa camada de serviço para carregar este template e criar uma mensagem final para enviar ao 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());
        }
    }

Por fim, definiremos um Controller camada para passar os atributos de e-mail dinâmicos:

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

Agora, se executarmos o aplicativo e executarmos o seguinte curl, ele enviará um e-mail para o endereço de e-mail verificado:

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'

Em seguida, podemos fazer login no endereço de e-mail do destinatário e verificar se o destinatário recebeu o e-mail:

Envio de e-mail personalizado usando modelos no AWS SES

No caso de uso anterior, usamos um modelo estático para enviar e-mails. Como podemos permitir que os modelos sejam projetados dinamicamente para diferentes propósitos e diferentes tipos de destinatários? O AWS SES nos permite criar modelos de e-mail para enviar e-mails personalizados para um ou mais destinos em uma única operação.

Podemos criar até 10,000 modelos de e-mail por conta do Amazon SES. Cada modelo pode ter até 500 KB de tamanho, incluindo as partes de texto e HTML. Podemos enviar até 50 destinos em cada chamada.

Então, vamos criar rapidamente um modelo de e-mail. Primeiro, podemos definir um arquivo JSON usando o seguinte modelo:

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

Este modelo contém os seguintes atributos:

• Nome do modelo: contém o nome do modelo.
• AssuntoParte: mantém a linha de assunto do e-mail. As tags de substituição podem estar presentes neste recurso. Essas tags são formatadas da seguinte forma: {{tagname}}. Você pode inserir um valor para {{tagname}} para cada destino ao enviar o e-mail.
• HtmlPart: contém o corpo HTML do e-mail e também pode conter tags de substituição.
• Parte de texto: representa o corpo do texto do email. Esta versão do e-mail é enviada para destinatários cujos clientes de e-mail não visualizam e-mails em HTML. As tags de substituição podem estar presentes neste recurso.

Podemos salvar este arquivo como mytemplate.json. Por fim, podemos usar um comando da AWS CLI para criar o modelo da seguinte forma:

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

Em seguida, vamos definir uma camada de serviço para definir atributos e enviar e-mails modelo:

@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 adicionar vários Destination endereços para enviar e-mails em massa para vários destinatários. Estamos usando o sendTemplatedEmail() método do AmazonSimpleEmailService interface para enviar este e-mail modelo. Também precisamos passar as tags de substituição para serem substituídas no texto HTML do nosso template que criamos anteriormente.

Por fim, definiremos um Controller camada para definir a API REST para passar os 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";
    }
}

Em seguida, quando executamos o aplicativo, podemos executar o seguinte curl para enviar e-mails modelo:

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'

Agora, o destinatário finalmente consegue ver um e-mail modelo:

Solicitar acesso à produção

Finalmente, para enviar e-mails para qualquer destinatário, independentemente de o endereço ou domínio do destinatário ser validado, devemos tirar nossa conta do sandbox. Todas as nossas identidades, incluindo From, Source, Sender e Return-Path endereços, ainda devem ser verificados. Podemos enviar uma solicitação de acesso à Produção a partir do “Painel da conta” página da seguinte forma:

Podemos enviar a solicitação preenchendo todos os detalhes acima no Console AWS. O mesmo também pode ser enviado usando a AWS CLI. Isso seria útil quando precisarmos solicitar acesso para um grande número de identidades e quisermos automatizar o processo.

Conclusão

As principais ideias do Amazon Simple Email Service (SES) e as bibliotecas oferecidas pelo Spring Cloud AWS para fazer interface com ele foram abordadas neste artigo. Além disso, criamos um aplicativo Spring Boot com uma API REST que pode enviar e-mails por meio do módulo Spring Cloud AWS SES.

Agora você deve ter uma compreensão sólida do que é o Amazon Simple Email Service (SES) e como utilizá-lo para enviar e-mails.