{"id":33148,"date":"2026-09-14T07:01:16","date_gmt":"2026-09-14T07:01:16","guid":{"rendered":"https:\/\/hosteko.com\/blog\/?p=33148"},"modified":"2026-09-14T07:01:16","modified_gmt":"2026-09-14T07:01:16","slug":"mengenal-service-discovery","status":"publish","type":"post","link":"https:\/\/hosteko.com\/blog\/mengenal-service-discovery","title":{"rendered":"Mengenal Service Discovery: Teknologi yang Membuat Microservices Lebih Fleksibel"},"content":{"rendered":"

Dalam aplikasi modern, terutama yang menggunakan microservices<\/em>, sebuah aplikasi biasanya tidak hanya terdiri dari satu server atau satu komponen. Sebaliknya, aplikasi dapat dibangun dari banyak service yang saling berkomunikasi untuk menjalankan fungsi tertentu.<\/p>\n

Masalahnya, lokasi setiap service tidak selalu tetap. Sebuah service dapat berpindah server, memiliki beberapa instance, menggunakan alamat IP yang berbeda, atau mengalami perubahan jumlah instance karena proses scaling.<\/p>\n

Service Discovery membantu aplikasi menemukan lokasi service lain secara otomatis tanpa harus menyimpan alamat IP dan port setiap service secara manual. Dengan mekanisme ini, komunikasi antarservice dapat menjadi lebih fleksibel, terutama pada lingkungan cloud, container, dan microservices.<\/p>\n

Lalu, apa itu Service Discovery, bagaimana cara kerjanya, dan mengapa teknologi ini penting dalam arsitektur aplikasi modern?<\/p>\n

Apa Itu Service Discovery?<\/h2>\n

Service Discovery adalah mekanisme yang memungkinkan aplikasi menemukan lokasi service lain secara otomatis dalam sebuah jaringan. Informasi yang ditemukan dapat berupa alamat IP, hostname, port, nama service, dan status instance.<\/p>\n

Pada aplikasi sederhana, alamat service biasanya ditentukan secara langsung melalui konfigurasi. Namun, cara ini menjadi kurang praktis pada arsitektur microservices karena satu service dapat memiliki banyak instance dengan alamat yang berbeda dan dapat berubah sewaktu-waktu.<\/p>\n

Service Discovery membantu mengatasi masalah tersebut dengan menyediakan informasi mengenai endpoint yang tersedia. Dengan begitu, service dapat saling berkomunikasi tanpa harus bergantung pada alamat IP tertentu dan tanpa melakukan konfigurasi secara manual setiap kali terjadi perubahan infrastruktur.<\/p>\n

Mengapa Service Discovery Dibutuhkan?<\/h2>\n

Dalam sistem tradisional, aplikasi biasanya berkomunikasi dengan server yang memiliki alamat relatif tetap.<\/p>\n

Misalnya: Aplikasi \u2192 192.168.1.10:8080
\n<\/code><\/p>\n

Masalah mulai muncul ketika aplikasi berkembang dan menggunakan banyak service. Contohnya:<\/p>\n

Frontend\r\n   \u2193\r\nAPI Service\r\n   \u2193\r\nUser Service\r\n   \u2193\r\nPayment Service\r\n   \u2193\r\nNotification Service\r\n<\/code><\/pre>\n
Masing-masing service dapat berjalan pada server atau container yang berbeda. Jika setiap service harus mengetahui alamat IP service lainnya secara manual, pengelolaan sistem akan menjadi semakin sulit.<\/p>\n
Service Discovery memberikan pendekatan yang lebih dinamis. Alih-alih aplikasi mengetahui alamat IP secara langsung, aplikasi cukup mengetahui nama service: payment-service
\n<\/code>, Kemudian Service Discovery membantu menemukan endpoint yang tersedia untuk service tersebut.<\/p>\n
\"\"<\/p>\n
Bagaimana Cara Kerja Service Discovery?<\/h2>\n
Secara sederhana, Service Discovery bekerja dengan menyimpan informasi mengenai service yang tersedia dan lokasi instance-nya. Alur dasarnya dapat digambarkan seperti berikut:<\/p>\n
Service A\r\n   \u2502\r\n   \u2502 mencari \"Service B\"\r\n   \u25bc\r\nService Discovery\r\n   \u2502\r\n   \u2502 memberikan endpoint\r\n   \u25bc\r\nService B\r\n<\/code><\/pre>\n
Prosesnya biasanya melibatkan beberapa tahap.<\/p>\n
1. Service Mendaftarkan Diri<\/span><\/p>\n
Ketika sebuah service dijalankan, service tersebut mendaftarkan informasi dirinya ke sistem Service Discovery. Misalnya:<\/p>\n
Nama: payment-service\r\nIP: 10.0.0.15\r\nPort: 8080\r\nStatus: healthy\r\n<\/code><\/pre>\n
Informasi ini kemudian disimpan dalam registry.<\/p>\n
2. Service Discovery Menyimpan Informasi<\/span><\/p>\n
Service Discovery menyimpan daftar service beserta endpoint yang tersedia. Contohnya:<\/p>\n
user-service \u2192 10.0.0.10:8080\r\npayment-service \u2192 10.0.0.15:8080\r\nnotification-service \u2192 10.0.0.20:8080\r\n<\/code><\/pre>\n
Jika sebuah service memiliki beberapa instance, semuanya dapat dicatat.<\/p>\n
payment-service\r\n\u251c\u2500\u2500 10.0.0.15:8080\r\n\u251c\u2500\u2500 10.0.0.16:8080\r\n\u2514\u2500\u2500 10.0.0.17:8080\r\n<\/code><\/pre>\n
3. Service Lain Mencari Service yang Dibutuhkan<\/span><\/p>\n
Ketika order-service<\/code> ingin berkomunikasi dengan payment-service<\/code>, order-service<\/code> tidak perlu mengetahui IP address setiap instance. Service tersebut cukup mencari: payment-service, <\/code>Service Discovery kemudian memberikan informasi mengenai instance yang tersedia.<\/p>\n
4. Request Dikirim ke Instance yang Tersedia<\/span><\/p>\n
Setelah mendapatkan endpoint, request dapat dikirim ke instance yang sesuai. Jika terdapat beberapa instance, sistem dapat memilih salah satu berdasarkan mekanisme tertentu, misalnya load balancing.<\/p>\n
5. Instance yang Tidak Sehat Dapat Dikeluarkan<\/span><\/p>\n
Service Discovery biasanya dapat dikombinasikan dengan mekanisme health check. <\/em>Jika sebuah instance tidak lagi sehat atau tidak dapat diakses, endpoint tersebut dapat ditandai tidak tersedia sehingga request berikutnya tidak diarahkan ke instance tersebut.<\/p>\n
Apa Itu Service Registry?<\/h2>\n
Service Registry adalah tempat penyimpanan informasi mengenai service dan endpoint yang tersedia dalam sebuah sistem. Service Registry menjadi salah satu komponen penting dalam Service Discovery. Contohnya:<\/p>\n\n\n\n\n\n\n\n\n
Service<\/th>\nEndpoint<\/th>\nStatus<\/th>\n<\/tr>\n<\/thead>\n
User Service<\/td>\n10.0.0.10:8080<\/td>\nHealthy<\/td>\n<\/tr>\n
Payment Service<\/td>\n10.0.0.11:8080<\/td>\nHealthy<\/td>\n<\/tr>\n
Payment Service<\/td>\n10.0.0.12:8080<\/td>\nHealthy<\/td>\n<\/tr>\n
Notification Service<\/td>\n10.0.0.13:8080<\/td>\nUnhealthy<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Registry memungkinkan sistem mengetahui service apa saja yang tersedia dan ke mana request dapat diarahkan. Informasi tersebut dapat berubah secara dinamis ketika instance ditambahkan, dihapus, atau mengalami gangguan.<\/p>\n
Apa Itu Service Registration?<\/h2>\n
Service Registration adalah proses ketika sebuah service mendaftarkan dirinya ke Service Registry. Misalnya ketika container baru menjalankan payment-service<\/code>, service tersebut dapat melakukan registrasi:<\/p>\n
Nama Service: payment-service\r\n\r\nEndpoint: 10.0.0.15:8080\r\n<\/code><\/pre>\n
Setelah terdaftar, service lain dapat menemukan endpoint tersebut melalui Service Discovery. Registrasi dapat dilakukan secara otomatis ketika service mulai berjalan.<\/p>\n
Apa Itu Service Deregistration?<\/h2>\n
Selain mendaftarkan service, sistem juga perlu mengetahui ketika sebuah instance sudah tidak tersedia. Proses menghapus atau menandai instance dari registry disebut service deregistration. Misalnya:<\/p>\n
payment-service\r\n\u251c\u2500\u2500 10.0.0.15:8080\r\n\u251c\u2500\u2500 10.0.0.16:8080\r\n\u2514\u2500\u2500 10.0.0.17:8080\r\n<\/code><\/pre>\n
Kemudian instance 10.0.0.16<\/code> dihentikan. Registry perlu memperbarui informasi menjadi:<\/p>\n
payment-service\r\n\u251c\u2500\u2500 10.0.0.15:8080\r\n\u2514\u2500\u2500 10.0.0.17:8080\r\n<\/code><\/pre>\n
Dengan demikian, request tidak lagi diarahkan ke instance yang sudah tidak tersedia.<\/p>\n
Apa Itu Health Check dalam Service Discovery?<\/h2>\n
Health check adalah mekanisme untuk memeriksa apakah sebuah service atau instance masih dapat menerima request dengan baik. Health check sangat penting karena service yang masih tercatat di registry belum tentu benar-benar dapat digunakan. Contohnya:<\/p>\n
payment-service\r\n10.0.0.15:8080 \u2192 Healthy\r\n10.0.0.16:8080 \u2192 Unhealthy\r\n10.0.0.17:8080 \u2192 Healthy\r\n<\/code><\/pre>\n
Ketika request datang, sistem dapat menghindari instance yang berstatus Unhealthy<\/code>. Health check dapat dilakukan melalui beberapa metode, tergantung platform dan arsitektur yang digunakan.<\/p>\n
Jenis Service Discovery<\/h2>\n
Secara umum, Service Discovery sering dibagi menjadi dua pendekatan utama, yaitu client-side discovery dan server-side discovery.<\/p>\n
1. Client-Side Service Discovery<\/span><\/p>\n
Pada client-side discovery, client bertanggung jawab mencari service yang ingin digunakan. Alurnya:<\/p>\n
Client\r\n  \u2193\r\nService Registry\r\n  \u2193\r\nMendapatkan endpoint\r\n  \u2193\r\nService\r\n<\/code><\/pre>\n
Misalnya order-service<\/code> ingin mengakses payment-service<\/code>. order-service<\/code> terlebih dahulu meminta informasi endpoint kepada Service Registry. Setelah mendapatkan endpoint, order-service<\/code> mengirimkan request langsung ke instance yang dipilih.<\/p>\n
Kelebihan pendekatan ini adalah client memiliki kontrol lebih besar terhadap proses pemilihan instance. Namun, client membutuhkan mekanisme atau library untuk berinteraksi dengan Service Registry dan melakukan pemilihan endpoint.<\/p>\n
2. Server-Side Service Discovery<\/span><\/p>\n
Pada server-side discovery, client tidak perlu mencari endpoint secara langsung. Request dikirim terlebih dahulu ke komponen yang bertanggung jawab menemukan service. Alurnya:<\/p>\n
Client\r\n  \u2193\r\nLoad Balancer \/ Proxy\r\n  \u2193\r\nService Discovery\r\n  \u2193\r\nService Instance\r\n<\/code><\/pre>\n
Komponen seperti load balancer, proxy, atau gateway dapat membantu menentukan instance yang akan menerima request. Pendekatan ini membuat client lebih sederhana karena logika discovery tidak perlu diimplementasikan pada setiap service. Namun, infrastruktur tambahan perlu dikelola untuk menangani proses tersebut.<\/p>\n
Perbedaan Client-Side dan Server-Side Discovery<\/h2>\n\n\n\n\n\n\n\n\n\n\n
Aspek<\/th>\nClient-Side<\/th>\nServer-Side<\/th>\n<\/tr>\n<\/thead>\n
Pencarian service<\/td>\nDilakukan client<\/td>\nDilakukan komponen server\/proxy<\/td>\n<\/tr>\n
Client<\/td>\nLebih kompleks<\/td>\nRelatif lebih sederhana<\/td>\n<\/tr>\n
Registry<\/td>\nDiakses client<\/td>\nDapat diakses proxy atau komponen infrastruktur<\/td>\n<\/tr>\n
Pemilihan instance<\/td>\nClient<\/td>\nLoad balancer\/proxy<\/td>\n<\/tr>\n
Fleksibilitas<\/td>\nTinggi<\/td>\nBergantung pada infrastruktur<\/td>\n<\/tr>\n
Pengelolaan<\/td>\nLogika discovery berada di aplikasi<\/td>\nLebih banyak ditangani infrastruktur<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Tidak ada pendekatan yang selalu paling baik. Pemilihannya bergantung pada arsitektur, platform, kebutuhan operasional, dan teknologi yang digunakan.<\/p>\n
Service Discovery dalam Arsitektur Microservices<\/h2>\n
Service Discovery sangat erat kaitannya dengan microservices. Dalam arsitektur microservices, aplikasi besar dipecah menjadi beberapa service yang memiliki tanggung jawab berbeda. Contohnya:<\/p>\n
                    \u250c\u2500 User Service\r\n                    \u2502\r\nAPI Gateway \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253c\u2500 Order Service\r\n                    \u2502\r\n                    \u251c\u2500 Payment Service\r\n                    \u2502\r\n                    \u2514\u2500 Notification Service\r\n<\/code><\/pre>\n
Setiap service dapat berjalan secara independen dan memiliki instance yang berbeda. Misalnya ketika traffic meningkat, order-service<\/code> dapat diperbanyak:<\/p>\n
order-service\r\n\u251c\u2500\u2500 Instance 1\r\n\u251c\u2500\u2500 Instance 2\r\n\u251c\u2500\u2500 Instance 3\r\n\u2514\u2500\u2500 Instance 4\r\n<\/code><\/pre>\n
Service Discovery membantu service lain mengetahui instance mana yang tersedia. Tanpa mekanisme discovery, pengelolaan alamat endpoint dalam lingkungan yang dinamis dapat menjadi lebih sulit.<\/p>\n
Service Discovery pada Cloud dan Container<\/h2>\n
Service Discovery semakin penting ketika aplikasi dijalankan pada lingkungan cloud dan container. Pada lingkungan tersebut, instance dapat dibuat dan dihentikan secara dinamis. Contohnya:<\/p>\n
Traffic meningkat\r\n      \u2193\r\nInstance baru dibuat\r\n      \u2193\r\nService mendaftarkan endpoint\r\n      \u2193\r\nService Discovery memperbarui registry\r\n      \u2193\r\nRequest dapat diarahkan ke instance baru\r\n<\/code><\/pre>\n
Ketika traffic menurun, beberapa instance dapat dihentikan kembali. Service Discovery membantu mengikuti perubahan tersebut tanpa mengharuskan developer memperbarui alamat IP secara manual.<\/p>\n
Service Discovery dan Docker<\/h2>\n
Dalam lingkungan container, alamat IP container dapat berubah ketika container dibuat ulang. Karena itu, menggunakan alamat IP container secara langsung bukan pendekatan yang ideal untuk komunikasi antarservice dalam sistem yang dinamis.<\/p>\n
Service discovery berbasis nama service dapat membuat komunikasi lebih sederhana. Misalnya: order-service \u2192 payment-service
\n<\/code>dibandingkan: order-service \u2192 172.18.0.5:8080
\n<\/code><\/p>\n
Dengan menggunakan nama service, aplikasi tidak terlalu bergantung pada alamat IP instance tertentu. Platform container modern juga menyediakan mekanisme discovery atau DNS service yang dapat digunakan sesuai kebutuhan arsitektur.<\/p>\n
Service Discovery pada Kubernetes<\/h2>\n
Kubernetes <\/em>memiliki mekanisme Service yang memungkinkan workload berkomunikasi menggunakan nama service daripada bergantung pada alamat IP Pod secara langsung. Misalnya terdapat: payment-service
\n<\/code><\/p>\n
Service lain dapat menggunakan nama tersebut untuk menemukan endpoint yang tersedia. Kubernetes kemudian membantu mengarahkan traffic ke Pod yang sesuai berdasarkan konfigurasi Service. Hal ini membuat komunikasi antarworkload lebih dinamis karena Pod dapat dibuat ulang atau berpindah tanpa membuat aplikasi harus mengetahui alamat IP Pod secara manual.<\/p>\n
Dalam konteks Kubernetes, istilah Service Discovery <\/em>dapat berkaitan dengan DNS internal, Kubernetes Service, endpoint, dan mekanisme jaringan lain yang digunakan untuk menemukan workload.<\/p>\n
Service Discovery dan DNS<\/h2>\n
DNS juga dapat digunakan sebagai bagian dari mekanisme Service Discovery. Daripada aplikasi menyimpan alamat IP secara langsung, aplikasi dapat menggunakan nama host tertentu.<\/p>\n
Contohnya: payment-service.example.internal
\n<\/code><\/p>\n
Nama tersebut kemudian dapat dipetakan ke endpoint yang sesuai. Pendekatan berbasis DNS cukup populer karena banyak aplikasi sudah mendukung resolusi nama host tanpa memerlukan implementasi discovery khusus di dalam kode aplikasi.<\/p>\n
Namun, kemampuan dan perilaku discovery tetap bergantung pada bagaimana DNS dan infrastruktur di belakangnya dikonfigurasi.<\/p>\n
Service Discovery vs Load Balancing<\/h2>\n
Service Discovery dan load balancing memiliki fungsi yang berbeda meskipun keduanya sering digunakan bersama. Service Discovery bertugas membantu menemukan service atau instance yang tersedia. Sementara itu, load balancing bertugas mendistribusikan traffic ke beberapa instance yang tersedia. Contohnya:<\/p>\n
                Service Discovery\r\n                       \u2193\r\n              Menemukan instance\r\n                       \u2193\r\n          \u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\r\n          \u2193            \u2193            \u2193\r\n      Instance 1   Instance 2   Instance 3\r\n          \u2191            \u2191            \u2191\r\n          \u2514\u2500\u2500\u2500\u2500 Load Balancer \u2500\u2500\u2500\u2500\u2500\u2500\u2518\r\n<\/code><\/pre>\n
Dalam implementasi tertentu, komponen yang sama atau platform yang sama dapat menangani sebagian fungsi tersebut. Namun secara konsep, discovery dan load balancing merupakan tanggung jawab yang berbeda.<\/p>\n\n\n\n\n\n\n\n\n
Service Discovery<\/th>\nLoad Balancing<\/th>\n<\/tr>\n<\/thead>\n
Menemukan service<\/td>\nMendistribusikan traffic<\/td>\n<\/tr>\n
Mengetahui endpoint<\/td>\nMemilih atau mengarahkan traffic<\/td>\n<\/tr>\n
Memantau keberadaan instance<\/td>\nMembagi beban antarinstance<\/td>\n<\/tr>\n
Membantu service saling menemukan<\/td>\nMembantu mencegah satu instance menerima seluruh beban<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Service Discovery vs API Gateway<\/h2>\n
Service Discovery juga berbeda dengan API Gateway. <\/em>API Gateway biasanya menjadi pintu masuk bagi client menuju beberapa backend service. Contohnya:<\/p>\n
Client\r\n   \u2193\r\nAPI Gateway\r\n   \u251c\u2500\u2500 User Service\r\n   \u251c\u2500\u2500 Order Service\r\n   \u2514\u2500\u2500 Payment Service\r\n<\/code><\/pre>\n
Sementara Service Discovery membantu gateway atau service lain menemukan lokasi backend service tersebut. Dengan demikian, API Gateway dan Service Discovery dapat digunakan secara bersamaan.<\/p>\n
\"\"<\/p>\n
Manfaat Service Discovery<\/h2>\n
Service Discovery memberikan beberapa manfaat bagi aplikasi modern.<\/p>\n
1. Mengurangi Ketergantungan pada IP Address<\/span><\/p>\n
Aplikasi tidak perlu menyimpan alamat IP setiap instance secara permanen. Hal ini membuat sistem lebih fleksibel ketika infrastruktur berubah.<\/p>\n
2. Mendukung Scaling<\/span><\/p>\n
Ketika instance baru ditambahkan, endpoint tersebut dapat didaftarkan ke registry sehingga dapat ditemukan oleh service lain. Hal ini sangat berguna pada sistem yang menggunakan horizontal scaling.<\/p>\n
3. Mempermudah Arsitektur Microservices<\/span><\/p>\n
Dalam microservices, jumlah service dapat cukup banyak. Service Discovery membantu masing-masing service menemukan dependency yang dibutuhkan tanpa konfigurasi alamat secara manual.<\/p>\n
4. Mendukung Infrastruktur Dinamis<\/span><\/p>\n
Server, container, dan instance cloud dapat dibuat atau dihentikan sesuai kebutuhan. Service Discovery membantu aplikasi mengikuti perubahan tersebut.<\/p>\n
5. Membantu Menangani Instance yang Bermasalah<\/span><\/p>\n
Dengan health check, instance yang tidak sehat dapat dikeluarkan dari daftar endpoint yang digunakan.<\/p>\n
6. Mengurangi Konfigurasi Manual<\/span><\/p>\n
Developer tidak perlu memperbarui alamat IP setiap kali lokasi service berubah. Hal ini dapat mengurangi pekerjaan operasional dan risiko kesalahan konfigurasi.<\/p>\n
7. Mendukung High Availability<\/span><\/p>\n
Ketika sebuah service memiliki beberapa instance, Service Discovery dapat membantu menyediakan daftar endpoint yang tersedia. Jika satu instance mengalami masalah, sistem dapat menggunakan instance lainnya sesuai mekanisme yang diterapkan.<\/p>\n
Apa Kekurangan Service Discovery?<\/h2>\n
Meskipun memiliki banyak manfaat, Service Discovery juga menambah komponen dan kompleksitas dalam sistem.<\/p>\n
1. Menambah Kompleksitas Infrastruktur<\/span><\/p>\n
Sistem perlu mengelola registry atau mekanisme discovery. Semakin banyak komponen yang digunakan, semakin besar pula kebutuhan monitoring dan maintenance.<\/p>\n
2. Registry Menjadi Komponen Penting<\/span><\/p>\n
Jika mekanisme Service Discovery mengalami masalah, proses menemukan service dapat terganggu. Karena itu, komponen discovery biasanya perlu dirancang dengan tingkat ketersediaan yang baik.<\/p>\n
3. Membutuhkan Monitoring<\/span><\/p>\n
Perubahan status service, health check, registration, dan deregistration perlu dipantau agar masalah dapat diketahui lebih cepat.<\/p>\n
4. Masalah Konsistensi Data<\/span><\/p>\n
Pada sistem terdistribusi, informasi mengenai instance dapat mengalami keterlambatan pembaruan. Karena itu, desain Service Discovery perlu mempertimbangkan bagaimana registry menangani perubahan data dan kegagalan jaringan.<\/p>\n
Contoh Sederhana Service Discovery<\/h2>\n
Bayangkan sebuah aplikasi toko online memiliki tiga service:<\/p>\n
User Service\r\nOrder Service\r\nPayment Service\r\n<\/code><\/pre>\n
Order Service<\/code> membutuhkan Payment Service<\/code>.<\/p>\n
Tanpa Service Discovery, konfigurasi mungkin seperti:<\/p>\n
PAYMENT_SERVICE_HOST=10.0.0.15\r\nPAYMENT_SERVICE_PORT=8080\r\n<\/code><\/pre>\n
Jika server payment berpindah ke alamat lain, konfigurasi perlu diperbarui. Dengan Service Discovery, Order Service<\/code> dapat mencari: payment-service
\n<\/code><\/p>\n
Registry kemudian memberikan endpoint yang tersedia:<\/p>\n
10.0.0.15:8080\r\n10.0.0.16:8080\r\n<\/code><\/pre>\n
Jika 10.0.0.15<\/code> mengalami gangguan dan statusnya menjadi tidak sehat, sistem dapat menghindari endpoint tersebut. Dengan demikian, komunikasi antarservice menjadi lebih dinamis.<\/p>\n
Contoh Alur Service Discovery pada Microservices<\/h2>\n
Secara keseluruhan, prosesnya dapat digambarkan seperti berikut:<\/p>\n
             Service Registry\r\n                    \u25b2\r\n                    \u2502\r\n             Registration\r\n                    \u2502\r\n              Payment Service\r\n                    \u2502\r\n                    \u2502\r\nOrder Service \u2500\u2500\u2500\u2500\u2500\u2500\u2518\r\n       \u2502\r\n       \u2502 Discovery\r\n       \u25bc\r\nService Registry\r\n       \u2502\r\n       \u2502 Endpoint\r\n       \u25bc\r\nPayment Service Instance\r\n<\/code><\/pre>\n
Jika terdapat beberapa instance, registry dapat menyimpan semuanya:<\/p>\n
Payment Service\r\n\u2502\r\n\u251c\u2500\u2500 Instance A \u2192 Healthy\r\n\u251c\u2500\u2500 Instance B \u2192 Healthy\r\n\u2514\u2500\u2500 Instance C \u2192 Unhealthy\r\n<\/code><\/pre>\n
Instance yang tidak sehat dapat dikeluarkan dari endpoint yang dipilih untuk request.<\/p>\n
Teknologi yang Dapat Digunakan untuk Service Discovery<\/h2>\n
Terdapat berbagai teknologi dan platform yang menyediakan mekanisme Service Discovery atau fitur yang mendukungnya. Beberapa contoh yang umum ditemui dalam ekosistem cloud dan distributed systems antara lain:<\/p>\n