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 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
   
   
   1 2 3

   logging:   level:     ROOT: DEBUG

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
   
   Java

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

   @Controller @AllArgsConstructor public class DemoController {       private final DemoService demoService;       @GetMapping("/hello")     @ResponseBody     public Mono<String> getHello() {           return demoService.getHello();       }   }

5. Buat lagi package baru bernama sevice
6. Buat berkas baru bernama DemoService
7. Isikan kode berikut
   
   Java

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   @Slf4j     @Service     @RequiredArgsConstructor     public class DemoService {              public Mono<String> getHello() {                  log.debug("Welcome Hello World");                  return Mono.just("Hello World");              }          }

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.
   
   1 2 3 4 5

   dependencyManagement {         imports {                 mavenBom 'com.linecorp.armeria:armeria-bom:0.96.0'         } }

2. Pada bagian dependencies, tambahkan armeria-spring-boot-webflux-starter
   
   1 2 3 4 5 6 7 8 9 10 11 12 13

   dependencies {         implementation 'org.springframework.boot:spring-boot-starter-webflux'                  // tambahkan baris ini         implementation 'com.linecorp.armeria:armeria-spring-boot-webflux-starter'           compileOnly 'org.projectlombok:lombok'         annotationProcessor 'org.projectlombok:lombok'         testImplementation('org.springframework.boot:spring-boot-starter-test') {                 exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'         }         testImplementation 'io.projectreactor:reactor-test' }

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
   
   Java

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

   @Configuration     public class ArmeriaServerConfiguration {              @Bean         public ArmeriaServerConfigurator armeriaServerConfigurator() {                  return serverBuilder -> {                      serverBuilder.decorator(LoggingService.newDecorator());                 serverBuilder.accessLogWriter(AccessLogWriter.combined(), false);                  };              }          }

   
   Keterangan:
   • LoggingService.newDecorator()
     Mengirimkan semua data yang masuk/keluar dari server ke log
   • AccessLogWriter.combined()
     Menampilkan log ke server apache httpd (lihathttps://httpd.apache.org/docs/2.4/en/logs.html)
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
   
   1 2 3 4 5 6 7 8

   plugins {    id 'org.springframework.boot' version '2.2.1.RELEASE'    id 'io.spring.dependency-management' version '1.0.8.RELEASE'    id 'java'     // tambahkan baris ini    id 'com.google.protobuf' version '0.8.10' }

3. Tambahkan armeria-grpc ke dependencies
   
   Java

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   dependencies {    implementation 'org.springframework.boot:spring-boot-starter-webflux'    implementation 'com.linecorp.armeria:armeria-spring-boot-webflux-starter'      // tambahkan baris ini    implementation 'com.linecorp.armeria:armeria-grpc'      compileOnly 'org.projectlombok:lombok'    annotationProcessor 'org.projectlombok:lombok'    testImplementation('org.springframework.boot:spring-boot-starter-test') {       exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'    }    testImplementation 'io.projectreactor:reactor-test' }

4. Tambahkan protobuf metadata di akhir dokumen build.gradle
   
   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

   protobuf {         protoc {                 artifact = "com.google.protobuf:protoc:3.10.0"         }         plugins {                 grpc {                         artifact = 'io.grpc:protoc-gen-grpc-java:1.25.0'                 }         }         generateProtoTasks {                 all()*.plugins {                         grpc {}                 }                 all().each { task ->                         task.generateDescriptorSet = true                         task.descriptorSetOptions.includeSourceInfo = true                         task.descriptorSetOptions.includeImports = true                         task.descriptorSetOptions.path =                                         "${buildDir}/resources/main/META-INF/armeria/grpc/service-name.dsc"                 }         } }

5. Tambahkan pula sourceSets di bawahnya
   
   Java

   1 2 3 4 5 6 7 8

   sourceSets {    main {       java {          srcDir 'build/generated/source/proto/main/grpc'          srcDir 'build/generated/source/proto/main/java'       }    } }

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:
   
   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

   syntax = "proto3";   package com.linecorp.devday.handson.demo.proto; option java_package = "com.linecorp.devday.handson.demo.proto";   service Demo {     rpc Hello (DemoGrpcRequest) returns (DemoGrpcResponse); }   message DemoGrpcRequest {     string message = 1; }   message DemoGrpcResponse {     string message = 1; }

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
   
   Java

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

   @Slf4j @Service @AllArgsConstructor public class DemoGrpcService extends DemoGrpc.DemoImplBase {       private final DemoService demoService;       @Override     public void hello(             DemoGrpcProto.DemoGrpcRequest request,             StreamObserver<DemoGrpcProto.DemoGrpcResponse> responseObserver) {           String message = request.getMessage();         log.debug("MESSAGE FROM GRPC REQUEST : {}", message);           demoService.getHello()                 .map(s -> DemoGrpcProto.DemoGrpcResponse.newBuilder().setMessage(s).build())                 .subscribe(                         demoGrpcResponse    -> responseObserver.onNext(demoGrpcResponse),                         cause               -> responseObserver.onError(cause),                         ()                  -> responseObserver.onCompleted()                 );       }   }

4. Tambahkan GrpcService.builder() ke ArmeriaServerConfiguration
   
   Java

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

   @Bean public ArmeriaServerConfigurator armeriaServerConfigurator() {       return serverBuilder -> {           serverBuilder.decorator(LoggingService.newDecorator());         serverBuilder.accessLogWriter(AccessLogWriter.combined(), false);           // tambahkan baris kode ini         serverBuilder.service(GrpcService.builder()                 .addService(demoGrpcService)                 .build());     };   }

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

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

   @Bean public ArmeriaServerConfigurator armeriaServerConfigurator() {       return serverBuilder -> {           serverBuilder.decorator(LoggingService.newDecorator());         serverBuilder.accessLogWriter(AccessLogWriter.combined(), false);           serverBuilder.service(GrpcService.builder()                 .addService(demoGrpcService)                   // tambahkan baris kode ini                 .supportedSerializationFormats(GrpcSerializationFormats.values())                 .enableUnframedRequests(true)                 //                   .build());           // tambahkan baris kode ini         serverBuilder.serviceUnder("/docs", new DocService());       };   }

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

• Sesi: What a BOOTiful microservice with Armeria + WebFlux
• Berkas Presentasi: di sini
• Dokumentasi https://github.com/joonhaeng/line-devday-2019-hands-on-docs
• Repositori https://github.com/joonhaeng/line-devday-2019-hands-on-src
• gRPC Guides https://grpc.io/docs/guides/
• Spring Project Starter https://start.spring.io/
• Github LINE Armeria https://github.com/line/armeria
• Armeria Examples https://github.com/line/armeria-examples

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