Strategi Komunikasi Antar Service

Ketika membangun aplikasi yang terintegrasi dengan service lain kita perlu memilih strategi yang dilakukan untuk berkomunikasi atau bertukar pesan antar service. Biasanya pada Microservices strategi yang paling umum untuk dilakukan adalah Direct Call menggunakan HTTP. Namun, pendekatan ini belum tentu cocok untuk semua kasus. Ada beberapa pilihan strategi komunikasi yang bisa dipertimbangkan.
Direct Call⌛
Ini adalah strategi yang paling gampang diimplementasi karena kita langsung panggil endpoint service yang dituju lalu tunggu responsenya. Ini ga perlu infrastruktur tambahan sebagai perantara. Bisa dipanggil menggunakan HTTP call kayak REST API, gRPC, graphql, atau sejenisnya. Kalau terjadi error pada service yang dituju atau servicenya ga bisa dihubungi, bisa langsung dihandle saat itu juga. Kekurangannya, ini blocking😴. Setelah dipanggil kita harus menunggu response dari service yang dituju. Kalau responsenya lama maka bakal berdampak juga pada resource dari service yang memanggil karena harus stand by nungguin hasilnya. Secara performa ini menambah latency dari service yang memanggil. Jika komunikasi antar service banyak, maka akan semakin berat beban resource yang digunakan. Ini ga cocok buat fitur yang prosesnya lambat dan bisa dieksekusi independen karena akan berdampak pada service yang memanggil. Ini cocoknya pada fitur yang memang bergantung pada response dari service lain. Misalnya pada pemesanan barang kita perlu call inventory service untuk cek stok. Untuk hal ini kita memang harus nungguin response untuk mendapatkan informasi terkait stok.
public void createOrder(){
//call other service synchronously and wait for response
try(HttpClient client = HttpClient.newHttpClient()){
HttpRequest request = HttpRequest.newBuilder().GET().uri(new URI("http://localhost:8080/stock/product123")).build();
HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
System.out.println("Status Code: " + response.statusCode());
System.out.println("Body: " + response.body());
} catch(Exception e){
//handle exception here
}
doOtherThings(); //executed after previous response received
}Fire & Forget🔥
Ini juga mirip seperti sebelumnya. Bedanya, kita ga perlu nungguin responsenya. Sesuai namanya, setelah dipanggil langsung dilupakan. Kita memanggil service lain secara paralel tanpa perlu tahu responsenya seperti apa. Setelah dipanggil langsung lanjut ke flow berikutnya. Meskipun response dari service yang dituju lambat atau service yang dipanggil banyak, ini ga ngaruh ke latency service yang memanggil karena berjalan asynchronous. Distribusinya At-most-once, bisa berhasil maksimal sekali, tapi bisa ga terkirim sama sekali saat service yang dituju ga bisa dihubungi. Kekurangannya, ini tetap membebani resource dari service yang memanggil. Kita hanya memindahkan HTTP call ke background process tapi masih di service yang sama. Jika service yang dipanggil banyak, beban resource masih ditanggung service yang memanggil. Selain itu, misalkan service tujuan error atau ga bisa dihubungi, maka komunikasinya akan hilang begitu saja karena flownya sudah lanjut ke flow selanjutnya💔. Ini ga cocok buat fitur penting yang harus dihandle jika ada error. Misalnya saat service notifikasi user ga bisa dihubungi, maka notifikasi ga akan pernah terkirim. Ini cocoknya buat fitur yang jika gagal dipanggil ga masalah, dan flownya sangat sederhana sehingga ga banyak makan resource. Misalnya saat mencatat statistik aktivitas dari halaman yang dibuka user, di sini kita hanya meng-increment counter ke service analitik tanpa perlu tahu responsenya apa, dan kalau gagal bukan masalah besar.
public void createOrder(){
//call other service asynchronously
CompletableFuture.runAsync(() -> {
try(HttpClient client = HttpClient.newHttpClient()){
HttpRequest request = HttpRequest.newBuilder().POST().uri(new URI("http://localhost:8080/analytics/page/count")).build();
HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
System.out.println("Status Code: " + response.statusCode());
System.out.println("Body: " + response.body());
} catch(Exception e){
//handle exception here
}
});
doOtherThings(); //executed immediately without waiting previous response
}Publisher & Subscriber📬
Kali ini kita butuh infrastruktur tambahan seperti Message Broker sebagai perantara. Misalnya kita menggunakan Redis PubSub. Service yang mengirim request disebut Publisher, sedangkan yang menerima & memproses request disebut Subscriber. Saat ingin mengirim request ke service lain, kita akan kirim request ke Redis PubSub. Setelah itu langsung lanjut ke flow selanjutnya tanpa perlu tahu responsenya seperti apa sehingga ga ngaruh ke latency. Request akan di-broadcast ke semua service yang jadi Subscriber. Kita bisa daftarkan banyak subscriber agar request di-broadcast sekaligus dalam 1x trigger. Di sini beban resource udah ga ditanggung oleh service yang memanggil meskipun ada banyak komunikasi antar service. Request yang dikirim hanya numpang lewat via Message Broker🚶. Kekurangannya, request yang terkirim akan hilang begitu saja setelah diproses sehingga susah untuk di-trace. Ini cocoknya untuk fitur yang bisa di-broadcast ke beberapa subscriber dalam 1x trigger dan kalau gagal bukan suatu masalah besar.
public class PageCounterPublisher{
private final RedisOperations<String, Object> redisTemplate;
public void publish(Message message) {
redisTemplate.convertAndSend("pageCount", message);
doOtherThings();
}
}public class PageCounterSubscriber implements MessageListener{
@Override
public void onMessage(Message message, byte[] pattern){
//receive message & do incremental counter
}
}public RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory, PageCounterSubscriber subscriber) {
RedisMessageListenerContainer container =
new RedisMessageListenerContainer();
container.setConnectionFactory(connectionFactory);
container.addMessageListener(
subscriber,
new ChannelTopic("pageCount")
);
return container;
}Message Queue📩
Contoh infrastrukturnya adalah RabbitMQ. Saat ingin mengirim request ke service lain, kita akan kirim request ke RabbitMQ lalu lanjut ke flow berikutnya. Di sini request yang dikirim akan disimpan terlebih dahulu ke antrian RabbitMQ. Lalu RabbitMQ akan menghubungi service yang dituju. Kalau ga bisa dihubungi, maka request akan ditunda dan masih tersimpan di antrian. Jika sudah bisa dihubungi, maka request akan diteruskan ke service tujuan dan dihapus dari antrian setelah diproses. Distribusinya by default At-least-once, yaitu request akan diproses minimal sekali, tapi ada kemungkinan akan terproses lebih dari sekali jika ada error saat diproses sehingga perlu handle idempotency dengan baik agar request ga terproses duplikat. By default 1 request akan dikirim ke 1 service tujuan. Misalkan servicenya ada 3 node server dan ada 3 antrian dalam 1 waktu, maka tiap request bisa diproses secara paralel oleh masing-masing service. Loadnya seimbang. Kekurangannya, request ga bisa diulang karena langsung dihapus setelah berhasil diproses. Pada RabbitMQ ini sifatnya Push-based, yaitu RabbitMQ yang akan mengirim request ke service yang dituju. Misalkan request yang dikirim terlalu banyak, maka service yang dituju bisa ga kuat memprosesnya karena RabbitMQ akan mengirim request terus-terusan selama masih ada antrian. Misalnya ada 1000 antrian, sedangkan service tujuan hanya kuat melayani 100, maka RabbitMQ akan tetap mengirimkan 1000 request sampai ga kuat. Ini dikenal dengan istilah Backpressure. Untuk menghindari ini perlu dikonfigurasi dulu jumlah maksimal pengiriman request ke service tujuan. Ini cocok pada fitur yang requestnya bisa rame dan load eksekusinya bisa dibagi ke beberapa server seperti pengiriman email.
@RequiredArgsConstructor
public class MessageProducer{
private final RabbitTemplate rabbitTemplate;
public void sendMessage(String message){
rabbitTemplate.convertAndSend("welcomeEmail", "", message);
doOtherThings();
}
}public class EmailConsumer{
@RabbitListener(queues = "welcomeEmail")
public void receiveMessage(String message){
//process email here
}
}Event Streaming📡
Contoh infrastrukturnya adalah Kafka sama Redis Streams. Service yang mengirim request disebut Producer. Service yang menerima & memproses request disebut Consumer. Di sini request akan disimpan ke perantara, misalnya di Redis Streams sehingga request ga akan hilang meskipun Consumer sedang ga bisa berkomunikasi dan request bisa diproses lagi saat Consumer sudah normal kembali. Request tersebut ga dihapus otomatis sehingga bisa diulang jika diperlukan. Pada Kafka & Redis Stream, ini sifatnya Pull-based, yaitu Consumer yang akan melakukan polling menjemput data request ke Broker. Jadi, setelah request dikirim ke Redis, request akan disimpan ke dalam Stream. Lalu Consumer menjemput request yang tersimpan & belum diproses. Setelah diproses, maka Consumer perlu mengubah statusnya menjadi “Acknowledge” dan ditandai bahwa request sudah berhasil diproses. Request yang berhasil diproses ga terhapus otomatis sehingga bisa diulang jika diperlukan. Di sini Consumer yang bebas menjemput seberapa banyak request yang mau diproses, bukan pasrah aja menerima semua request dari antrian sehingga aman dari Backpressure. Misalkan ada 1000 antrian dan Consumer hanya kuat handle 100, maka 1000 antrian itu tersimpan doang di Stream. Consumer hanya akan menjemput request tiap 100 data, ga semuanya sekaligus. Jika node servernya lebih dari 1, kita bisa pasang consumer group agar diprosesnya per group service. Jadi, 1 request untuk service yang sama walaupun servernya ada banyak ga akan dieksekusi berkali-kali. Jaman sekarang strategi ini cukup populer pada Event Driven Architecture karena komunikasinya ga gampang putus, jika terjadi masalah bisa di-trace dengan mudah lewat data yang tersimpan😎. Distribusinya juga At-least-once dan perlu handle idempotency. Kekurangannya, ini butuh resource untuk menyimpan data request pada perantara karena semua request disimpan di sana dan ga dihapus otomatis setelah diproses. Ini cocok untuk hal-hal kompleks, bisa diulang, dan peluang kegagalannya harus minim seperti payment, generate report, kirim notifikasi penting, dan sebagainya.
@RequiredArgsConstructor
public class ReportGenerationProducer{
private final StringRedisTemplate redisTemplate;
public void generate(Report report) {
Map<String, String> payload = new HashMap<>();
payload.put("reportId", String.valueOf(report.getId()));
redisTemplate.opsForStream()
.add("ReportGenerationStream", payload);
}
}@RequiredArgsConstructor
public class ReportGenerationConsumer implements StreamListener<String, MapRecord<String, String, String>>{
private final StringRedisTemplate redisTemplate;
@Override
public void onMessage(MapRecord<String, String, String> message){
try{
process(message);
redisTemplate.opsForStream().acknowledge(
"ReportGenerationGroup",
message
);
} catch(Exception e){
//handle exception here
}
}
}Verdict
Itulah 5 strategi untuk komunikasi antar service. Yang paling gampang adalah dengan Direct Call, tapi komunikasinya jadi blocking, beban ditanggung service yang memanggil, dan request bisa hilang di tengah jalan. Yang paling kompleks adalah menggunakan Event Streaming, tapi dengan ini komunikasinya non-blocking, request aman tersimpan tanpa takut hilang di tengah jalan, dan beban ditanggung perantara meskipun butuh resource untuk menyimpan data pada perantara. Semuanya punya kelebihan dan kekurangan masing-masing. Fitur pada masing-masing infrastruktur antara PubSub, Message Queue, dan Message Stream memiliki pendekatan berbeda untuk menyelesaikan masalah masing-masing sehingga cara kerja ketiganya terlihat mirip dan perbedaannya tipis. Tinggal disesuaikan aja berdasarkan kasus yang dihadapi.
