0Pricing
DevOps Bootcamp · Pelajaran

Pemeriksaan Kesehatan: Probe Keaktifan & Kesiapan

Konfigurasikan probe keaktifan dan kesiapan untuk memastikan aplikasi Anda sehat dan siap melayani lalu lintas.

Pemeriksaan Kesehatan: Probe Keaktifan & Kesiapan adalah pelajaran DevOps Bootcamp gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar DevOps Bootcamp, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus DevOps Bootcamp mencakup 4 pelajaran total.

Menjaga Aplikasi Tetap Sehat

Bagaimana Kubernetes mengetahui apakah aplikasi Anda benar-benar berfungsi? Container yang sekadar berjalan saja tidak cukup; container juga harus sehat dan siap melayani lalu lintas.

Kubernetes menggunakan pemeriksaan khusus yang disebut probe untuk memantau aplikasi Anda. Probe ini membantu memastikan pengguna Anda selalu mendapatkan layanan yang andal.

Apa Itu Probe Liveness?

Probe Liveness memeriksa apakah aplikasi Anda masih aktif dan responsif. Jika probe liveness gagal, Kubernetes menganggap container Anda tidak sehat dan akan memulai ulang container tersebut.

Anggaplah ini seperti pemantau detak jantung: jika jantung berhenti, diperlukan mulai ulang! Hal ini membantu memulihkan aplikasi dari kebuntuan atau kerusakan.

Dasar-Dasar Probe Liveness

Anda dapat mengonfigurasi probe liveness menggunakan berbagai metode:

  • HTTP GET: Mengirim permintaan HTTP ke jalur yang ditentukan.
  • Soket TCP: Memeriksa apakah koneksi TCP dapat dibuka ke suatu port.
  • Perintah Exec: Menjalankan perintah di dalam container.

Untuk aplikasi web, HTTP GET sangat umum digunakan. Berikut cuplikan yang menunjukkan cara mendefinisikannya dalam YAML Pod:

livenessProbe:
  httpGet:
    path: /healthz
    port: 8080
  initialDelaySeconds: 5
  periodSeconds: 5

Probe Liveness Beraksi

Aplikasi Flask Python ini akan menyimulasikan keadaan tidak sehat dengan mengalami kerusakan setelah dua permintaan ke /healthz. Probe Kubernetes akan mendeteksi hal ini dan memulai ulang container.

Pertama, simpan sebagai app.py:

from flask import Flask, Response
import os
import time

app = Flask(__name__)
request_count = 0

@app.route('/healthz')
def health_check():
    global request_count
    request_count += 1
    if request_count > 2:
        print("Liveness probe failing! Exiting...")
        os._exit(1) # Simulate a crash
    print(f"Liveness probe successful (count: {request_count})")
    return Response("OK", status=200)

@app.route('/')
def home():
    return "Hello from the Liveness Probe Demo!"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080)

Menjalankan Probe Liveness

Sekarang, mari kita lihat cara Kubernetes menggunakan probe liveness. Jika Anda menerapkannya dengan YAML berikut, Kubernetes akan memulai ulang Pod saat pemeriksaan kesehatan gagal:

apiVersion: v1
kind: Pod
metadata:
  name: liveness-demo
spec:
  containers:
  - name: liveness-container
    image: python:3.9-slim-buster
    command: ["python", "app.py"]
    ports:
    - containerPort: 8080
    livenessProbe:
      httpGet:
        path: /healthz
        port: 8080
      initialDelaySeconds: 5
      periodSeconds: 5
      failureThreshold: 1
    volumeMounts:
    - name: app-volume
      mountPath: /app
  volumes:
  - name: app-volume
    configMap:
      name: liveness-app-config

# (You'd need a ConfigMap for app.py, omitted for brevity)

Setelah diterapkan, pemeriksaan pertama dan kedua akan berhasil, tetapi pemeriksaan ketiga akan gagal dan Kubernetes akan memulai ulang container.

Apa Itu Probe Readiness?

Probe Readiness memeriksa apakah aplikasi Anda siap melayani lalu lintas. Jika probe readiness gagal, Kubernetes akan berhenti mengirimkan lalu lintas ke Pod tersebut, tetapi tidak akan memulai ulang Pod.

Hal ini sangat penting selama proses mulai (misalnya, saat menunggu koneksi basis data) atau penghentian secara baik-baik. Bayangkan pertanyaan: "Apakah toko sudah buka untuk pelanggan?"

Dasar-Dasar Probe Readiness

Probe readiness dikonfigurasi dengan cara yang mirip dengan probe liveness, menggunakan HTTP GET, Soket TCP, atau perintah Exec. Perbedaan utamanya adalah dampaknya:

  • Liveness: Memulai ulang container saat terjadi kegagalan.
  • Readiness: Menghapus Pod dari titik akhir layanan saat terjadi kegagalan (tidak ada lalu lintas).

Berikut cuplikan untuk probe readiness:

readinessProbe:
  httpGet:
    path: /ready
    port: 8080
  initialDelaySeconds: 10
  periodSeconds: 5

Probe Readiness Beraksi

Aplikasi Flask ini menyimulasikan aplikasi yang memerlukan waktu untuk melakukan inisialisasi (misalnya, saat menyambung ke basis data). Aplikasi ini hanya akan melaporkan status "siap" setelah 5 detik.

Simpan sebagai ready_app.py:

from flask import Flask, Response
import time

app = Flask(__name__)
start_time = time.time()
READY_AFTER_SECONDS = 5

@app.route('/ready')
def readiness_check():
    if time.time() - start_time > READY_AFTER_SECONDS:
        print("Readiness probe successful: App is ready!")
        return Response("READY", status=200)
    else:
        print("Readiness probe failing: App not ready yet...")
        return Response("NOT READY", status=503)

@app.route('/')
def home():
    return "Hello from the Readiness Probe Demo!"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080)

Menjalankan Probe Kesiapan

Saat diterapkan dengan YAML ini, Pod tidak akan menerima lalu lintas selama initialDelaySeconds ditambah waktu yang diperlukan /ready untuk mengembalikan 200 OK.

apiVersion: v1
kind: Pod
metadata:
  name: readiness-demo
spec:
  containers:
  - name: readiness-container
    image: python:3.9-slim-buster
    command: ["python", "ready_app.py"]
    ports:
    - containerPort: 8080
    readinessProbe:
      httpGet:
        path: /ready
        port: 8080
      initialDelaySeconds: 10
      periodSeconds: 3
    volumeMounts:
    - name: app-volume
      mountPath: /app
  volumes:
  - name: app-volume
    configMap:
      name: readiness-app-config

# (You'd need a ConfigMap for ready_app.py, omitted for brevity)

Dengan demikian, lalu lintas hanya diarahkan ke instans yang benar-benar siap.

Liveness vs. Readiness

Penting untuk menggunakan kedua probe ini dengan benar:

  • Probe Liveness: Digunakan untuk mendeteksi apakah aplikasi Anda mengalami kerusakan atau berada dalam kondisi yang tidak dapat dipulihkan. Jika gagal, Kubernetes akan memulai ulang kontainer.
  • Probe Readiness: Digunakan untuk mendeteksi apakah aplikasi Anda siap menerima dan memproses permintaan. Jika gagal, Kubernetes akan berhenti mengirimkan lalu lintas ke Pod.

Keduanya memiliki tujuan yang berbeda, tetapi saling melengkapi untuk menjaga aplikasi tetap tangguh.

Uji Pemahaman Anda

Pernyataan mana dari berikut ini tentang Probe Liveness dan Readiness yang BENAR?

Probe: Poin-Poin Utama

Dalam pelajaran ini, Anda telah mempelajari Probe Liveness dan Readiness di Kubernetes. Pemeriksaan kesehatan ini sangat penting untuk menjaga keandalan dan ketersediaan aplikasi Anda:

  • Probe Liveness mendeteksi kontainer yang tidak sehat dan memicu proses mulai ulang.
  • Probe Readiness mengatur kapan sebuah Pod siap menerima lalu lintas jaringan.

Penggunaan yang efektif memastikan aplikasi Anda selalu responsif dan mampu menghadapi masalah.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pemeriksaan Kesehatan: Probe Keaktifan & Kesiapan” gratis?

Ya — teks lengkap “Pemeriksaan Kesehatan: Probe Keaktifan & Kesiapan” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus DevOps Bootcamp, upgrade ke CoddyKit PRO. Kursus DevOps Bootcamp mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Pemeriksaan Kesehatan: Probe Keaktifan & Kesiapan”?

Konfigurasikan probe keaktifan dan kesiapan untuk memastikan aplikasi Anda sehat dan siap melayani lalu lintas. Kamu berlatih DevOps Bootcamp dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai DevOps Bootcamp?

Tidak diperlukan pengalaman sebelumnya. DevOps Bootcamp di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Pemeriksaan Kesehatan: Probe Keaktifan & Kesiapan” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran DevOps Bootcamp ini?

Ya. Setiap pelajaran DevOps Bootcamp menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Logging dengan kubectl logs
  2. Metrik dengan Prometheus & Grafana
  3. Pemeriksaan Kesehatan: Probe Keaktifan & Kesiapan
  4. Pelacakan Terdistribusi dan Peristiwa
← Kembali ke DevOps Bootcamp