Controlli di salute: probe di liveness e readiness
Configuri le probe di liveness e readiness per garantire che le applicazioni siano sane e pronte a gestire il traffico.
Controlli di salute: probe di liveness e readiness è una lezione Kubernetes Basics gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kubernetes Basics, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kubernetes Basics include 4 lezioni in totale.
Mantenere integre le applicazioni
Come fa Kubernetes a sapere se l'applicazione funziona davvero? Non è sufficiente che un container sia semplicemente in esecuzione: deve essere integro e pronto a gestire il traffico.
Kubernetes usa controlli speciali chiamati probe per monitorare le applicazioni. Queste probe contribuiscono a garantire agli utenti un servizio sempre affidabile.
Che cosa sono le probe di liveness?
Una liveness Probe verifica che l'applicazione sia ancora attiva e reattiva. Se una liveness probe fallisce, Kubernetes considera il container non integro e lo riavvia.
È simile a un monitor del battito cardiaco: se il cuore si ferma, è necessario un riavvio! Questo aiuta a recuperare da deadlock o crash dell'applicazione.
Nozioni di base sulle liveness probe
Può configurare le liveness probe usando metodi diversi:
- HTTP GET: invia una richiesta HTTP a un percorso specificato.
- Socket TCP: verifica se è possibile aprire una connessione TCP a una porta.
- Comando Exec: esegue un comando all'interno del container.
Per le applicazioni web, HTTP GET è molto comune. Ecco un frammento che mostra come definirlo nello YAML di un Pod:
livenessProbe:
httpGet:
path: /healthz
port: 8080
initialDelaySeconds: 5
periodSeconds: 5Liveness probe in azione
Questa applicazione Python Flask simula uno stato non integro andando in crash dopo due richieste a /healthz. La probe di Kubernetes lo rileverà e riavvierà il container.
Per prima cosa, salvi il file come 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)Eseguire una liveness probe
Ora vediamo come Kubernetes usa la liveness probe. Se distribuisce questa configurazione YAML, Kubernetes riavvierà il Pod quando il controllo dello stato di salute fallirà:
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)Una volta distribuito, dopo 2 controlli riusciti il terzo fallirà e Kubernetes riavvierà il container.
Che cosa sono le probe di readiness?
Una readiness Probe verifica che l'applicazione sia pronta a gestire il traffico. Se una readiness probe fallisce, Kubernetes smette di inviare traffico a quel Pod, ma non lo riavvia.
È fondamentale durante l'avvio (ad esempio, mentre si attende una connessione al database) o durante un arresto controllato. In altre parole: "Il negozio è aperto ai clienti?"
Nozioni di base sulle readiness probe
Le readiness probe vengono configurate in modo simile alle liveness probe, usando richieste HTTP GET, socket TCP o comandi Exec. La differenza fondamentale riguarda il loro effetto:
- Liveness: riavvia il container in caso di errore.
- Readiness: rimuove il Pod dagli endpoint del servizio in caso di errore (nessun traffico).
Ecco un frammento per una readiness probe:
readinessProbe:
httpGet:
path: /ready
port: 8080
initialDelaySeconds: 10
periodSeconds: 5Readiness probe in azione
Questa applicazione Flask simula un'applicazione che richiede tempo per inizializzarsi (ad esempio, per connettersi a un database). Segnalerà di essere "ready" solo dopo 5 secondi.
Salvi il file come 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)Esecuzione del probe di readiness
Quando viene distribuito con questo YAML, il Pod non riceverà traffico per i primi initialDelaySeconds secondi, più il tempo necessario affinché /ready restituisca 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)In questo modo, il traffico viene indirizzato solo alle istanze effettivamente pronte.
Liveness e readiness a confronto
È importante utilizzare correttamente entrambi i probe:
- Probe di liveness: rileva se l'applicazione è andata in crash o si trova in uno stato irrecuperabile. Se fallisce, Kubernetes riavvia il container.
- Probe di readiness: rileva se l'applicazione è pronta ad accettare ed elaborare le richieste. Se fallisce, Kubernetes interrompe l'invio del traffico al Pod.
Hanno scopi diversi ma complementari e consentono di mantenere robuste le applicazioni.
Verifica della comprensione
Quali delle seguenti affermazioni sui probe di liveness e readiness sono VERE?
Probe: concetti chiave
In questa lezione ha imparato a conoscere i probe di liveness e readiness in Kubernetes. Questi controlli dello stato di salute sono fondamentali per mantenere l'affidabilità e la disponibilità delle applicazioni:
- I probe di liveness rilevano i container non integri e ne attivano il riavvio.
- I probe di readiness determinano quando un Pod è pronto a ricevere traffico di rete.
Un loro utilizzo efficace garantisce che le applicazioni siano sempre reattive e resilienti ai problemi.
Domande Frequenti
La lezione «Controlli di salute: probe di liveness e readiness» è gratuita?
Sì — il testo completo di «Controlli di salute: probe di liveness e readiness» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kubernetes Basics, passa a CoddyKit PRO. Il corso Kubernetes Basics include 4 lezioni in totale.
Cosa imparerò in «Controlli di salute: probe di liveness e readiness»?
Configuri le probe di liveness e readiness per garantire che le applicazioni siano sane e pronte a gestire il traffico. Eserciti Kubernetes Basics con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Kubernetes Basics?
Non è richiesta alcuna esperienza precedente. Kubernetes Basics su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Controlli di salute: probe di liveness e readiness»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Kubernetes Basics?
Sì. Ogni lezione Kubernetes Basics include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Logging con kubectl logs
- Metriche con Prometheus e Grafana
- Controlli di salute: probe di liveness e readiness
- Tracing distribuito ed eventi