Belajar Membuat gRPC Microservice dengan LINE Armeria dan Spring WebFlux

Apa itu Microservice

Bicara soal microservice berarti kita sedang membahas tentang arsitektur suatu aplikasi.

Di masa lalu umumnya aplikasi dikembangkan dengan cara monolith. Seperti dari namanya “mono” yang berarti satu, istilah monolith merupakan metode pengembangan aplikasi dimana arsitektur sistemnya meletakkan semua komponen dan layanan berada pada satu kesatuan layanan.

Bisa dibayangkan itu layaknya sebuah sport center di mana semua fasilitas olahraga ada di sana. Mulai lapangan sepak bola, atletik, renang dan sebagainya. Ini tentu menguntungkan dalam hal pengembangan dan pengelolaan karena semuanya berada dalam satu bagian.

Kelemahannya, jika salah satu layanan bermasalah, lainnya bisa terpengaruh. Selain itu, banyaknya layanan yang dikelola akan menyulitkan penanganan saat muncul problem karena kita harus mencari yang mana sumber masalah di antara layanan-layanan tersebut.

Pendekatan lain yang biasa digunakan yaitu microservice. Microservice yaitu metode pengembangan aplikasi yang arsitektur sistemnya memisahkan tiap komponen dan layanan pada tempat yang berbeda.

Karena pada pola microservice semua layanan berdiri sendiri, maka satu sama lain tidak akan saling mempengaruhi. Jika terjadi masalah, hanya satu layanan saja yang berdampak, sedangkan layanan lain tetap dapat digunakan.

Namun demikian, microservice yang banyak akan otomatis memerlukan lebih banyak perhatian demi menangani setiap layanan yang dikembangkan. Pun jika suatu saat ada keperluan mengubah hal umum, kita perlu mengubah tiap layanan satu per satu. Repot kan?

Apa itu gRPC

Pada pengembangan dengan arsitektur microservice, antar layanan sangat mungkin memiliki lingkungan sistem maupun bahasa pemrograman yang berbeda. Untuk itu diperlukanlah suatu mekanisme di mana antar layanan dapat saling berkomunikasi dan bertukar data. Mekanisme inilah yang kita sebut Remote Procedure Call(RPC).

RPC yang dipasang pada suatu layanan microservice akan membuka sebuah jalur komunikasi data (socket) dengan alamat terentu (port) yang dapat diakses oleh client untuk dapat saling bertukar informasi dan data yang dibutuhkan.

gRPC Concept Diagram

gRPC merupakan salah satu framework RPC open source yang dikembangkan oleh Google. Pada gRPC aplikasi klien dapat secara langsung memanggil metode pada aplikasi server pada mesin yang berbeda seolah-olah itu adalah objek lokal. Anda jadi mudah membuat aplikasi dan layanan pun terdistribusi. [ rujukan]

Pembuatan Microservice dengan Spring WebFlux

Perangkat Lunak

Sebelum mulai membuat microservice, silakan pasang perangkat lunak berikut pada sistem operasi Anda.

  1. Java Development Kit (JDK)
    Silakan gunakan JDK versi 8 atau yang terbaru (rekomendasi: JDK Versi 11). Unduh di sini.
  2. Code Editor
    Silakan gunakan IntelliJ IDEA Community Edition versi terbaru. Unduh di sini.

Mengatur Versi JDK pada IntelliJ

  1. Buka IntelliJ dan pilih [Configure] – [Structure for New Projects]
  2. Sekarang Anda akan melihat <No SDK> pada Project SDK
  3. Klik tombol [New] dan pilih [JDK]
  4. Tentukan letak direktori JAVA_HOME
  5. Cek kembali JDK apakah sudah terpasang dengan benar

Memasang Plugin

  1. Pada IntelliJ, silakan buka [Settings] kemudian pilih [Plugins]
  2. Pasang plugin “Lombok”
  3. Setelah plugin Lombok terpasang, silakan aktifkan [Enable annotation processing]
  4. Pasang plugin “Protobuf Support”

Menyiapkan Repositori

Silakan kloning repositori berikut ini ke komputer lokal Anda kemudian lakukan “git checkout” ke branch“chapter-0”. Selanjutnya buka repositori tersebut melalui IntelliJ. Langkah-langkahnya sebagai berikut:

  1. Pada IntelliJ pilih [Import Project] lalu tentukan letak direktori repositori yang telah Anda kloning sebelumnya
  2. Pilih [Gradle] dan klik [Finish]

Menjalankan Konfigurasi

  1. Setelah selesai mengimpor proyek, Anda dapat melihat pohon proyek di bagian kiri.
  2. Buka direktori src – main – resources
  3. Buat berkas bernama application.yml
  4. Isikan kode berikut untuk menyalakan mode debugging

  5. Buka direktori src – main – java – com.linecorp.devday.handson.demo
  6. Anda akan menemukan berkas DemoApplication.class pada langkah terakhir
  7. Klik kanan pada DemoApplication, dan pilih [Run ‘DemoApplication.main()’]
  8. Akan muncul logo Spring, dan Anda sekarang sudah memasuki dunia Spring!

Membuat Controller dan Service

  1. Buka direktori src – main – java – com.linecorp.devday.handson.demo
  2. Buat package baru bernama controller
  3. Buat berkas baru bernama DemoController.java
  4. Isikan kode seperti berikut ini
  5. Buat lagi package baru bernama sevice
  6. Buat berkas baru bernama DemoService
  7. Isikan kode berikut
  8. Jalankan ulang DemoApplication hingga muncul informasi seperti ini
  9. Uji service yang telah kita buat dengan mengakses halaman /hello yang telah dibuat
  10. Pada log akan terlihat seperti ini

gRPC Microservice dengan LINE Armeria

Sampai tahap ini berarti Anda sudah bisa membuat microservice sendiri menggunakan spring webflux. Namun, microservice terseput belum dapat diakses melalui jalur gRPC. Untuk menambahkan fitur ini, kita akan memasang LINE Armeria ke proyek kita.

Menambahkan LINE Armeria

  1. Buka berkas  build.graddle kemudian tambahkan dependency management berikut ini di akhir konfigurasi.
  2. Pada bagian dependencies, tambahkan armeria-spring-boot-webflux-starter
  3. Lakukan sync gradle untuk mengunduh dependency yang baru saja ditambahkan

Membuat Konfigurasi Armeria

  1. Buka kembali direktori src – main – java – com.linecorp.devday.handson.demo
  2. Buat package baru bernama configuration
  3. Buat berkas baru bernama ArmeriaServerConfiguration
  4. Isikan kode berikut

    Keterangan:

  5. Jalankan kembali DemoApplication
  6. Perhatikan pada log. Akan ada perubahan berikut:
    • Implementasi server berubah ke Armeria
    • Akses I/O ditampilkan ke Log

Mengaplikasikan gRPC

  1. Buka kembali build.graddle
  2. Tambahkan plugin protobuf
  3. Tambahkan armeria-grpc ke dependencies
  4. Tambahkan protobuf metadata di akhir dokumen build.gradle
  5. Tambahkan pula sourceSets di bawahnya
  6. Lakukan sync gradle

Membuat Proto

Secara default, gRPC menggunakan buffer protokol, mekanisme open source Google yang matang untuk membuat serialisasi data terstruktur (meskipun dapat digunakan dengan format data lain seperti JSON).

Langkah pertama ketika bekerja dengan buffer protokol adalah menentukan struktur untuk data yang ingin Anda serialkan dalam berkas proto. Proto adalah berkas teks biasa dengan ekstensi .proto. Protokol data buffer disusun sebagai pesan (message), di mana setiap pesan adalah catatan kecil logika dari informasi yang berisi serangkaian pasangan nama-nilai yang disebut bidang (fields).

Caranya sebagai berikut:

  1. Buat package baru pada /src/main bernama proto
  2. Buat berkas bernama demo_grpc_proto.proto pada package /src/main/proto
  3. Isikan kode berikut:
  4. Jalankan perintah generateProto dengan Gradle wrapper untuk meng-compile berkas .proto
  5. Periksa hasilnya apakah sudah ter-compile dan apakah berkas .java sudah terbuat dengan benar

Menambahkan Service

  1. Buka kembali direktori src – main – java – com.linecorp.devday.handson.demo
  2. Pada package sevice buat file baru bernama DemoGrpcService
  3. Isikan kode berikut
  4. Tambahkan GrpcService.builder() ke ArmeriaServerConfiguration
  5. Jalankan kembali DemoApplication

Sampai tahap ini aplikasi yang telah kita buat telah dapat berkomunikasi data menggunakan gRPC. Untuk mengeceknya, kita perlu membuat microservice dari sisi client-nya. Namun pada tutorial ini kita tidak membahas cara pembuatannya.

Mengaktifkan Layanan Dokumentasi

Menggunakan Armeria, kita tidak perlu repot untuk membuat dokumentasi penggunaan microservice. Halaman dokumentasi akan terbuat secara otomatis dengan menambahkan sedikit kode berikut:

  1. Buka ArmeriaServerConfiguration
  2. Pada bagian registrasi service, ubah menjadi seperti berikut:
  3. Jalankan ulang DemoApplication
  4. Sekarang Anda sudah dapat mengakses dokumentasi melalui halaman berikut: http://localhost:8080/docs/
  5. Selanjutnya, uji coba service hello() yang tadi telah kita buat
    1. Masuk ke menu POST Hello()
    2. Gulir ke bawah pada bagian Debug
    3. Masukkan data yang ingin dikirim pada bagian [REQUEST BODY]
    4. Klik tombol [SUBMIT]
    5. Lihat data yang masuk pada log

References

Penutup

Jika Anda mengalami kesulitan mengikuti tutorial ini, Anda dapat memeriksa langkah demi langkah solusinya pada “git branch” mulai dari “chapter-0” sampai dengan “chapter-3”.

Tulisan kali ini merupakan oleh-oleh yang penulis pelajari saat mengikuti LINE Developer Day 2019 di Tokyo bulan November kemaren. Jika kalian masih penasaran dengan materi lainnya dari LINE Developer Day 2019, silakan ikuti tautan berikut ya:

  1. Membuat Module Bundler Sendiri ala Front-end Engineer LINE
  2. Evolusi LINE Things dan Produk yang Dirilis

Belajar mengembangkan aplikasi atau game dengan kurikulum yang telah divalidasi langsung oleh industri dengan Dicoding Academy.

Belajar di Dicoding Sekarang →
Share this:

Product Engineer at Dicoding Indonesia (LINE API Expert, IoT Enthusiast)