Panduan Layanan Email Sederhana (AWS SES) dengan Spring Boot dan Spring Cloud PlatoBlockchain Data Intelligence. Pencarian Vertikal. Ai.

Panduan untuk Layanan Email Sederhana (AWS SES) dengan Spring Boot dan Spring Cloud

Stempel Waktu: 20 Oktober 2022 6:30

Pengantar

AWS SES (Layanan Email Sederhana) adalah layanan pengiriman dan penerimaan email yang mudah disiapkan. Biasanya sulit, rewel, dan membosankan untuk mengelola sistem email lokal, jadi outsourcing prosesnya adalah pilihan yang populer.

Kami dapat menggunakan Amazon SES untuk mengirim email transaksional, email pemasaran, atau jenis email pemberitahuan lainnya ke klien kami. Ini adalah solusi yang terjangkau untuk bisnis dari semua ukuran yang menggunakan email untuk terhubung dengan pelanggan mereka karena dibangun di atas infrastruktur yang dapat diandalkan dan dapat diskalakan dari Layanan Web Amazon (AWS).

Untuk mengirim email massal, aplikasi apa pun dapat berinteraksi dengan Amazon SES. Kami hanya membayar email yang benar-benar kami kirim, apakah itu email transaksional atau email pemasaran. Selain itu, berbagai konfigurasi, termasuk alamat IP khusus, bersama, atau dimiliki, didukung oleh Amazon SES. Bisnis dapat menghitung setiap email dengan menggunakan dasbor keterkiriman dan laporan tentang informasi pengirim.

Dalam panduan ini kita akan mengonfigurasi instans AWS SES di suatu wilayah dan kemudian mengintegrasikannya Musim Semi Cloud untuk AWS yang merupakan sub-proyek dari Awan Musim Semi. Kami akan mencoba berbagai skenario untuk mengirim email dari aplikasi kami.

Catatan: Anda dapat menemukan semua kode sumber yang digunakan dalam panduan di Github.

Siklus Hidup Pengiriman Email menggunakan AWS SES

Mari kita lihat bagaimana daur hidup email yang dikirim oleh aplikasi sampai ke kotak surat tujuan:

  • Aplikasi, dalam kasus kami, kode Spring Cloud meminta AWS SES untuk mengirim email ke satu atau lebih penerima.

  • SES awalnya memverifikasi permintaan, dan jika disetujui, menghasilkan pesan email dengan spesifikasi permintaan. Pesan email ini memiliki tajuk, badan, dan amplop dan sesuai dengan RFC 5322Definisi Format Pesan Internet.

  • SES kemudian mengirimkan pesan ke penerima penerima melalui Internet. Segera setelah pesan diserahkan ke SES, sering kali dikirim segera, dengan upaya pengiriman awal biasanya dilakukan dalam hitungan milidetik.

  • Ada beberapa hasil saat ini. Contohnya:

    • Pengiriman sukses: Penyedia layanan Internet (ISP) menerima email dan mengirimkannya ke penerima yang dituju.
    • Pantulan Keras: Karena alamat penerima tidak valid, ISP menolak email tersebut. ISP mengirimkan kembali pemberitahuan hard bounce ke Amazon SES, yang memberi tahu pengirim melalui email atau dengan menerbitkannya ke topik Amazon Simple Notification Service (Amazon SNS) yang diatur untuk menerima pemberitahuan ini.
    • Pantulan Lembut: Karena kondisi seperti kotak masuk penerima penuh, domain tidak ada, atau keadaan yang lewat seperti ISP terlalu sibuk untuk memproses permintaan, ISP mungkin tidak dapat mengirimkan email ke penerima. ISP kemudian mencoba lagi email tersebut hingga beberapa kali dan mengirimkan pesan soft bounce kepada SES. Jika SES tidak dapat mengirimkan email dalam jangka waktu yang ditentukan, SES akan menerbitkan acara tersebut ke topik SNS atau mengirimkan pesan hard bounce melalui email.
    • Keluhan: Email diklasifikasikan sebagai spam oleh penerima dalam program email mereka. Pemberitahuan keluhan dikirimkan ke Amazon SES, yang kemudian menyampaikannya ke pengirim jika Amazon SES dan ISP memiliki loop umpan balik yang dibuat.
    • Respon otomatis: ISP penerima memberi tahu Amazon SES tentang tanggapan otomatis dari penerima, seperti pemberitahuan di luar kantor, dan Amazon SES meneruskan pemberitahuan tersebut ke pengirim.

Saat pengiriman tidak berhasil, Amazon SES mengembalikan kesalahan ke pengirim dan menghapus email.

Menyiapkan Amazon SES

Tidak seperti Layanan AWS lainnya, praktis tidak perlu membuat instans SES karena semua akun AWS baru ditempatkan di kotak pasir AWS SES secara default. Setiap akun AWS memiliki akses kotak pasir untuk AWS SES di wilayah yang tersedia secara default.

Saat menggunakan mode kotak pasir, kami hanya dapat mengirim email ke identitas terverifikasi. Domain atau alamat email yang kami gunakan untuk mengirim email adalah identitas yang diverifikasi. Kita harus membangun dan memvalidasi setiap identitas yang ingin kita gunakan sebagai a From, To, Source, Sender, atau Return-Path alamat sebelum kami dapat mengirim email menggunakan SES dalam mode kotak pasir. Dengan menggunakan Amazon SES untuk memverifikasi identitas, kami dapat membuktikan kepemilikan kami dan menghentikan penggunaan ilegal.

Untuk menghindari penipuan dan menjaga reputasi alamat IP, AWS SES menyertakan batas pengiriman email. Batasan ini menentukan jumlah maksimum email per detik dan batas email harian untuk setiap pengguna. Dengan menghubungi Pusat Dukungan AWS, kami dapat menetapkan kuota tersebut berdasarkan wilayah.

Mari kita verifikasi identitas. Masuk ke AWS Console dan cari “Layanan Email Amazon Simple"

Pengantar SES

Kemudian klik "Buat Identitas” untuk menambahkan email atau domain untuk verifikasi. Dalam kasus kami, kami akan menambahkan email untuk verifikasi.

Buat Identitas

Setelah identitas dibuat, kami dapat memverifikasi detailnya.

Identitas Tercipta

Identitas yang kami buat masuk ke “Verifikasi Tertunda" panggung. Pada tahap ini, pengguna perlu memeriksa email verifikasi dari AWS dan mengikuti petunjuk untuk memverifikasi email.

Identitas Terverifikasi

Selanjutnya, kita perlu mengambil "kunci akses"Dan"kunci rahasia” untuk otentikasi dan otorisasi aplikasi kami dengan SES. Untuk membuatnya, kita perlu membuat Grup Pengguna dan menambahkan Pengguna ke grup itu. Saat kami membuat Pengguna itu, AWS membuat kunci akses dan kunci rahasia. Jadi mari kita redirect ke “IAM” di AWS Console dan buat Grup Pengguna.

Buat Grup Pengguna

Kemudian kita perlu menambahkan “Akses Administrator” izin ke grup itu untuk SES.

Tambahkan Izin

Terakhir, kami akan menambahkan Pengguna ke grup di atas.

Tambahkan pengguna

Selanjutnya, kita perlu memilih grup untuk izin.

Tambahkan Grup

Terakhir, salin kunci akses dan kunci rahasia yang ditampilkan di layar untuk penggunaan lebih lanjut.

Mengirim Email menggunakan Proyek Spring Cloud

Pengaturan Proyek

Mari jalankan proyek Spring Cloud dan jalankan melalui kasus penggunaan untuk diintegrasikan dengan SES. Cara termudah untuk memulai dengan proyek kerangka adalah melalui Inisialisasi Musim Semi:

Inisialisasi Musim Semi

Kami telah menambahkan Web Musim Semi untuk REST MVC, Penanda Gratis Apache untuk menghasilkan template email berbasis HTML, Pengirim Surat Jawa untuk mengirim email dan Lombok (perpustakaan pengurang boilerplate opsional). Selain itu, kami perlu menambahkan dependensi yang relevan untuk Spring Cloud AWS dan SES. Untuk Spring Cloud AWS, kami akan menambahkan BOM Spring Cloud AWS terpisah di pom.xml file menggunakan ini blok:

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

Terakhir, untuk menambahkan dukungan untuk SES, kita perlu menyertakan dependensi modul yang tersedia sebagai modul awal spring-cloud-starter-aws-ses:

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

spring-cloud-starter-aws-ses termasuk dependensi transitif untuk spring-cloud-starter-aws, dan spring-cloud-aws-ses. itu spring-cloud-aws-ses modul untuk SES berisi dua kelas: SimpleEmailServiceMailSender dan SimpleEmailServiceJavaMailSender.

  • Grafik SimpleEmailServiceMailSender class menggunakan Amazon Simple Email Service untuk mengirim email. Java Mail API bukan persyaratan untuk implementasi ini. Ini dapat digunakan untuk mengirim pesan email langsung tanpa lampiran.
  • Grafik SimpleEmailServiceJavaMailSender class memungkinkan pengiriman email yang berisi lampiran dan elemen pantomim lainnya.

Jadi ini mencakup semua persyaratan dasar kami!

Mengkonfigurasi Kacang

Seperti dibahas di atas, kita perlu mendefinisikan dua jenis kacang: SimpleEmailServiceMailSender dan SimpleEmailServiceJavaMailSender. Kita cukup meneruskan kunci akses dan kunci rahasia sebagai kredensial dan mengonfigurasi a MailSender kacang yang akan kita gunakan untuk mengirim email:

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

Untuk mengirim email dengan lampiran, kami perlu mengonfigurasi SimpleEmailServiceJavaMailSender yang merupakan implementasi dari JavaMailSender antarmuka dari abstraksi email Spring.

Lihat panduan praktis dan praktis kami untuk mempelajari Git, dengan praktik terbaik, standar yang diterima industri, dan termasuk lembar contekan. Hentikan perintah Googling Git dan sebenarnya belajar itu!

Kami juga akan menentukan properti untuk mengambil informasi dari application.yml:

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

Mengirim Email Sederhana

Kami dapat mengirim email sederhana menggunakan SimpleEmailServiceMailSender kacang yang kami konfigurasikan di atas. Mari kita tentukan lapisan layanan untuk menggunakan kacang ini:

@Service
public class EmailService {

    @Autowired
    private MailSender mailSender;

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

Kami memanggil send() metode dalam MailSender kacang untuk mengirim email kami. Kita juga harus melewati SimpleMailMessage yang akan berisi atribut seperti from, to, teks dan subjek email kami. Jadi, mari kita definisikan a Controller kelas untuk memanggil layanan di atas menggunakan REST API:

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

Sekarang, jika kita menjalankan aplikasi dan menjalankan curl berikut ini akan mengirim email ke alamat email yang diverifikasi:

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'

Selanjutnya, kita dapat login ke alamat email penerima dan memverifikasi apakah penerima telah menerima email tersebut.

Mengirim Email Sederhana dengan Lampiran

Kami akan menentukan lapisan layanan untuk meneruskan lampiran sebagai mime dan menyetel atribut email lainnya seperti from, to, teks dan subjek:

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

Di sini kita gunakan MimeMessageHelper untuk membuat email dengan lampiran. Terakhir, kami akan mendefinisikan Controller lapisan untuk lulus SimpleMailMessage atribut:

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

Sekarang, jika kita menjalankan aplikasi dan menjalankan curl berikut ini akan mengirim email ke alamat email yang diverifikasi:

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'

Selanjutnya, kita dapat login ke alamat email penerima dan memverifikasi apakah penerima telah menerima email tersebut.

Mengirim Template Email dengan Lampiran

Kasus penggunaan sebelumnya yang telah kami lihat bagus untuk skenario pengembangan atau pengujian, tetapi dalam produksi, kami umumnya menggunakan template email dengan variabel yang akan diganti menggunakan respons API. Kami sebelumnya telah menambahkan ketergantungan untuk Penanda Gratis Apache. Kami akan menggunakannya untuk menentukan template dan memuatnya untuk diproses!

Untuk ini, pertama-tama mari kita definisikan template sederhana, beri nama sebagai email-template.ftl dan letakkan di templates folder di bawah 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>

Selanjutnya, kita perlu mendefinisikan class konfigurasi untuk memuat template dari path dan menambahkannya sebagai bean. Untuk ini, kami akan mendefinisikan FreeMarkerConfigurationFactoryBean:

@Configuration
public class FreemarkerConfig {

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

Selanjutnya, kita akan menentukan lapisan layanan kita untuk memuat template ini dan membuat pesan terakhir untuk dikirim ke 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());
        }
    }

Terakhir, kita akan mendefinisikan a Controller lapisan untuk meneruskan atribut email dinamis:

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

Sekarang, jika kita menjalankan aplikasi dan menjalankan curl berikut ini akan mengirim email ke alamat email yang diverifikasi:

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'

Selanjutnya, kita dapat login ke alamat email penerima dan memverifikasi apakah penerima telah menerima email:

Email Templat Penanda Gratis

Mengirim Email yang Dipersonalisasi menggunakan Template di AWS SES

Dalam kasus penggunaan sebelumnya, kami menggunakan template statis untuk mengirim email. Bagaimana kita dapat mengaktifkan template untuk dirancang secara dinamis untuk tujuan yang berbeda dan jenis penerima yang berbeda? AWS SES memungkinkan kami membuat template email untuk mengirim email yang dipersonalisasi ke satu atau beberapa tujuan dalam satu operasi.

Kami dapat membuat hingga 10,000 templat email per akun Amazon SES. Setiap templat dapat berukuran hingga 500 KB, termasuk bagian teks dan HTML. Kami dapat mengirim hingga 50 tujuan dalam setiap panggilan.

Jadi mari kita segera membuat template email. Pertama, kita dapat mendefinisikan file JSON menggunakan template berikut:

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

Template ini berisi atribut berikut:

  • Nama Template: Ini berisi nama template.
  • Bagian Subjek: Ini menyimpan baris subjek email. Tag pengganti mungkin ada pada aset ini. Tag ini diformat sebagai berikut: {{tagname}}. Anda dapat memasukkan nilai untuk {{tagname}} untuk setiap tujuan saat mengirim email.
  • HtmlBagian: Ini berisi badan HTML email dan juga dapat berisi tag pengganti.
  • Bagian Teks: Ini mewakili badan teks email. Versi email ini dikirim ke penerima yang klien emailnya tidak melihat email HTML. Tag pengganti mungkin ada pada aset ini.

Kita dapat menyimpan file ini sebagai mytemplate.json. Akhirnya kita dapat menggunakan perintah AWS CLI untuk membuat template sebagai berikut:

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

Selanjutnya, mari kita tentukan lapisan layanan untuk menentukan atribut dan mengirim email dengan template:

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

Kita bisa menambahkan banyak Destination alamat untuk mengirim email massal ke beberapa penerima. Kami menggunakan sendTemplatedEmail() metode dari AmazonSimpleEmailService antarmuka untuk mengirim email templated ini. Kita juga perlu memberikan tag pengganti untuk diganti dalam teks HTML template kita yang kita buat tadi.

Terakhir, kita akan mendefinisikan a Controller lapisan untuk menentukan REST API untuk meneruskan atribut:

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

Selanjutnya, ketika kami menjalankan aplikasi, kami dapat menjalankan yang berikut ini curl untuk mengirim email template:

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'

Sekarang penerima akhirnya bisa melihat email template:

Email Templat

Minta Akses Produksi

Terakhir, untuk mengirim email ke penerima mana pun, terlepas dari apakah alamat atau domain penerima divalidasi, pada akhirnya kita harus mengeluarkan akun kita dari kotak pasir. Semua identitas kita, termasuk From, Source, Sender, dan Return-Path alamat, masih harus diverifikasi. Kami dapat mengajukan permintaan akses Produksi dari “Dasbor Akun” sebagai berikut:

Dasbor Akun
Minta Akses Produksi

Kami dapat mengirimkan permintaan untuk mengisi semua detail di atas dari AWS Console. Hal yang sama juga dapat dikirimkan menggunakan AWS CLI. Ini akan sangat membantu saat kami perlu meminta akses untuk sejumlah besar identitas dan ingin mengotomatiskan prosesnya.

Kesimpulan

Gagasan utama Amazon Simple Email Service (SES) dan pustaka yang ditawarkan oleh Spring Cloud AWS untuk berinteraksi dengannya tercakup dalam artikel ini. Selain itu, kami membuat aplikasi Spring Boot dengan REST API yang dapat mengirim email melalui modul Spring Cloud AWS SES.

Anda sekarang harus memiliki pemahaman yang kuat tentang apa itu Amazon Simple Email Service (SES) dan bagaimana menggunakannya untuk mengirim email.

Stempel Waktu:

Lebih dari penyalahgunaan