Introduction
AWS SES (service de messagerie simple) est un service d'envoi et de réception d'e-mails simple à configurer. Il est généralement difficile, capricieux et fastidieux de gérer un système de messagerie sur site, c'est pourquoi l'externalisation du processus est un choix populaire.
Nous pouvons utiliser Amazon SES pour envoyer des e-mails transactionnels, des e-mails marketing ou tout autre type d'e-mails de notification à nos clients. Il s'agit d'une solution abordable pour les entreprises de toutes tailles qui utilisent les e-mails pour se connecter avec leurs clients, car elle repose sur l'infrastructure fiable et évolutive de Amazon Web Services (AWS).
Pour l'envoi d'e-mails en masse, n'importe quelle application peut interagir avec Amazon SES. Nous ne payons que les e-mails que nous envoyons réellement, qu'il s'agisse d'e-mails transactionnels ou d'e-mails marketing. De plus, une gamme de configurations, y compris des adresses IP dédiées, partagées ou détenues, sont prises en charge par Amazon SES. Les entreprises peuvent faire en sorte que chaque e-mail compte grâce à l'utilisation de tableaux de bord de délivrabilité et de rapports sur les informations de l'expéditeur.
Dans ce guide, nous allons configurer une instance AWS SES dans une région, puis intégrer avec Spring Cloud pour AWS qui est un sous-projet de Nuage de printemps. Nous allons essayer différents scénarios pour envoyer des emails depuis notre application.
Remarque: Vous pouvez trouver tout le code source utilisé dans le guide sur Github.
Cycle de vie de l'envoi d'un e-mail à l'aide d'AWS SES
Regardons comment le cycle de vie d'un e-mail envoyé par une application atteint la boîte aux lettres de destination :
-
Une application, dans notre cas, le code Spring Cloud demande à AWS SES d'envoyer un e-mail à un ou plusieurs destinataires.
-
SES vérifie initialement la demande et, si elle est approuvée, produit un message électronique avec les spécifications de la demande. Ce message électronique a un en-tête, un corps et une enveloppe et est conforme à RFC 5322Définition du format de message Internet de .
-
SES transmet ensuite le message au destinataire du destinataire via Internet. Dès que le message est remis à SES, il est souvent transmis immédiatement, la tentative de livraison initiale se déroulant généralement en quelques millisecondes.
-
Il y a plusieurs résultats en ce moment. Par exemple:
- Livraison réussie: Le fournisseur d'accès Internet (FAI) accepte l'e-mail et l'envoie au destinataire prévu.
- Rebondissement dur: L'adresse du destinataire n'étant pas valide, le FAI rejette l'e-mail. Le FAI renvoie la notification de rebond définitif à Amazon SES, qui notifie l'expéditeur par e-mail ou en la publiant dans une rubrique Amazon Simple Notification Service (Amazon SNS) configurée pour recevoir cette notification.
- Rebond doux : En raison de conditions telles que la boîte de réception du destinataire étant pleine, le domaine inexistant ou toute circonstance passagère comme le FAI étant trop occupé pour traiter la demande, le FAI peut ne pas être en mesure de remettre l'e-mail au destinataire. Le FAI réessaie ensuite l'e-mail jusqu'à un certain nombre de fois et envoie à SES un message de rebond temporaire. Si SES n'est pas en mesure de livrer l'e-mail dans le délai spécifié, il publie l'événement dans une rubrique SNS ou envoie un message de rebond définitif par e-mail.
- Plainte: L'e-mail est classé comme spam par le destinataire dans son programme de messagerie. Une notification de plainte est transmise à Amazon SES, qui la relaie ensuite à l'expéditeur si Amazon SES et le FAI ont établi une boucle de rétroaction.
- Réponse automatique: Le FAI destinataire informe Amazon SES d'une réponse automatisée du destinataire, telle qu'un avis d'absence du bureau, et Amazon SES transmet la notification à l'expéditeur.
Lorsque la livraison échoue, Amazon SES renvoie une erreur à l'expéditeur et supprime l'e-mail.
Configuration d'Amazon SES
Contrairement à tous les autres services AWS, il n'est pratiquement pas nécessaire de créer une instance SES car tous les nouveaux comptes AWS sont placés par défaut dans le bac à sable AWS SES. Chaque compte AWS dispose d'un accès sandbox pour AWS SES dans les régions disponibles par défaut.
Lorsque vous utilisez le mode sandbox, nous ne pouvons envoyer des e-mails qu'aux identités vérifiées. Un domaine ou une adresse e-mail que nous utilisons pour envoyer un e-mail est une identité vérifiée. Nous devons construire et valider chaque identité que nous avons l'intention d'utiliser comme From, To, Source, Senderou Return-Path avant de pouvoir envoyer un e-mail à l'aide de SES en mode sandbox. En utilisant Amazon SES pour vérifier l'identité, nous pouvons prouver notre propriété et arrêter l'utilisation illégale.
Pour éviter la fraude et préserver la réputation d'une adresse IP, AWS SES inclut des limites d'envoi d'e-mails. Ces limitations spécifient le nombre maximal d'e-mails par seconde et la limite quotidienne d'e-mails pour chaque utilisateur. En contactant le AWS Support Center, nous pouvons établir ces quotas par région.
Vérifions les identités. Connectez-vous à la console AWS et recherchez "Service de messagerie simple Amazon"
Puis cliquez sur "Créer une identité” pour ajouter une adresse e-mail ou un domaine pour vérification. Dans notre cas, nous allons ajouter un email pour vérification.
Une fois l'identité créée, nous pouvons vérifier les détails.
L'identité que nous avons créée va dans "Vérification en attente" organiser. À ce stade, l'utilisateur doit vérifier l'e-mail de vérification d'AWS et suivre les instructions pour faire vérifier l'e-mail.
Ensuite, nous devons récupérer "clé d'accès" et "clef secrète” pour l'authentification et l'autorisation de notre application auprès de SES. Pour générer cela, nous devons créer un groupe d'utilisateurs et ajouter un utilisateur à ce groupe. Lorsque nous créons cet utilisateur, AWS génère une clé d'accès et une clé secrète. Alors redirigeons vers "IAM” dans la console AWS et créez un groupe d'utilisateurs.
Ensuite, nous devons ajouter "AccèsAdministrateur” autorisation à ce groupe pour SES.
Enfin, nous ajouterons un utilisateur au groupe ci-dessus.
Ensuite, nous devons sélectionner le groupe pour les autorisations.
Enfin, copiez la clé d'accès et la clé secrète affichées à l'écran pour une utilisation ultérieure.
Envoi d'e-mails à l'aide de Spring Cloud Project
Configuration du projet
Lançons un projet Spring Cloud et parcourons les cas d'utilisation à intégrer à SES. La façon la plus simple de commencer avec un projet squelette est via Initialisation du ressort:
Nous avons ajouté Toile de printemps pour REST MVC, Apache Freemarker pour générer des modèles d'e-mails HTML, Expéditeur de courrier Java pour envoyer un e-mail et Lombok (bibliothèque de réduction passe-partout facultative) dépendances. De plus, nous devons ajouter des dépendances pertinentes pour Spring Cloud AWS et SES. Pour Spring Cloud AWS, nous ajouterons une nomenclature Spring Cloud AWS distincte dans notre pom.xml fichier utilisant ceci bloquer:
<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>
Enfin, pour ajouter le support de SES, nous devons inclure la dépendance de module qui est disponible en tant que module de démarrage spring-cloud-starter-aws-ses:
<dependency>
<groupId>io.awspring.cloud</groupId>
<artifactId>spring-cloud-starter-aws-ses</artifactId>
</dependency>
spring-cloud-starter-aws-ses inclut les dépendances transitives pour spring-cloud-starter-awset spring-cloud-aws-sesL’ spring-cloud-aws-ses module pour SES contient deux classes : SimpleEmailServiceMailSender ainsi que SimpleEmailServiceJavaMailSender.
- La
SimpleEmailServiceMailSenderclasse utilise Amazon Simple Email Service pour envoyer des e-mails. L'API Java Mail n'est pas une exigence pour cette implémentation. Il peut être utilisé pour envoyer des messages électroniques simples sans pièces jointes. - La
SimpleEmailServiceJavaMailSenderLa classe permet l'envoi d'e-mails contenant des pièces jointes et d'autres éléments mime.
Cela couvre donc toutes nos exigences de base !
Configuration des beans
Comme discuté ci-dessus, nous devons définir deux types de haricots : SimpleEmailServiceMailSender ainsi que SimpleEmailServiceJavaMailSender. Nous pouvons simplement transmettre la clé d'accès et la clé secrète comme informations d'identification et configurer un MailSender bean que nous utiliserons pour envoyer des 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);
}
}
Pour envoyer des e-mails avec des pièces jointes, nous devons configurer le SimpleEmailServiceJavaMailSender qui est une implémentation de JavaMailSender interface de l'abstraction de courrier de Spring.
Consultez notre guide pratique et pratique pour apprendre Git, avec les meilleures pratiques, les normes acceptées par l'industrie et la feuille de triche incluse. Arrêtez de googler les commandes Git et en fait apprendre il!
Nous définirons également les propriétés pour récupérer les informations de application.yml:
cloud:
aws:
region:
static: eu-central-1
auto: false
stack:
auto: false
credentials:
access-key: ********
secret-key: **************************
Envoi d'e-mails simples
Nous pouvons envoyer des e-mails simples en utilisant le SimpleEmailServiceMailSender bean que nous avons configuré ci-dessus. Définissons une couche de service pour utiliser ce bean :
@Service
public class EmailService {
@Autowired
private MailSender mailSender;
public void sendMessage(SimpleMailMessage simpleMailMessage) {
this.mailSender.send(simpleMailMessage);
}
}
Nous appelons le send() méthode dans le MailSender bean pour envoyer notre email. Nous devons également passer le SimpleMailMessage qui contiendrait des attributs comme from, to, le texte et l'objet de notre e-mail. Alors, définissons un Controller class pour appeler le service ci-dessus à l'aide d'une 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";
}
}
Maintenant, si nous exécutons l'application et exécutons la boucle suivante, elle enverra un e-mail à l'adresse e-mail vérifiée :
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'
Ensuite, nous pouvons nous connecter à l'adresse e-mail du destinataire et vérifier si le destinataire a reçu l'e-mail.
Envoyer un e-mail simple avec pièce jointe
Nous allons définir une couche de service pour transmettre la pièce jointe en tant que mime et définir les autres attributs d'e-mail comme from, to, texte et sujet :
@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());
}
}
}
Ici nous utilisons MimeMessageHelper pour créer un e-mail avec une pièce jointe. Enfin, nous définirons Controller couche pour passer le SimpleMailMessage attributs:
@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";
}
}
Maintenant, si nous exécutons l'application et exécutons la boucle suivante, elle enverra un e-mail à l'adresse e-mail vérifiée :
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'
Ensuite, nous pouvons nous connecter à l'adresse e-mail du destinataire et vérifier si le destinataire a reçu l'e-mail.
Envoi d'un modèle d'e-mail avec pièce jointe
Les cas d'utilisation précédents que nous avions vus sont bons pour les scénarios de développement ou de test, mais en production, nous utilisons généralement un modèle d'e-mail avec des variables qui seraient remplacées à l'aide des réponses d'une API. Nous avions précédemment ajouté la dépendance pour Apache Freemarker. Nous allons l'utiliser pour définir un modèle et le charger pour le traiter !
Pour cela, définissons d'abord un modèle simple, nommons-le comme email-template.ftl et placez-le dans templates dossier sous 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>
Ensuite, nous devons définir une classe de configuration pour charger le modèle à partir du chemin et l'ajouter en tant que bean. Pour cela, nous définirons FreeMarkerConfigurationFactoryBean:
@Configuration
public class FreemarkerConfig {
@Primary
@Bean
public FreeMarkerConfigurationFactoryBean factoryBean() {
FreeMarkerConfigurationFactoryBean bean = new FreeMarkerConfigurationFactoryBean();
bean.setTemplateLoaderPath("classpath:/templates");
return bean;
}
}
Ensuite, nous allons définir notre couche de service pour charger ce modèle et créer un message final à envoyer à 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());
}
}
Enfin, nous définirons une Controller couche pour transmettre les attributs d'e-mail dynamique :
@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";
}
}
Maintenant, si nous exécutons l'application et exécutons la boucle suivante, elle enverra un e-mail à l'adresse e-mail vérifiée :
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'
Ensuite, nous pouvons nous connecter à l'adresse e-mail du destinataire et vérifier si le destinataire a reçu l'e-mail :
Envoi d'e-mails personnalisés à l'aide de modèles dans AWS SES
Dans le cas d'utilisation précédent, nous avons utilisé un modèle statique pour envoyer des e-mails. Comment pouvons-nous permettre à des modèles d'être conçus de manière dynamique pour différents objectifs et différents types de destinataires ? AWS SES nous permet de créer des modèles d'e-mails pour envoyer des e-mails personnalisés vers une ou plusieurs destinations en une seule opération.
Nous pouvons créer jusqu'à 10,000 500 modèles d'e-mails par compte Amazon SES. Chaque modèle peut avoir une taille maximale de 50 Ko, y compris les parties texte et HTML. Nous pouvons envoyer jusqu'à XNUMX destinations dans chaque appel.
Créons donc rapidement un modèle d'e-mail. Tout d'abord, nous pouvons définir un fichier JSON en utilisant le modèle suivant :
{
"Template": {
"TemplateName": "MyTemplate",
"SubjectPart": "Greetings from {{name}}!",
"HtmlPart": "StackAbuse Email
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."
}
}
Ce modèle contient les attributs suivants :
- Nom du modèle: contient le nom du modèle.
- ObjetPartie: Cela contient la ligne d'objet de l'e-mail. Des balises de remplacement peuvent être présentes sur cet élément. Ces balises sont formatées comme suit :
{{tagname}}. Vous pouvez entrer une valeur pour{{tagname}}pour chaque destination lors de l'envoi de l'e-mail. - Partie HTML: contient le corps HTML de l'e-mail et peut également contenir des balises de remplacement.
- Partie Texte: Ceci représente le corps du texte de l'e-mail. Cette version de l'e-mail est envoyée aux destinataires dont les clients de messagerie n'affichent pas les e-mails HTML. Des balises de remplacement peuvent être présentes sur cet élément.
Nous pouvons enregistrer ce fichier sous mytemplate.json. Enfin, nous pouvons utiliser une commande AWS CLI pour créer le modèle comme suit :
$ aws ses create-template --cli-input-json file://mytemplate.json
Ensuite, définissons une couche de service pour définir les attributs et envoyer des e-mails basés sur des modèles :
@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);
}
}
Nous pouvons ajouter plusieurs Destination adresses pour envoyer des e-mails en masse à plusieurs destinataires. Nous utilisons le sendTemplatedEmail() méthode de la AmazonSimpleEmailService interface pour envoyer cet e-mail basé sur un modèle. Nous devons également passer les balises de remplacement à remplacer dans le texte HTML de notre modèle que nous avons créé précédemment.
Enfin, nous définirons une Controller couche pour définir l'API REST pour transmettre les attributs :
@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";
}
}
Ensuite, lorsque nous exécutons l'application, nous pouvons exécuter ce qui suit curl pour envoyer des modèles d'e-mails :
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'
Maintenant, le destinataire peut enfin voir un modèle d'e-mail :
Demande d'accès à la production
Enfin, afin d'envoyer des e-mails à n'importe quel destinataire, que l'adresse ou le domaine du destinataire soit validé ou non, nous devons finalement sortir notre compte du bac à sable. Toutes nos identités, y compris From, Source, Senderet Return-Path adresses, doivent encore être vérifiées. Nous pouvons soumettre une demande d'accès à la production à partir du "Tableau de Bord» page comme suit :
Nous pouvons soumettre la demande en remplissant tous les détails ci-dessus depuis la console AWS. La même chose peut également être soumise à l'aide de l'AWS CLI. Cela serait utile lorsque nous devons demander l'accès à un grand nombre d'identités et que nous souhaitons automatiser le processus.
Conclusion
Les idées clés d'Amazon Simple Email Service (SES) et les bibliothèques proposées par Spring Cloud AWS pour s'interfacer avec lui ont été abordées dans cet article. De plus, nous avons créé une application Spring Boot avec une API REST qui peut envoyer des e-mails via le module Spring Cloud AWS SES.
Vous devriez maintenant avoir une solide compréhension de ce qu'est Amazon Simple Email Service (SES) et comment l'utiliser pour envoyer des e-mails.
