Sundhedstjek: liveness- og readiness-probes
Konfigurer liveness- og readiness-probes for at sikre, at Deres applikationer er sunde og klar til at modtage trafik.
Sundhedstjek: liveness- og readiness-probes er en gratis Intensiv DevOps-uddannelse-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Intensiv DevOps-uddannelse, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Intensiv DevOps-uddannelse-kurset indeholder 4 lektioner i alt.
Hold applikationer sunde
Hvordan ved Kubernetes, om din applikation rent faktisk fungerer? Det er ikke nok, at en container bare kører; den skal være sund og klar til at håndtere trafik.
Kubernetes bruger særlige kontroller, der kaldes probes, til at overvåge dine applikationer. Disse kontroller hjælper med at sikre, at dine brugere altid oplever en pålidelig tjeneste.
Hvad er liveness-prober?
En liveness-probe kontrollerer, om din applikation stadig er aktiv og svarer. Hvis en liveness-probe mislykkes, antager Kubernetes, at din container er usund, og genstarter den.
Tænk på det som en hjertemonitor: Hvis hjertet stopper, er en genstart nødvendig! Det hjælper med at komme sig efter deadlocks eller applikationsnedbrud.
Grundlæggende om liveness-prober
Du kan konfigurere liveness-prober ved hjælp af forskellige metoder:
- HTTP GET: Sender en HTTP-anmodning til en angivet sti.
- TCP-socket: Kontrollerer, om der kan åbnes en TCP-forbindelse til en port.
- Exec-kommando: Kører en kommando inde i containeren.
HTTP GET er meget almindeligt til webapplikationer. Her er et uddrag, der viser, hvordan du definerer en sådan probe i en Pods YAML:
livenessProbe:
httpGet:
path: /healthz
port: 8080
initialDelaySeconds: 5
periodSeconds: 5Liveness-probe i praksis
Denne Python Flask-app simulerer en usund tilstand ved at gå ned efter to anmodninger til /healthz. Kubernetes-proben registrerer dette og genstarter containeren.
Gem først dette som 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)Kørsel af liveness-probe
Lad os nu se, hvordan Kubernetes bruger liveness-proben. Hvis du udruller dette med følgende YAML, genstarter Kubernetes Pod'en, når sundhedskontrollen mislykkes:
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)Efter udrulningen mislykkes den tredje kontrol efter to vellykkede kontroller, og Kubernetes genstarter containeren.
Hvad er readiness-prober?
En readiness-probe kontrollerer, om din applikation er klar til at håndtere trafik. Hvis en readiness-probe mislykkes, holder Kubernetes op med at sende trafik til den pågældende Pod, men genstarter den ikke.
Dette er afgørende under opstart (f.eks. mens der ventes på en databaseforbindelse) eller ved kontrollerede nedlukninger. Tænk: "Er butikken åben for kunder?"
Grundlæggende om readiness-prober
Readiness-prober konfigureres på samme måde som liveness-prober ved hjælp af HTTP GET, TCP-socket eller Exec-kommandoer. Den afgørende forskel er deres effekt:
- Liveness: Genstarter containeren ved fejl.
- Readiness: Fjerner Pod'en fra tjenestens slutpunkter ved fejl (ingen trafik).
Her er et uddrag til en readiness-probe:
readinessProbe:
httpGet:
path: /ready
port: 8080
initialDelaySeconds: 10
periodSeconds: 5Readiness-probe i praksis
Denne Flask-app simulerer en applikation, der tager noget tid at initialisere (f.eks. at oprette forbindelse til en database). Den rapporterer først "klar" efter 5 sekunder.
Gem dette som 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)Kørsel af readiness-probe
Når Pod'en implementeres med denne YAML, modtager den ikke trafik i de første initialDelaySeconds sekunder plus den tid, det tager for /ready at returnere 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
# (Du skal bruge en ConfigMap til ready_app.py, men den er udeladt for overskuelighedens skyld)Det sikrer, at trafik kun sendes til instanser, der reelt er klar.
Liveness kontra readiness
Det er vigtigt at bruge begge probes korrekt:
- Liveness-probe: Bruges til at registrere, om din applikation er gået ned eller er i en tilstand, den ikke kan komme sig over. Hvis den fejler, genstarter Kubernetes containeren.
- Readiness-probe: Bruges til at registrere, om din applikation er klar til at modtage og behandle anmodninger. Hvis den fejler, holder Kubernetes op med at sende trafik til Pod'en.
De har forskellige, men komplementære formål, som gør dine applikationer robuste.
Test din forståelse
Hvilke af følgende udsagn om liveness- og readiness-probes er SANDE?
Probes: Vigtigste pointer
I denne lektion har du lært om liveness- og readiness-probes i Kubernetes. Disse helbredstjek er afgørende for at bevare dine applikationers pålidelighed og tilgængelighed:
- Liveness-probes registrerer usunde containere og udløser genstarter.
- Readiness-probes styrer, hvornår en Pod er klar til at modtage netværkstrafik.
Hvis du bruger dem effektivt, sikrer du, at dine applikationer altid svarer og kan modstå problemer.
Lær Intensiv DevOps-uddannelse med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 142
- Lektioner
- 568
Ofte stillede spørgsmål
Er lektionen “Sundhedstjek: liveness- og readiness-probes” gratis?
Ja — alle 3 lektioner i læringssporet Intensiv DevOps-uddannelse, inklusive “Sundhedstjek: liveness- og readiness-probes”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Intensiv DevOps-uddannelse-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Sundhedstjek: liveness- og readiness-probes”?
Konfigurer liveness- og readiness-probes for at sikre, at Deres applikationer er sunde og klar til at modtage trafik. Du øver dig i Intensiv DevOps-uddannelse med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Intensiv DevOps-uddannelse?
Der kræves ingen tidligere erfaring. Intensiv DevOps-uddannelse på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.
Hvor lang tid tager lektionen “Sundhedstjek: liveness- og readiness-probes”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Intensiv DevOps-uddannelse-lektion?
Ja. Alle Intensiv DevOps-uddannelse-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Logning med kubectl logs
- Metrics med Prometheus og Grafana
- Sundhedstjek: liveness- og readiness-probes
- Distribueret tracing og hændelser