{"canonical_url":"https://engineer.company/da/glossary/health-check/","content_markdown":"# Health check\n\n## Hvad det er\n\nEt health check er en lille test, der gentages efter en fast plan og spørger en\nkørende tjeneste, om den kan gøre sit arbejde, sammen med en regel for, hvad der\nsker, når svaret er nej. Testen kan være en HTTP-forespørgsel til en særlig sti,\nen kommando, der køres inde i en container, eller et forsøg på at åbne en\nTCP-port. Det er reglen, der gør tjekket til mere end en måling: et fejlet\nhealth check kan tage en server ud af rotation, genstarte en container, stoppe\nen udrulning eller vække nogen.\n\nDocker bygger ideen ind i selve imaget. Instruktionen `HEALTHCHECK` i en\nDockerfile angiver en kommando, som Docker kører inde i containeren med et fast\ninterval. Afslutningskode 0 betyder sund, 1 betyder usund, og 2 er reserveret og\nmå ikke bruges. En container med et tjek starter i tilstanden `starting`, bliver\n`healthy`, så snart ét tjek går igennem, og skifter til `unhealthy` efter et\nfastsat antal fejl i træk. Standardværdierne er et tjek hvert 30. sekund, en\ntimeout på 30 sekunder og tre forsøg; en kørsel, der overskrider sin timeout,\ntæller som en fejl, og dens proces bliver dræbt. En valgfri startperiode giver\net langsomt program tid til at starte op, og fejl inden for den tæller ikke. En\nDockerfile rummer én sådan instruktion, den sidste vinder, hvis der er flere, og\n`HEALTHCHECK NONE` slår et tjek fra, der er arvet fra basisimaget.\n\nKubernetes deler spørgsmålet op i tre prober, som hver har sin egen konsekvens.\nEn startup probe spørger, om programmet er færdigt med at starte; indtil den\nlykkes, venter de to andre, og bliver den ved med at fejle, dræbes containeren\nog overlades til sin genstartspolitik. En liveness probe spørger, om containeren\nskal genstartes, og er beregnet til tilstande som en deadlock, hvor processen\nkører, men ikke kommer videre. En readiness probe spørger, om containeren skal\nhave trafik. Når den fejler, genstartes containeren ikke; i stedet fjernes\nPod'ens adresse fra endpoints for hver Service, der matcher den, og\nforespørgslerne går til de andre replikaer, indtil proben svarer rigtigt igen.\n\nHver probe bruger én af fire mekanismer. En `httpGet`-probe går igennem på\nenhver statuskode fra 200 til og med 399. En `tcpSocket`-probe går igennem, hvis\nporten tager imod en forbindelse, også én, der bliver lukket med det samme. En\n`grpc`-probe går igennem, når tjenestens health check i gRPC svarer `SERVING`.\nEn `exec`-probe kører en kommando i containeren og går igennem på\nafslutningskode 0. Medmindre andet er angivet, prober Kubernetes hvert tiende\nsekund, venter ét sekund på svar og handler efter tre fejl i træk.\n\nLoad balancere tilføjer en anden slags. Tjekkene ovenfor er aktive: noget sender\nen testforespørgsel, uanset om der er brugere eller ej. Et passivt tjek holder i\nstedet øje med den rigtige trafik. Sådan arbejder open source-udgaven af nginx:\nnår en forespørgsel til en upstream-server ender med en fejl, markerer nginx\nserveren som fejlet og undgår den et stykke tid, og med standardværdien 1 for\n`max_fails` er ét mislykket forsøg nok. Ifølge nginx' dokumentation hører\napplication health checks til de betalte NGINX Plus-abonnementer. Et passivt\ntjek koster ikke ekstra, men det opdager en ødelagt server gennem en brugers\nmislykkede forespørgsel, og det siger intet om en server, der ikke får trafik.\n\n## Hvorfor det betyder noget\n\nEn kørende proces er ikke det samme som en tjeneste, der virker. Dockers\nreference nævner det typiske eksempel: en webserver, der sidder fast i en\nuendelig løkke og er holdt op med at tage imod forbindelser, mens processen\nstadig lever. Alt, hvad der kun holder øje med, om processen findes, som en\n[systemd](/da/glossary/#systemd)-unit med en genstartspolitik, ser ingen fejl.\nKun et spørgsmål, der stilles gennem den samme dør, som brugerne bruger, kan se\nforskellen, og det er hele begrundelsen for et health check: det erstatter\n»kører den?« med »svarer den?«.\n\nTo beslutninger afgør, om et tjek er nyttigt eller farligt. Den første er, hvad\ntjekket tester, og det svarer til en definition af »virker«, skrevet i kode. En\nhandler, der returnerer 200 uden at røre noget, beviser, at webframeworket er\noppe; en handler, der også spørger databasen, beviser, at databasen kan nås, og\nfejler, når den ikke kan. Den anden er, hvad der sker ved en fejl, og den afgør,\nhvor langt skaden rækker. At tage én replika ud af rotation er billigt og kan\nrulles tilbage. At genstarte den smider dens igangværende arbejde og dens varme\ncaches væk, og fejler alle replikaer det samme tjek på samme tid, gør en\ngenstart af dem alle en langsom afhængighed til et totalt nedbrud.\n\nKubernetes advarer netop mod det. Dokumentationen skriver, at liveness probes\nskal sættes op, så de virkelig viser en fejl, der ikke kan rettes på anden måde,\nog at en forkert implementering kan give kaskadefejl: containere, der genstartes\nunder høj belastning, klientforespørgsler, der fejler, og mere arbejde til de\npods, der er tilbage. Rådet, der følger, er at holde de to spørgsmål adskilt.\nNår et program er strengt afhængigt af bagvedliggende tjenester, skal dets\nliveness probe gå igennem, så længe programmet selv er sundt, mens dets\nreadiness probe også tjekker hver nødvendig tjeneste bagved. Så undgår trafikken\nen Pod, der kun kan svare med fejl, og Pod'en bliver ikke dræbt for en fejl, der\nligger et andet sted.\n\nHealth checks fodrer også [overvågningen](/da/glossary/#monitoring). Et\nendpoint, som en load balancer spørger, kan også spørges udefra, og den alarm,\nder går, når det fejler, er ofte det første tegn på en\n[driftshændelse](/da/glossary/#incident). Da Irakli Nadareishvili skrev\nInternet-Draftet Health Check Response Format for HTTP APIs, fandtes der ingen\nstandard for, hvad sådan et endpoint returnerer, og de fleste programmer nøjedes\nmed HTTP-statuskoden eller brugte deres eget format. Draftet foreslog et\nJSON-svar med medietypen `application/health+json` og et obligatorisk\n`status`-felt med værdien `pass`, `fail` eller `warn`, hvor `pass` og `warn`\nhører sammen med en statuskode i 2xx eller 3xx og `fail` med en i 4xx eller 5xx.\nDen sidste udgave, fra oktober 2021, udløb i april 2022, og IETF angiver, at den\nhverken er godkendt af IETF eller har formel status. Den er brugbar som fælles\nordforråd, ikke som standard.\n\n## Sådan ser det ud i praksis\n\nI en Dockerfile følger tjekket med det image, det tjekker. Her spørger\nprogrammets eget lille probeprogram en sti på localhost og afslutter med 0 eller\n1:\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ører proben hvert 15. sekund og giver hver kørsel tre sekunder. Fejl i\ndet første minut tæller ikke, medmindre et tjek allerede er gået igennem, og på\nDocker Engine 25.0 eller nyere kører tjekkene i det minut hvert femte sekund,\nsom er standardintervallet i startperioden, så en hurtig start bliver opdaget\nhurtigt. Efter tre fejl i træk markeres containeren som `unhealthy`. De første\n4096 byte af probens output gemmes til `docker inspect`, og hver statusændring\nudsender en `health_status`-hændelse. Referencen beskriver en status, ikke en\nhandling: noget andet skal reagere på den.\n\nI Kubernetes kan de tre prober få hver sin sti, så hver af dem stiller sit eget\nspørgsmål:\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 # op til 2 minutter til at starte\n    livenessProbe:\n      httpGet: { path: /livez, port: 8080 }\n      periodSeconds: 10\n      timeoutSeconds: 2\n      failureThreshold: 6 # cirka et minut før en genstart\n    readinessProbe:\n      httpGet: { path: /readyz, port: 8080 }\n      periodSeconds: 5\n      timeoutSeconds: 2\n      failureThreshold: 2\n```\n\n`/livez` svarer kun for selve processen, mens `/readyz` også tjekker databasen\nog alt andet, en forespørgsel ikke kan undvære. Startup proben bruger\nliveness-stien, som Kubernetes' dokumentation anbefaler, og giver 24 × 5\nsekunder, før containeren opgives. Når den er gået igennem, tager liveness over\nmed en lang lunte og readiness med en kort: omkring ti sekunders fejl tager\nPod'en ud af Servicen, og et minuts fejl genstarter den. Standardværdierne ville\ngive tre fejl med ti sekunders mellemrum, og det er for lidt til et program, der\nskal bruge to minutter på at indlæse sine data. Dokumentationens egen\ntommelfingerregel er, at en container, der normalt er længere tid om at starte\nend den indledende forsinkelse plus failureThreshold × periodSeconds, skal have\nen startup probe.\n\nEt health check kan også vendes på hovedet. I [overvågning med dead man's switch](/da/portfolio/built-dead-mans-switch-host-monitoring/), fra september 2026, tjekker en vært med 464 MB, der kører en forge og en webserver, sig selv hvert kvarter med jitter: et lille script måler den tilgængelige hukommelse og den ledige diskplads og pinger kun en ekstern tjeneste, når begge ligger over deres tærskelværdier. Tavsheden er alarmen. En vært, der er løbet tør for hukommelse, har mistet netværket eller ikke længere kan starte, giver det samme signal som en, der bare er usund, og derfor blev den løsning valgt frem for en agent, der rapporterer en status. Tjekket læser tilgængelig hukommelse og ikke fri hukommelse, fordi kernen fylder ledig hukommelse med cache, og seks variabelnavne, der sagde »free«, blev rettet, så ingen ville »reparere« en fungerende alarm til en, der står permanent i alarm. Et modtaget signal bekræfter, at scriptet kørte, og at dets tærskelkontroller for tilgængelig hukommelse og ledig diskplads blev bestået; det dokumenterer ikke værtens generelle tilstand eller, at sitet svarer. Overvågning kan afsløre advarselstegn, men tidspunktet afhænger af belastningen og de forhold, der observeres.\n\nEt tjek ved opstart besvarer et helt tredje spørgsmål. I\n[e-mail med failover og leveringslog](/da/portfolio/built-email-with-failover-and-delivery-logging/),\nfra 2025, går mailen gennem tre udbydere med automatisk failover, og foran det\nhele sender et opstartstjek en rigtig besked gennem hele stakken, styret af et\nflag. I udviklingsmiljøet logger en fejl en advarsel, og programmet fortsætter;\ni staging og produktion er fejlen fatal, og processen stopper i stedet for at\nudrulle et build, der ikke kan sende mail. Siden opsummerer resultatet sådan, at\nen hel kategori af lydløse fejl gik fra »en bruger opdager det dage senere« til\n»udrulningen stopper«.\n\n## Hvor det går galt\n\n**Tjekket beviser kun, at processen svarer.** En handler, der returnerer 200\nuden at røre noget, forbliver grøn, mens databasen er utilgængelig, disken er\nfuld, eller hver eneste rigtige forespørgsel ender med en fejl. Lad\nreadiness-tjekket afprøve det, en forespørgsel har brug for, på en billig måde,\nog tilføj et tjek udefra, der følger brugerens vej gennem DNS, TLS og load\nbalanceren, for kubelet sender sine prober direkte til Pod'ens egen IP-adresse\nog ser intet af det.\n\n**Liveness afhænger af noget uden for containeren.** Spørger liveness proben\ndatabasen, får en langsom database den til at fejle i alle replikaer på én gang,\nog Kubernetes genstarter dem alle, netop mens tjenesten i forvejen er presset.\nLad liveness kun svare for selve processen, som Kubernetes' dokumentation råder\ntil, og læg afhængighederne i readiness, hvor en fejl leder trafikken væk i\nstedet for at dræbe containere.\n\n**Tiderne passer ikke til programmet.** Kubernetes venter som standard ét sekund\npå svar, så et endpoint, der bliver langsommere under belastning, fejler, mens\nprogrammet blot har travlt, og en container, der starter langsommere, end dens\nliveness probe tillader, bliver dræbt, før den er klar, igen og igen. Mål, hvor\nlang tid endpointet tager under belastning, og sæt timeouten over det, og giv\nlangsomme programmer en startup probe, der er dimensioneret efter den langsomste\nreelle opstart.\n\n**En omdirigering går igennem.** En HTTP-probe i Kubernetes regner enhver status\nfra 200 til 399 som en succes, så en sti, der omdirigerer til en loginside, ser\nsund ud. Peger omdirigeringen på en anden vært, følger kubelet den ikke, men\nregistrerer proben som vellykket med en advarsel. Med HTTPS springer kubelet\ndesuden certifikatkontrollen over, så et udløbet certifikat får aldrig en probe\ntil at fejle. Peg proberne på en sti, der svarer 200 direkte og returnerer en\n5xx, når noget er galt, og tjek certifikater udefra.\n\n**Endpointet fortæller for meget til for mange.** Et detaljeret svar, der\nopregner hver afhængighed, version og værtsnavn, oplyser en angriber lige så\ngodt som en load balancer, og Internet-Draftets afsnit om sikkerhed bemærker, at\nhealth check-endpoints kan have brug for autentificering og rollebaseret\nadgangskontrol. Hold det offentlige svar til en status, og vis kun detaljerne på\nen intern port eller til autentificerede klienter.\n\n**Tjekket koster mere, end det bør.** Kubernetes advarer om, at `exec`-prober\nstarter nye processer ved hver kørsel, hvilket på tætpakkede noder med korte\nintervaller kan give et mærkbart CPU-forbrug på noden, og en probe, der kører en\ntung forespørgsel med få sekunders mellemrum på hver replika, er en belastning i\nsig selv. Foretræk HTTP-, TCP- eller gRPC-prober, hold endpointet billigt, og\ngem resultatet af et dyrt afhængighedstjek i nogle sekunder i stedet for at\ngentage det ved hver probe.\n\n## Læs mere\n\n- [Dockerfile reference: HEALTHCHECK](https://docs.docker.com/reference/dockerfile/#healthcheck)\n  — instruktionen, dens indstillinger og standardværdier, og hvad hver\n  afslutningskode betyder.\n- [Liveness, Readiness, and Startup Probes](https://kubernetes.io/docs/concepts/workloads/pods/probes/)\n  — hvad hver probetype gør, de fire tjekmekanismer og alle konfigurationsfelter\n  med deres standardværdier.\n- [Configure Liveness, Readiness and Startup Probes](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/)\n  — gennemgåede eksempler, blandt andet en startup probe, der giver et langsomt\n  program fem minutter.\n- [Health Check Response Format for HTTP APIs](https://datatracker.ietf.org/doc/draft-inadarei-api-health-check/)\n  — det udløbne Internet-Draft bag `application/health+json` og dets\n  statusværdier pass, fail og warn.\n- [Using nginx as HTTP load balancer](https://nginx.org/en/docs/http/load_balancing.html)\n  — de passive in-band-tjek i open source-udgaven af nginx og indstillingerne\n  `max_fails` og `fail_timeout`.\n\n\u003chttps://engineer.company/da/glossary/health-check/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hvordan en kørende tjeneste bliver spurgt, om den kan gøre sit arbejde, hvad Docker og Kubernetes gør med svaret, og hvordan et dårligt tjek giver nedbrud.","formats":{"gemtext":"https://engineer.company/da/glossary/health-check/index.gmi","gopher":"https://engineer.company/da/glossary/health-check/gophermap","html":"https://engineer.company/da/glossary/health-check/","json":"https://engineer.company/da/glossary/health-check/index.json","markdown":"https://engineer.company/da/glossary/health-check/index.md","pdf":"https://engineer.company/da/glossary/health-check/index.pdf"},"kind":"page","language":"da","title":"Hvad er et health check?","url":"https://engineer.company/da/glossary/health-check/","version":1}