{"canonical_url":"https://engineer.company/sv/glossary/health-check/","content_markdown":"# Hälsokontroll\n\n## Vad det är\n\nEn hälsokontroll är ett litet test som upprepas enligt ett schema och frågar en\nkörande tjänst om den kan göra sitt jobb, tillsammans med en regel för vad som\nhänder när svaret är nej. Testet kan vara en HTTP-förfrågan till en särskild\nsökväg, ett kommando som körs inuti en container eller ett försök att öppna en\nTCP-port. Det är regeln som gör kontrollen till mer än en mätning: en misslyckad\nhälsokontroll kan ta en server ur rotation, starta om en container, stoppa en\ndriftsättning eller väcka någon mitt i natten.\n\nDocker bygger in idén i själva imagen. Instruktionen `HEALTHCHECK` i en\nDockerfile anger ett kommando som Docker kör inuti containern med ett fast\nintervall. Slutkod 0 betyder att containern är frisk, 1 att den inte är det, och\n2 är reserverad och får inte användas. En container med en kontroll börjar i\ntillståndet `starting`, blir `healthy` så snart en kontroll går igenom och\növergår till `unhealthy` efter ett bestämt antal misslyckanden i rad.\nStandardvärdena är en kontroll var 30:e sekund, en tidsgräns på 30 sekunder och\ntre försök; en körning som överskrider sin tidsgräns räknas som ett\nmisslyckande, och dess process avslutas med tvång. En valfri startperiod ger ett\nlångsamt program tid att starta, och misslyckanden under den räknas inte. En\nDockerfile har en sådan instruktion, den sista gäller om det finns flera, och\n`HEALTHCHECK NONE` stänger av en kontroll som ärvts från basimagen.\n\nKubernetes delar upp frågan i tre prober, var och en med sin egen konsekvens. En\nstartup-prob frågar om programmet har startat klart; tills den lyckas väntar de\ntvå andra, och om den fortsätter att misslyckas avslutas containern och hanteras\nenligt sin omstartspolicy. En liveness-prob frågar om containern ska startas om\noch är avsedd för tillstånd som ett dödläge (deadlock), där processen kör men\ninte kommer framåt. En readiness-prob frågar om containern ska få trafik. När\nden misslyckas startas ingenting om; i stället tas Podens adress bort från\nendpoints för varje Service som väljer den, och förfrågningarna går till de\nandra replikerna tills proben går igenom igen.\n\nVarje prob använder en av fyra mekanismer. En `httpGet`-prob går igenom på varje\nstatuskod från och med 200 till och med 399. En `tcpSocket`-prob går igenom om\nporten tar emot en anslutning, även en som stängs direkt. En `grpc`-prob går\nigenom när tjänstens hälsokontroll i gRPC svarar `SERVING`. En `exec`-prob kör\nett kommando i containern och går igenom på slutkod 0. Om inget annat anges\nkontrollerar Kubernetes var tionde sekund, väntar en sekund på svar och agerar\nefter tre misslyckanden i rad.\n\nLastbalanserare lägger till en andra sort. Kontrollerna ovan är aktiva: något\nskickar en testförfrågan oavsett om det finns användare eller inte. En passiv\nkontroll följer i stället den verkliga trafiken. Så fungerar nginx med öppen\nkällkod: när en förfrågan till en upstream-server slutar med ett fel markerar\nnginx servern som felande och undviker den en stund, och med standardvärdet 1\nför `max_fails` räcker ett enda misslyckat försök. Enligt dokumentationen för\nnginx hör hälsokontroller av applikationer (application health checks) till\nfunktionerna i de betalda NGINX Plus-prenumerationerna. En passiv kontroll\nkostar inget extra, men den får veta att en server är trasig genom en användares\nmisslyckade förfrågan, och den säger ingenting om en server som inte får någon\ntrafik.\n\n## Varför det spelar roll\n\nEn process som kör är inte detsamma som en tjänst som fungerar. Dockers referens\nnämner det typiska fallet: en webbserver som har fastnat i en oändlig loop och\nslutat ta emot anslutningar medan processen fortfarande lever. Allt som bara\nhåller koll på om processen finns, till exempel en\n[systemd](/sv/glossary/#systemd)-enhet med omstartspolicy, ser inget fel. Bara\nen fråga som ställs genom samma dörr som användarna går in genom kan se\nskillnaden, och det är hela poängen med en hälsokontroll: den byter ut ”kör\nden?” mot ”svarar den?”.\n\nTvå beslut avgör om en kontroll är nyttig eller farlig. Det första är vad\nkontrollen testar, vilket i praktiken är en definition av ”fungerar”, skriven i\nkod. En hanterare som returnerar 200 utan att röra något bevisar att\nwebbramverket är uppe; en hanterare som också frågar databasen bevisar att\ndatabasen går att nå, och misslyckas när den inte gör det. Det andra är vad som\nhänder vid ett misslyckande, och det avgör hur långt skadan når. Att ta en\nreplik ur rotation är billigt och går att ångra. Att starta om den kastar bort\ndet arbete den höll på med och dess varma cachar, och om alla repliker\nmisslyckas med samma kontroll samtidigt gör en omstart av alla ett långsamt\nberoende till ett totalt driftstopp.\n\nKubernetes varnar för just detta. Dokumentationen säger att liveness-prober\nmåste ställas in så att de verkligen visar ett fel som programmet inte kan\nåterhämta sig från på egen hand, och att en felaktig implementering kan orsaka\nkaskadfel: containrar som startas om under hög belastning, klientförfrågningar\nsom misslyckas och mer arbete för de poddar som är kvar. Rådet som följer är att\nhålla isär de två frågorna. När ett program är strikt beroende av bakomliggande\ntjänster ska dess liveness-prob gå igenom så länge programmet självt är friskt,\nmedan readiness-proben också kontrollerar varje nödvändig tjänst bakom. Då\nundviker trafiken en Pod som bara kunde ha svarat med fel, och Poden dödas inte\nför ett fel som ligger någon annanstans.\n\nHälsokontroller kommer också [övervakningen](/sv/glossary/#monitoring) till\ngodo. En endpoint som en lastbalanserare frågar kan också frågas utifrån, och\ndet larm som går när den fallerar är ofta det första tecknet på en\n[incident](/sv/glossary/#incident). När Irakli Nadareishvili skrev Health Check\nResponse Format for HTTP APIs, ett Internet-Draft inom IETF, fanns det ingen\nstandard för vad en sådan endpoint ska returnera, och de flesta program nöjde\nsig med HTTP-statuskoden eller använde ett eget format. Utkastet föreslog ett\nJSON-svar med medietypen `application/health+json` och ett obligatoriskt\n`status`-fält med värdet `pass`, `fail` eller `warn`, där `pass` och `warn` hör\nihop med en statuskod i 2xx eller 3xx och `fail` med en i 4xx eller 5xx. Den\nsista versionen, från oktober 2021, löpte ut i april 2022, och IETF anger att\nden varken är godkänd av IETF eller har någon formell status. Den är användbar\nsom ett gemensamt ordförråd, inte som en standard.\n\n## Så ser det ut i praktiken\n\nI en Dockerfile följer kontrollen med den image den kontrollerar. Här frågar\nprogrammets eget lilla probprogram efter en sökväg på localhost och avslutar med\n0 eller 1:\n\n```dockerfile\nHEALTHCHECK --interval=15s --timeout=3s --start-period=60s --retries=3 \\\n  CMD [\"/app/bin/probe\", \"http://127.0.0.1:8080/livez\"]\n```\n\nDocker kör proben var 15:e sekund och ger varje körning tre sekunder.\nMisslyckanden under den första minuten räknas inte, om inte en kontroll redan\nhar gått igenom, och i Docker Engine 25.0 eller senare körs kontrollerna under\nden minuten var femte sekund, vilket är standardintervallet under startperioden,\nså att en snabb start märks snabbt. Efter tre misslyckanden i rad markeras\ncontainern som `unhealthy`. De första 4096 byten av probens utdata sparas för\n`docker inspect`, och varje statusändring skickar ut en\n`health_status`-händelse. Referensen beskriver ett tillstånd, inte en åtgärd:\nnågot annat måste agera på det.\n\nI Kubernetes kan de tre proberna få var sin sökväg, så att var och en ställer\nsin egen fråga:\n\n```yaml\ncontainers:\n  - name: api\n    ports:\n      - containerPort: 8080\n    startupProbe:\n      httpGet: { path: /livez, port: 8080 }\n      periodSeconds: 5\n      failureThreshold: 24 # upp till 2 minuter att starta\n    livenessProbe:\n      httpGet: { path: /livez, port: 8080 }\n      periodSeconds: 10\n      timeoutSeconds: 2\n      failureThreshold: 6 # ungefär en minut före omstart\n    readinessProbe:\n      httpGet: { path: /readyz, port: 8080 }\n      periodSeconds: 5\n      timeoutSeconds: 2\n      failureThreshold: 2\n```\n\n`/livez` svarar bara för själva processen, medan `/readyz` också kontrollerar\ndatabasen och allt annat som en förfrågan inte klarar sig utan. Startup-proben\nanvänder liveness-sökvägen, som dokumentationen för Kubernetes rekommenderar,\noch ger 24 × 5 sekunder innan containern ges upp. När den har gått igenom tar\nliveness över med lång stubin och readiness med kort: ungefär tio sekunder av\nmisslyckanden tar Poden ur Servicen, och en minut av dem startar om den.\nStandardvärdena skulle ge tre misslyckanden med tio sekunders mellanrum, och det\när för lite för ett program som behöver två minuter för att läsa in sina data.\nDokumentationens egen tumregel är att en container som vanligtvis tar längre tid\natt starta än initialDelaySeconds plus failureThreshold × periodSeconds behöver\nen startup-prob.\n\nEn hälsokontroll kan också vändas ut och in. I [värdövervakning med dödmansgrepp](/sv/portfolio/built-dead-mans-switch-host-monitoring/), från september 2026, kontrollerar en värd på 464 MB som kör en git-forge och en webbserver sig själv var femtonde minut, med slumpmässig förskjutning: ett litet skript mäter tillgängligt minne och ledigt diskutrymme och pingar en extern tjänst bara om båda ligger över sina tröskelvärden. Tystnaden är larmet. En värd som har fått slut på minne, tappat nätverket eller slutat starta ger samma signal som en som bara inte är frisk, och därför valdes den här formen framför en agent som rapporterar en status. Kontrollen läser tillgängligt minne och inte ledigt minne, eftersom kärnan använder outnyttjat minne som cache, och sex variabelnamn som sa ”free” rättades, så att ingen skulle ”laga” ett fungerande larm till ett som löser ut permanent. En mottagen signal bekräftar att skriptet kördes och att dess tröskelkontroller för tillgängligt minne och ledigt diskutrymme godkändes; den intygar inte värdens allmänna tillstånd eller att webbplatsen svarar. Övervakning kan visa varningssignaler, men tidpunkten beror på belastningen och de förhållanden som observeras.\n\nEn kontroll vid uppstart besvarar ännu en fråga. I\n[e-post med failover och leveransloggning](/sv/portfolio/built-email-with-failover-and-delivery-logging/),\nfrån 2025, går posten genom tre leverantörer med automatisk failover, och\nframför alltihop skickar en kontroll vid uppstart ett verkligt meddelande genom\nhela stacken, bakom en flagga. I utveckling loggar ett misslyckande en varning\noch programmet fortsätter; i staging och produktion är felet fatalt, och\nprocessen avslutas i stället för att ett bygge som inte kan skicka e-post\ndriftsätts. Sidan sammanfattar resultatet så här: en hel kategori av tysta fel\nflyttades från ”en användare märker det dagar senare” till ”driftsättningen\nstoppas”.\n\n## Var det går fel\n\n**Kontrollen bevisar bara att processen svarar.** En hanterare som returnerar\n200 utan att röra något förblir grön medan databasen inte går att nå, disken är\nfull eller varje verklig förfrågan slutar med ett fel. Låt readiness-kontrollen\npröva det en förfrågan behöver, på ett billigt sätt, och lägg till en kontroll\nutifrån som följer användarens väg genom DNS, TLS och lastbalanseraren, eftersom\nkubelet skickar sina prober direkt till Podens egen IP-adress och inte ser något\nav det.\n\n**Liveness beror på något utanför containern.** Om liveness-proben frågar\ndatabasen får en långsam databas den att misslyckas i alla repliker på en gång,\noch Kubernetes startar om dem alla precis när tjänsten redan har det svårt. Låt\nliveness bara svara för själva processen, som dokumentationen för Kubernetes\nråder, och lägg beroendena i readiness, där ett misslyckande leder bort trafiken\ni stället för att döda containrar.\n\n**Tidsinställningarna passar inte programmet.** Kubernetes väntar som standard\nen sekund på svar, så en endpoint som blir långsammare under belastning\nmisslyckas medan programmet bara har mycket att göra, och en container som\nstartar långsammare än dess liveness-prob tillåter dödas innan den är klar, om\noch om igen. Mät hur lång tid endpointen tar under belastning och sätt\ntidsgränsen över det, och ge långsamma program en startup-prob som är\ndimensionerad efter den långsammaste verkliga starten.\n\n**En omdirigering går igenom.** En HTTP-prob i Kubernetes räknar varje status\nfrån 200 till 399 som en framgång, så en sökväg som omdirigerar till en\ninloggningssida ser frisk ut. Pekar omdirigeringen till en annan värd följer\nkubelet den inte, utan registrerar proben som lyckad med en varning. Med HTTPS\nhoppar kubelet dessutom över certifikatkontrollen, så ett utgånget certifikat\nfår aldrig en prob att misslyckas. Rikta proberna mot en sökväg som svarar 200\ndirekt och returnerar en 5xx när något är fel, och kontrollera certifikaten\nutifrån.\n\n**Endpointen säger för mycket till för många.** Ett detaljerat svar som räknar\nupp varje beroende, version och värdnamn informerar en angripare lika väl som en\nlastbalanserare, och säkerhetsavsnittet i utkastet påpekar att endpoints för\nhälsokontroller kan behöva autentisering och rollbaserad åtkomstkontroll.\nBegränsa det offentliga svaret till en status, och visa detaljerna bara på en\nintern port eller för autentiserade klienter.\n\n**Kontrollen kostar mer än den borde.** Kubernetes varnar för att `exec`-prober\nstartar nya processer vid varje körning, vilket på tätt packade noder med korta\nintervall kan öka CPU-belastningen på noden, och en prob som kör en tung fråga\nmed några sekunders mellanrum på varje replik är en belastning i sig. Föredra\nHTTP-, TCP- eller gRPC-prober, håll endpointen billig och cacha resultatet av en\ndyr beroendekontroll i några sekunder i stället för att upprepa den för varje\nprob.\n\n## Läs mer\n\n- [Dockerfile reference: HEALTHCHECK](https://docs.docker.com/reference/dockerfile/#healthcheck)\n  — instruktionen, dess alternativ och standardvärden och vad varje slutkod\n  betyder.\n- [Liveness, Readiness, and Startup Probes](https://kubernetes.io/docs/concepts/workloads/pods/probes/)\n  — vad varje probtyp gör, de fyra kontrollmekanismerna och alla\n  konfigurationsfält med sina standardvärden.\n- [Configure Liveness, Readiness and Startup Probes](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/)\n  — genomgångna exempel, bland annat en startup-prob som ger ett långsamt\n  program fem minuter.\n- [Health Check Response Format for HTTP APIs](https://datatracker.ietf.org/doc/draft-inadarei-api-health-check/)\n  — det utgångna Internet-Draftet bakom `application/health+json` och dess\n  statusvärden pass, fail och warn.\n- [Using nginx as HTTP load balancer](https://nginx.org/en/docs/http/load_balancing.html)\n  — de passiva hälsokontrollerna i nginx med öppen källkod, som sker i själva\n  trafiken (in-band), och inställningarna `max_fails` och `fail_timeout`.\n\n\u003chttps://engineer.company/sv/glossary/health-check/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hur en körande tjänst tillfrågas om den kan göra sitt jobb, vad Docker och Kubernetes gör med svaret och hur en illa vald kontroll orsakar driftstopp.","formats":{"gemtext":"https://engineer.company/sv/glossary/health-check/index.gmi","gopher":"https://engineer.company/sv/glossary/health-check/gophermap","html":"https://engineer.company/sv/glossary/health-check/","json":"https://engineer.company/sv/glossary/health-check/index.json","markdown":"https://engineer.company/sv/glossary/health-check/index.md","pdf":"https://engineer.company/sv/glossary/health-check/index.pdf"},"kind":"page","language":"sv","title":"Vad är en hälsokontroll?","url":"https://engineer.company/sv/glossary/health-check/","version":1}