Útmutató az egyszerű e-mail szolgáltatáshoz (AWS SES) a Spring Boot és a Spring Cloud segítségével

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, Sendervagy 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.

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

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.