Bevezetés
AWS SES (egyszerű e-mail szolgáltatás) egy egyszerűen beállítható e-mail küldő és fogadó szolgáltatás. Általában nehéz, körülményes és fárasztó a helyszíni levelezőrendszer kezelése, ezért a folyamat kiszervezése népszerű választás.
Az Amazon SES segítségével tranzakciós e-maileket, marketing e-maileket vagy bármilyen más értesítő e-mailt küldhetünk ügyfeleinknek. Ez egy megfizethető megoldás bármilyen méretű vállalkozás számára, akik e-maileket használnak az ügyfelekkel való kapcsolattartásra, mivel a megbízható és méretezhető infrastruktúrára épül. Amazon Web Services (AWS).
Tömeges e-mailek küldéséhez bármely alkalmazás kapcsolatba léphet az Amazon SES-szel. Csak a ténylegesen elküldött e-mailekért fizetünk, legyenek azok tranzakciós e-mailek vagy marketing e-mailek. Ezenkívül az Amazon SES számos konfigurációt támogat, beleértve a dedikált, megosztott vagy birtokolt IP-címeket. A kézbesítési irányítópultok és a feladói adatokról szóló jelentések segítségével a vállalkozások minden e-mailt fontossá tehetnek.
Ebben az útmutatóban egy AWS SES példányt fogunk konfigurálni egy régióban, majd integrálni fogunk vele Tavaszi felhő az AWS-hez amely alprojektje Tavaszi felhő. Különféle forgatókönyveket próbálunk ki e-mailek küldésére az alkalmazásunkból.
Jegyzet: Az útmutatóban használt összes forráskódot megtalálja a GitHub.
Az AWS SES használatával e-mail küldésének életciklusa
Nézzük meg, hogyan jut el egy alkalmazás által küldött e-mail életciklusa a célpostafiókig:
-
Egy alkalmazás, esetünkben a Spring Cloud kód arra kéri az AWS SES-t, hogy küldjön e-mailt egy vagy több címzettnek.
-
A SES először ellenőrzi a kérést, és ha jóváhagyják, e-mail üzenetet készít a kérelem specifikációival. Ennek az e-mail üzenetnek van fejléce, törzse és borítéka, és megfelel a követelményeknek RFC 5322internetes üzenetformátum definícióját.
-
A SES ezután az üzenetet az interneten keresztül továbbítja a címzett vevőjének. Amint az üzenetet átadják a SES-nek, gyakran azonnal elküldik, és a kezdeti kézbesítési kísérlet általában néhány ezredmásodperc alatt megtörténik.
-
Jelenleg több eredmény is van. Például:
- Sikeres szállítás: Az internetszolgáltató (ISP) elfogadja az e-mailt, és elküldi a címzettnek.
- Hard Bounce: Mivel a címzett címe érvénytelen, az internetszolgáltató elutasítja az e-mailt. Az internetszolgáltató visszaküldi a kemény visszapattanási értesítést az Amazon SES-nek, amely e-mailben értesíti a feladót, vagy közzéteszi az Amazon Simple Notification Service (Amazon SNS) témában, amely az értesítés fogadására van beállítva.
- Soft Bounce: Olyan körülmények miatt, mint például, hogy a címzett postaládája megtelt, a domain nem létezik, vagy bármilyen múló körülmény, például az internetszolgáltató túl elfoglalt a kérés feldolgozásához, előfordulhat, hogy az internetszolgáltató nem tudja kézbesíteni az e-mailt a címzettnek. Az internetszolgáltató ezután bizonyos számú alkalommal újrapróbálja az e-mailt, és lágy visszapattanó üzenetet küld a SES-nek. Ha a SES nem tudja kézbesíteni az e-mailt a megadott időn belül, akkor vagy közzéteszi az eseményt egy SNS-témában, vagy kemény visszapattanó üzenetet küld e-mailben.
- Panasz: Az e-mailt a címzett a levelezőprogramjában spamnek minősítette. A panaszról szóló értesítést továbbítják az Amazon SES-nek, amely továbbítja azt a feladónak, ha az Amazon SES és az internetszolgáltató visszacsatolási hurkot épített ki.
- Automatikus válasz: A címzett internetszolgáltató értesíti az Amazon SES-t a fogadó automatikus válaszáról, például a házon kívüli értesítésről, az Amazon SES pedig továbbítja az értesítést a feladónak.
Ha a kézbesítés sikertelen, az Amazon SES hibaüzenetet küld a feladónak, és törli az e-mailt.
Az Amazon SES beállítása
A többi AWS-szolgáltatástól eltérően gyakorlatilag nincs szükség SES-példány létrehozására, mivel az összes új AWS-fiók alapértelmezés szerint az AWS SES sandboxba kerül. Alapértelmezés szerint minden AWS-fiók sandbox-hozzáféréssel rendelkezik az AWS SES-hez az elérhető régiókban.
Sandbox mód használata esetén csak ellenőrzött személyazonosságoknak tudunk e-mailt küldeni. Az e-mail küldésére használt domain vagy e-mail cím ellenőrzött személyazonosság. Meg kell alkotnunk és érvényesítenünk kell minden identitást, amelyet használni kívánunk a From
, To
, Source
, Sender
vagy Return-Path
címre, mielőtt e-mailt küldhetnénk a SES használatával sandbox módban. Az Amazon SES használatával a személyazonosság ellenőrzésére igazolhatjuk tulajdonjogunkat, és leállíthatjuk az illegális használatot.
A csalások elkerülése és az IP-címek hírnevének megőrzése érdekében az AWS SES e-mail küldési korlátokat tartalmaz. Ezek a korlátozások meghatározzák az e-mailek másodpercenkénti maximális számát és az egyes felhasználók napi e-mail-korlátját. Az AWS támogatási központtal való kapcsolatfelvétellel régiónként megállapíthatunk ilyen kvótákat.
Ellenőrizzük a személyazonosságokat. Jelentkezzen be az AWS konzolba, és keresse meg a "Amazon egyszerű e-mail szolgáltatás"
Ezután kattintson aIdentitás létrehozása” e-mail-cím vagy domain hozzáadásához ellenőrzés céljából. A mi esetünkben egy e-mailt fogunk hozzáadni az ellenőrzéshez.
Miután az identitás létrejött, ellenőrizhetjük a részleteket.
Az identitás, amit létrehoztunk, a „Ellenőrzés függőben" színpad. Ebben a szakaszban a felhasználónak ellenőriznie kell az AWS-től kapott ellenőrző levelet, és követnie kell az utasításokat az e-mail ellenőrzéséhez.
Ezután le kell hoznunk "hozzáférési kulcs"És"titkos kulcs” alkalmazásunk SES-sel történő hitelesítéséhez és engedélyezéséhez. Ennek létrehozásához létre kell hoznunk egy felhasználói csoportot, és hozzá kell adnunk egy felhasználót a csoporthoz. Amikor létrehozzuk ezt a felhasználót, az AWS létrehoz egy hozzáférési kulcsot és egy titkos kulcsot. Tehát irányítsuk át ide: "IAM” az AWS konzolban, és hozzon létre felhasználói csoportot.
Ezután hozzá kell adnunk: "AdministratorAccess” engedélyt ehhez a csoporthoz a SES számára.
Végül hozzáadunk egy felhasználót a fenti csoporthoz.
Ezután ki kell választanunk az engedélyekhez tartozó csoportot.
Végül másolja ki a képernyőn megjelenő hozzáférési kulcsot és titkos kulcsot további felhasználás céljából.
E-mailek küldése a Spring Cloud Project segítségével
Projekt beállítása
Pörgessünk fel egy Spring Cloud projektet, és fussunk végig a használati eseteken, hogy integráljuk a SES-t. A csontváz-projekt elindításának legegyszerűbb módja a Tavaszi inicializálás:
Hozzátettük Tavaszi web a REST MVC számára, Apache Freemarker HTML-alapú e-mail sablonok létrehozásához, Java Mail Sender e-mail küldésére és Lombok (opcionális fűtőelem-csökkentő könyvtár) függőségek. Ezenkívül hozzá kell adnunk a Spring Cloud AWS-hez és a SES-hez kapcsolódó függőségeket. A Spring Cloud AWS esetében külön Spring Cloud AWS BOM-ot adunk hozzá pom.xml
fájlt ezzel Blokk:
<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>
Végül a SES támogatásának hozzáadásához tartalmaznunk kell a modulfüggőséget, amely kezdő modulként érhető el spring-cloud-starter-aws-ses
:
<dependency>
<groupId>io.awspring.cloud</groupId>
<artifactId>spring-cloud-starter-aws-ses</artifactId>
</dependency>
spring-cloud-starter-aws-ses
tartalmazza a tranzitív függőségeket spring-cloud-starter-aws
és spring-cloud-aws-ses
Az spring-cloud-aws-ses
A SES modul két osztályt tartalmaz: SimpleEmailServiceMailSender
és a SimpleEmailServiceJavaMailSender
.
- A
SimpleEmailServiceMailSender
osztály az Amazon Simple Email Service szolgáltatást használja e-mailek küldésére. A Java Mail API nem követelmény ehhez a megvalósításhoz. Használható egyszerű, mellékletek nélküli e-mail üzenetek küldésére. - A
SimpleEmailServiceJavaMailSender
osztály lehetővé teszi a mellékleteket és egyéb MIME elemeket tartalmazó e-mailek küldését.
Tehát ez minden alapvető követelményünket lefedi!
Beans konfigurálása
Mint fentebb tárgyaltuk, kétféle babot kell meghatároznunk: SimpleEmailServiceMailSender
és a SimpleEmailServiceJavaMailSender
. Egyszerűen átadhatjuk a hozzáférési kulcsot és a titkos kulcsot hitelesítő adatokként, és beállíthatjuk a MailSender
bab, amelyet e-mailek küldésére fogunk használni:
@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);
}
}
A csatolt e-mailek küldéséhez konfigurálnunk kell a SimpleEmailServiceJavaMailSender
amely megvalósítása a JavaMailSender
felület a tavaszi levélabsztrakcióból.
Tekintse meg gyakorlatias, gyakorlati útmutatónkat a Git tanulásához, amely tartalmazza a bevált gyakorlatokat, az iparág által elfogadott szabványokat és a mellékelt csalólapot. Hagyd abba a guglizást a Git parancsokkal, és valójában tanulni meg!
Meghatározzuk azokat a tulajdonságokat is, amelyekből lekérjük az információkat application.yml
:
cloud:
aws:
region:
static: eu-central-1
auto: false
stack:
auto: false
credentials:
access-key: ********
secret-key: **************************
Egyszerű e-mail küldése
Egyszerű e-maileket küldhetünk a SimpleEmailServiceMailSender
bab, amelyet fent konfiguráltunk. Határozunk meg egy szolgáltatási réteget a komponens használatához:
@Service
public class EmailService {
@Autowired
private MailSender mailSender;
public void sendMessage(SimpleMailMessage simpleMailMessage) {
this.mailSender.send(simpleMailMessage);
}
}
Hívjuk a send()
módszer a MailSender
bean, hogy elküldje e-mailünket. Azt is át kell adnunk a SimpleMailMessage
amely olyan attribútumokat tartalmazna, mint from
, to
, az e-mailünk szövege és tárgya. Tehát határozzuk meg a Controller
osztály a fenti szolgáltatás meghívásához REST API használatával:
@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";
}
}
Most, ha futtatjuk az alkalmazást és végrehajtjuk a következő curl-et, akkor e-mailt küld az ellenőrzött e-mail címre:
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'
Ezután bejelentkezhetünk a címzett e-mail címére, és ellenőrizhetjük, hogy a címzett megkapta-e az e-mailt.
Egyszerű e-mail küldése melléklettel
Meghatározunk egy szolgáltatási réteget, amely a mellékletet MIME-ként továbbítja, és beállítjuk a többi e-mail attribútumot, mint pl from
, to
, szöveg és tárgy:
@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());
}
}
}
Itt használjuk MimeMessageHelper
mellékletet tartalmazó e-mail létrehozásához. Végül meghatározzuk Controller
réteg átadni a SimpleMailMessage
attribútumok:
@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";
}
}
Most, ha futtatjuk az alkalmazást és végrehajtjuk a következő curl-et, akkor e-mailt küld az ellenőrzött e-mail címre:
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'
Ezután bejelentkezhetünk a címzett e-mail címére, és ellenőrizhetjük, hogy a címzett megkapta-e az e-mailt.
Sablon e-mail küldése melléklettel
A korábbi használati esetek, amelyeket láttunk, jók fejlesztési vagy tesztelési forgatókönyvekhez, de az éles környezetben általában egy e-mail sablont használunk olyan változókkal, amelyeket egy API válaszaival helyettesítenek. Korábban hozzáadtuk a függőséget Apache Freemarker. Ennek segítségével definiálunk egy sablont és betöltjük a feldolgozáshoz!
Ehhez először definiáljunk egy egyszerű sablont, nevezzük el email-template.ftl
és helyezze be templates
mappa alatt 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>
Ezután meg kell határoznunk egy konfigurációs osztályt a sablon betöltéséhez az elérési útból, és hozzáadnunk kell komponensként. Ehhez meghatározzuk FreeMarkerConfigurationFactoryBean
:
@Configuration
public class FreemarkerConfig {
@Primary
@Bean
public FreeMarkerConfigurationFactoryBean factoryBean() {
FreeMarkerConfigurationFactoryBean bean = new FreeMarkerConfigurationFactoryBean();
bean.setTemplateLoaderPath("classpath:/templates");
return bean;
}
}
Ezután meghatározzuk a szolgáltatási rétegünket a sablon betöltéséhez, és létrehozunk egy végső üzenetet, amelyet elküldünk a SES-nek:
@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());
}
}
Végül meghatározzuk a Controller
réteg a dinamikus e-mail attribútumok átadásához:
@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";
}
}
Most, ha futtatjuk az alkalmazást és végrehajtjuk a következő curl-et, akkor e-mailt küld az ellenőrzött e-mail címre:
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'
Ezután bejelentkezhetünk a címzett e-mail címére, és ellenőrizhetjük, hogy a címzett megkapta-e az e-mailt:
Személyre szabott e-mailek küldése sablonok segítségével az AWS SES-ben
Az előző használati esetben statikus sablont használtunk az e-mailek küldésére. Hogyan tehetjük lehetővé a sablonok dinamikus tervezését különböző célokra és különböző típusú címzettekhez? Az AWS SES lehetővé teszi e-mail sablonok létrehozását, amelyekkel személyre szabott e-maileket küldhetünk egy vagy több célállomásra egyetlen műveletben.
Amazon SES-fiókonként akár 10,000 500 e-mail sablont is létrehozhatunk. Minden sablon legfeljebb 50 KB méretű lehet, beleértve a szöveges és HTML részeket is. Hívásonként legfeljebb XNUMX célállomást tudunk küldeni.
Tehát gyorsan hozzunk létre egy e-mail sablont. Először is definiálhatunk egy JSON-fájlt a következő sablon használatával:
{
"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."
}
}
Ez a sablon a következő attribútumokat tartalmazza:
- Sablonnév: Ez tartalmazza a sablon nevét.
- TárgyRész: Ez tartalmazza az e-mail tárgysorát. Cserecímkék lehetnek ezen az eszközön. Ezek a címkék a következőképpen vannak formázva:
{{tagname}}
. Megadhat egy értéket{{tagname}}
az e-mail küldésekor minden egyes célállomáshoz. - HtmlPart: Ez tartalmazza az e-mail HTML törzsét, és tartalmazhat helyettesítő címkéket is.
- TextPart: Ez az e-mail szövegrésze. Az e-mail ezen verziója azoknak a címzetteknek kerül elküldésre, akiknek az e-mail kliensei nem tekintik meg a HTML e-maileket. Cserecímkék lehetnek ezen az eszközön.
Ezt a fájlt más néven menthetjük mytemplate.json
. Végül egy AWS CLI paranccsal létrehozhatjuk a sablont az alábbiak szerint:
$ aws ses create-template --cli-input-json file://mytemplate.json
Ezután definiáljunk egy szolgáltatási réteget az attribútumok meghatározásához és a sablonos e-mailek küldéséhez:
@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);
}
}
Többet is hozzáadhatunk Destination
címek tömeges e-mailek küldéséhez több címzettnek. Mi használjuk a sendTemplatedEmail()
módszer a AmazonSimpleEmailService
felületen elküldheti ezt a sablonos e-mailt. A korábban létrehozott sablonunk HTML-szövegében is át kell adnunk a helyettesítendő címkéket.
Végül meghatározzuk a Controller
réteg a REST API meghatározásához az attribútumok átadásához:
@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";
}
}
Ezután az alkalmazás futtatásakor a következőket hajthatjuk végre curl
sablonos e-mailek küldéséhez:
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'
Most végre a címzett láthat egy sablonos e-mailt:
Gyártási hozzáférés kérése
Végül pedig ahhoz, hogy bármely címzettnek e-mailt küldhessünk, függetlenül attól, hogy a címzett címe vagy domainje érvényesített-e, végül ki kell venni a fiókunkat a homokozóból. Minden identitásunk, beleértve From
, Source
, Sender
és Return-Path
címeket, akkor is ellenőrizni kell. Gyártási hozzáférés iránti kérelmet a „Fiók irányítópultja” oldalon az alábbiak szerint:
A kérelmet a fenti adatok kitöltésével az AWS Console-ból tudjuk benyújtani. Ugyanez az AWS CLI használatával is benyújtható. Ez akkor lenne hasznos, ha nagyszámú identitáshoz kell hozzáférést kérnünk, és automatizálni szeretnénk a folyamatot.
Következtetés
Ebben a cikkben az Amazon Simple Email Service (SES) és a Spring Cloud AWS által a vele való interfészhez kínált könyvtárak kulcsfontosságú ötleteit ismertetjük. Ezenkívül létrehoztunk egy Spring Boot alkalmazást REST API-val, amely képes e-maileket küldeni a Spring Cloud AWS SES modulon keresztül.
Most már alaposan meg kell értenie, hogy mi az Amazon Simple Email Service (SES), és hogyan használhatja fel e-mailek küldésére.