Penemuan Layanan (Service Discovery): Kupas Tuntas Mekanisme Pemeriksaan Kesehatan (Health Check)

Dalam dunia microservices dan sistem terdistribusi, penemuan layanan (service discovery) adalah komponen penting yang memungkinkan aplikasi untuk menemukan dan berkomunikasi satu sama lain. Namun, sekadar mengetahui lokasi sebuah layanan tidaklah cukup. Kita juga perlu memastikan bahwa layanan tersebut sehat dan mampu menangani permintaan. Di sinilah pemeriksaan kesehatan (health check) berperan.

Apa itu Penemuan Layanan?

Penemuan layanan adalah proses mendeteksi dan menemukan layanan secara otomatis dalam lingkungan yang dinamis. Dalam aplikasi monolitik tradisional, layanan biasanya berada di server yang sama dan lokasinya sudah diketahui sebelumnya. Sebaliknya, microservices sering kali diterapkan di beberapa server dan lokasinya dapat sering berubah karena penskalaan, penerapan, dan kegagalan. Penemuan layanan memecahkan masalah ini dengan menyediakan registri pusat tempat layanan dapat mendaftarkan diri dan klien dapat meminta layanan yang tersedia.

Alat penemuan layanan yang populer meliputi:

• Consul: Solusi service mesh dengan fungsionalitas penemuan layanan, konfigurasi, dan segmentasi.
• Etcd: Penyimpanan nilai-kunci terdistribusi yang umum digunakan untuk penemuan layanan di Kubernetes.
• ZooKeeper: Layanan terpusat untuk memelihara informasi konfigurasi, penamaan, menyediakan sinkronisasi terdistribusi, dan layanan grup.
• Kubernetes DNS: Mekanisme penemuan layanan berbasis DNS yang terpasang di Kubernetes.
• Eureka: Registri layanan yang utamanya digunakan di lingkungan Spring Cloud.

Pentingnya Pemeriksaan Kesehatan

Meskipun penemuan layanan menyediakan mekanisme untuk menemukan layanan, hal itu tidak menjamin bahwa layanan tersebut sehat. Sebuah layanan mungkin terdaftar di registri layanan tetapi mengalami masalah seperti penggunaan CPU yang tinggi, kebocoran memori, atau masalah koneksi basis data. Tanpa pemeriksaan kesehatan, klien mungkin secara tidak sengaja mengarahkan permintaan ke layanan yang tidak sehat, yang menyebabkan kinerja buruk, kesalahan, dan bahkan pemadaman aplikasi. Pemeriksaan kesehatan menyediakan cara untuk terus memantau kesehatan layanan dan secara otomatis menghapus instans yang tidak sehat dari registri layanan. Hal ini memastikan bahwa klien hanya berinteraksi dengan layanan yang sehat dan responsif.

Pertimbangkan skenario di mana aplikasi e-commerce bergantung pada layanan terpisah untuk memproses pembayaran. Jika layanan pembayaran kelebihan beban atau mengalami kesalahan basis data, layanan tersebut mungkin masih terdaftar di registri layanan. Tanpa pemeriksaan kesehatan, aplikasi e-commerce akan terus mengirim permintaan pembayaran ke layanan yang gagal, yang mengakibatkan transaksi gagal dan pengalaman pelanggan yang negatif. Dengan adanya pemeriksaan kesehatan, layanan pembayaran yang gagal akan secara otomatis dihapus dari registri layanan, dan aplikasi e-commerce dapat mengalihkan permintaan ke instans yang sehat atau menangani kesalahan dengan baik.

Jenis-jenis Pemeriksaan Kesehatan

Ada beberapa jenis pemeriksaan kesehatan yang dapat digunakan untuk memantau kesehatan layanan. Jenis yang paling umum meliputi:

Pemeriksaan Kesehatan HTTP

Pemeriksaan kesehatan HTTP melibatkan pengiriman permintaan HTTP ke endpoint tertentu pada layanan dan memverifikasi kode status respons. Kode status 200 (OK) biasanya menunjukkan bahwa layanan tersebut sehat, sementara kode status lainnya (misalnya, 500 Internal Server Error) menunjukkan adanya masalah. Pemeriksaan kesehatan HTTP mudah diimplementasikan dan dapat digunakan untuk memverifikasi fungsionalitas dasar layanan. Sebagai contoh, pemeriksaan kesehatan mungkin akan memeriksa endpoint `/health` dari sebuah layanan. Dalam aplikasi Node.js yang menggunakan Express, ini bisa sesederhana:

            app.get('/health', (req, res) => {
  res.status(200).send('OK');
});
            

              
                Copy
              
            
          

Contoh konfigurasi:

Consul

            {
  "service": {
    "name": "payment-service",
    "port": 8080,
    "check": {
      "http": "http://localhost:8080/health",
      "interval": "10s",
      "timeout": "5s"
    }
  }
}
            

              
                Copy
              
            
          

Kubernetes

            apiVersion: v1
kind: Pod
metadata:
  name: payment-service
spec:
  containers:
  - name: payment-service-container
    image: payment-service:latest
    ports:
    - containerPort: 8080
    livenessProbe:
      httpGet:
        path: /health
        port: 8080
      initialDelaySeconds: 3
      periodSeconds: 10
            

              
                Copy
              
            
          

Pemeriksaan Kesehatan TCP

Pemeriksaan kesehatan TCP melibatkan upaya untuk membuat koneksi TCP ke port tertentu pada layanan. Jika koneksi berhasil dibuat, layanan dianggap sehat. Pemeriksaan kesehatan TCP berguna untuk memverifikasi bahwa layanan sedang mendengarkan di port yang benar dan menerima koneksi. Pemeriksaan ini lebih sederhana daripada pemeriksaan HTTP karena tidak memeriksa lapisan aplikasi. Pemeriksaan dasar mengonfirmasi aksesibilitas port.

Contoh konfigurasi:

Consul

            {
  "service": {
    "name": "database-service",
    "port": 5432,
    "check": {
      "tcp": "localhost:5432",
      "interval": "10s",
      "timeout": "5s"
    }
  }
}
            

              
                Copy
              
            
          

Kubernetes

            apiVersion: v1
kind: Pod
metadata:
  name: database-service
spec:
  containers:
  - name: database-service-container
    image: database-service:latest
    ports:
    - containerPort: 5432
    livenessProbe:
      tcpSocket:
        port: 5432
      initialDelaySeconds: 15
      periodSeconds: 20
            

              
                Copy
              
            
          

Pemeriksaan Kesehatan Eksekusi Perintah

Pemeriksaan kesehatan eksekusi perintah melibatkan eksekusi perintah pada host layanan dan memverifikasi kode keluar (exit code). Kode keluar 0 biasanya menunjukkan bahwa layanan sehat, sedangkan kode keluar lainnya menunjukkan masalah. Pemeriksaan kesehatan eksekusi perintah adalah jenis pemeriksaan kesehatan yang paling fleksibel, karena dapat digunakan untuk melakukan berbagai macam pemeriksaan, seperti memverifikasi ruang disk, penggunaan memori, atau status dependensi eksternal. Sebagai contoh, Anda dapat menjalankan skrip yang memeriksa apakah koneksi basis data sehat.

Contoh konfigurasi:

Consul

            {
  "service": {
    "name": "monitoring-service",
    "port": 80,
    "check": {
      "args": ["/usr/local/bin/check_disk_space.sh"],
      "interval": "30s",
      "timeout": "10s"
    }
  }
}
            

              
                Copy
              
            
          

Kubernetes

            apiVersion: v1
kind: Pod
metadata:
  name: monitoring-service
spec:
  containers:
  - name: monitoring-service-container
    image: monitoring-service:latest
    command: ["/usr/local/bin/check_disk_space.sh"]
    livenessProbe:
      exec:
        command: ["/usr/local/bin/check_disk_space.sh"]
      initialDelaySeconds: 60
      periodSeconds: 30
            

              
                Copy
              
            
          

Pemeriksaan Kesehatan Kustom

Untuk skenario yang lebih kompleks, Anda dapat mengimplementasikan pemeriksaan kesehatan kustom yang melakukan logika spesifik aplikasi. Ini mungkin melibatkan pemeriksaan status antrean internal, memverifikasi ketersediaan sumber daya eksternal, atau melakukan metrik kinerja yang lebih canggih. Pemeriksaan kesehatan kustom memberikan kontrol paling terperinci atas proses pemantauan kesehatan.

Sebagai contoh, pemeriksaan kesehatan kustom untuk konsumen antrean pesan mungkin memverifikasi bahwa kedalaman antrean berada di bawah ambang batas tertentu dan bahwa pesan diproses dengan kecepatan yang wajar. Atau, layanan yang berinteraksi dengan API pihak ketiga mungkin memeriksa waktu respons dan tingkat kesalahan API tersebut.

Mengimplementasikan Pemeriksaan Kesehatan

Mengimplementasikan pemeriksaan kesehatan biasanya melibatkan langkah-langkah berikut:

1. Tentukan Kriteria Kesehatan: Tentukan apa yang merupakan layanan yang sehat. Ini mungkin termasuk waktu respons, penggunaan CPU, penggunaan memori, status koneksi basis data, dan ketersediaan sumber daya eksternal.
2. Implementasikan Endpoint atau Skrip Pemeriksaan Kesehatan: Buat endpoint (misalnya, `/health`) atau skrip yang melakukan pemeriksaan kesehatan dan mengembalikan kode status atau kode keluar yang sesuai.
3. Konfigurasikan Alat Penemuan Layanan: Konfigurasikan alat penemuan layanan Anda (misalnya, Consul, Etcd, Kubernetes) untuk secara berkala menjalankan pemeriksaan kesehatan dan memperbarui registri layanan sesuai dengan hasilnya.
4. Pantau Hasil Pemeriksaan Kesehatan: Pantau hasil pemeriksaan kesehatan untuk mengidentifikasi potensi masalah dan mengambil tindakan perbaikan.

Sangat penting bahwa pemeriksaan kesehatan bersifat ringan dan tidak mengonsumsi sumber daya yang berlebihan. Hindari melakukan operasi yang kompleks atau mengakses basis data eksternal langsung dari endpoint pemeriksaan kesehatan. Sebaliknya, fokuslah pada verifikasi fungsionalitas dasar layanan dan andalkan alat pemantauan lain untuk analisis yang lebih mendalam.

Praktik Terbaik untuk Pemeriksaan Kesehatan

Berikut adalah beberapa praktik terbaik untuk mengimplementasikan pemeriksaan kesehatan:

• Jaga Agar Pemeriksaan Kesehatan Tetap Ringan: Pemeriksaan kesehatan harus cepat dan mengonsumsi sumber daya minimal. Hindari logika yang rumit atau operasi I/O. Usahakan agar pemeriksaan selesai dalam hitungan milidetik.
• Gunakan Beberapa Jenis Pemeriksaan Kesehatan: Gabungkan berbagai jenis pemeriksaan kesehatan untuk mendapatkan gambaran yang lebih komprehensif tentang kesehatan layanan. Misalnya, gunakan pemeriksaan kesehatan HTTP untuk memverifikasi fungsionalitas dasar layanan dan pemeriksaan kesehatan eksekusi perintah untuk memverifikasi ketersediaan sumber daya eksternal.
• Pertimbangkan Dependensi: Jika sebuah layanan bergantung pada layanan atau sumber daya lain, sertakan pemeriksaan untuk dependensi tersebut dalam pemeriksaan kesehatan. Ini dapat membantu mengidentifikasi masalah yang mungkin tidak langsung terlihat dari metrik kesehatan layanan itu sendiri. Misalnya, jika layanan Anda bergantung pada basis data, sertakan pemeriksaan untuk memastikan koneksi basis data sehat.
• Gunakan Interval dan Waktu Tunggu yang Tepat: Konfigurasikan interval dan waktu tunggu pemeriksaan kesehatan dengan tepat untuk layanan tersebut. Interval harus cukup sering untuk mendeteksi masalah dengan cepat, tetapi tidak terlalu sering sehingga membebani layanan. Waktu tunggu harus cukup lama untuk memungkinkan pemeriksaan kesehatan selesai, tetapi tidak terlalu lama sehingga menunda deteksi masalah. Titik awal yang umum adalah interval 10 detik dan waktu tunggu 5 detik, tetapi nilai-nilai ini mungkin perlu disesuaikan berdasarkan layanan dan lingkungan spesifik.
• Tangani Kesalahan Sementara dengan Baik: Implementasikan logika untuk menangani kesalahan sementara dengan baik. Satu kegagalan pemeriksaan kesehatan mungkin tidak menunjukkan masalah serius. Pertimbangkan untuk menggunakan ambang batas atau mekanisme coba lagi untuk menghindari penghapusan layanan dari registri layanan secara prematur. Misalnya, Anda mungkin mengharuskan sebuah layanan gagal tiga kali pemeriksaan kesehatan berturut-turut sebelum menganggapnya tidak sehat.
• Amankan Endpoint Pemeriksaan Kesehatan: Lindungi endpoint pemeriksaan kesehatan dari akses yang tidak sah. Jika endpoint pemeriksaan kesehatan mengekspos informasi sensitif, seperti metrik internal atau data konfigurasi, batasi akses hanya untuk klien yang berwenang. Ini dapat dicapai melalui autentikasi atau daftar putih IP (IP whitelisting).
• Dokumentasikan Pemeriksaan Kesehatan: Dokumentasikan dengan jelas tujuan dan implementasi setiap pemeriksaan kesehatan. Ini akan membantu pengembang lain memahami cara kerja pemeriksaan kesehatan dan cara memecahkan masalah. Sertakan informasi tentang kriteria kesehatan, endpoint atau skrip pemeriksaan kesehatan, dan kode status atau kode keluar yang diharapkan.
• Otomatiskan Perbaikan: Integrasikan pemeriksaan kesehatan dengan sistem perbaikan otomatis. Ketika sebuah layanan terdeteksi tidak sehat, picu tindakan secara otomatis untuk mengembalikan layanan ke kondisi sehat. Ini mungkin melibatkan memulai ulang layanan, meningkatkan jumlah instans, atau kembali ke versi sebelumnya.
• Gunakan Tes Dunia Nyata: Pemeriksaan kesehatan harus menyimulasikan lalu lintas dan dependensi pengguna nyata. Jangan hanya memeriksa apakah server berjalan; pastikan server dapat menangani permintaan umum dan berinteraksi dengan sumber daya yang diperlukan.

Contoh di Berbagai Teknologi

Mari kita lihat contoh implementasi pemeriksaan kesehatan di berbagai teknologi:

Java (Spring Boot)

            @RestController
public class HealthController {

    @GetMapping("/health")
    public ResponseEntity<String> health() {
        // Lakukan pemeriksaan di sini, mis., koneksi basis data
        boolean isHealthy = true; // Ganti dengan pemeriksaan sebenarnya

        if (isHealthy) {
            return new ResponseEntity<>("OK", HttpStatus.OK);
        } else {
            return new ResponseEntity<>("Error", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
}
            

              
                Copy
              
            
          

Python (Flask)

            from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/health')
def health_check():
    # Lakukan pemeriksaan di sini
    is_healthy = True  # Ganti dengan pemeriksaan sebenarnya

    if is_healthy:
        return jsonify({'status': 'OK'}), 200
    else:
        return jsonify({'status': 'Error'}), 500

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)
            

              
                Copy
              
            
          

Go

            package main

import (
    "fmt"
    "net/http"
)

func healthHandler(w http.ResponseWriter, r *http.Request) {
    // Lakukan pemeriksaan di sini
    isHealthy := true // Ganti dengan pemeriksaan sebenarnya

    if isHealthy {
        w.WriteHeader(http.StatusOK)
        fmt.Fprint(w, "OK")
    } else {
        w.WriteHeader(http.StatusInternalServerError)
        fmt.Fprint(w, "Error")
    }
}

func main() {
    http.HandleFunc("/health", healthHandler)
    fmt.Println("Server listening on port 8080")
    http.ListenAndServe(":8080", nil)
}
            

              
                Copy
              
            
          

Pemeriksaan Kesehatan dan Penyeimbangan Beban (Load Balancing)

Pemeriksaan kesehatan sering diintegrasikan dengan solusi penyeimbangan beban untuk memastikan bahwa lalu lintas hanya diarahkan ke layanan yang sehat. Penyeimbang beban (load balancer) menggunakan hasil pemeriksaan kesehatan untuk menentukan layanan mana yang tersedia untuk menerima lalu lintas. Ketika sebuah layanan gagal dalam pemeriksaan kesehatan, penyeimbang beban secara otomatis menghapusnya dari kumpulan layanan yang tersedia. Ini mencegah klien mengirim permintaan ke layanan yang tidak sehat dan meningkatkan keandalan aplikasi secara keseluruhan.

Contoh penyeimbang beban yang terintegrasi dengan pemeriksaan kesehatan meliputi:

• HAProxy
• NGINX Plus
• Amazon ELB
• Google Cloud Load Balancing
• Azure Load Balancer

Pemantauan dan Peringatan (Alerting)

Selain secara otomatis menghapus layanan yang tidak sehat dari registri layanan, pemeriksaan kesehatan juga dapat digunakan untuk memicu peringatan dan notifikasi. Ketika sebuah layanan gagal dalam pemeriksaan kesehatan, sistem pemantauan dapat mengirim peringatan ke tim operasi, memberi tahu mereka tentang potensi masalah. Ini memungkinkan mereka untuk menyelidiki masalah tersebut dan mengambil tindakan perbaikan sebelum memengaruhi pengguna.

Alat pemantauan populer yang terintegrasi dengan pemeriksaan kesehatan meliputi:

• Prometheus
• Datadog
• New Relic
• Grafana
• Nagios

Kesimpulan

Pemeriksaan kesehatan adalah komponen penting dari penemuan layanan dalam arsitektur microservices. Mereka menyediakan cara untuk terus memantau kesehatan layanan dan secara otomatis menghapus instans yang tidak sehat dari registri layanan. Dengan mengimplementasikan mekanisme pemeriksaan kesehatan yang kuat, Anda dapat memastikan bahwa aplikasi Anda tangguh, skalabel, dan andal. Memilih jenis pemeriksaan kesehatan yang tepat, mengonfigurasikannya dengan benar, dan mengintegrasikannya dengan sistem pemantauan dan peringatan adalah kunci untuk membangun lingkungan microservices yang sehat dan kuat.

Terapkan pendekatan proaktif terhadap pemantauan kesehatan. Jangan menunggu pengguna melaporkan masalah. Implementasikan pemeriksaan kesehatan komprehensif yang terus-menerus memantau kesehatan layanan Anda dan secara otomatis mengambil tindakan perbaikan ketika masalah muncul. Ini akan membantu Anda membangun arsitektur microservices yang tangguh dan andal yang dapat menghadapi tantangan lingkungan yang dinamis dan terdistribusi. Tinjau dan perbarui secara teratur pemeriksaan kesehatan Anda untuk beradaptasi dengan kebutuhan dan dependensi aplikasi yang terus berkembang.

Pada akhirnya, berinvestasi dalam mekanisme pemeriksaan kesehatan yang kuat adalah investasi dalam stabilitas, ketersediaan, dan kesuksesan keseluruhan aplikasi berbasis microservices Anda.