{"canonical_url":"https://engineer.company/da/glossary/kubernetes/","content_markdown":"# Kubernetes\n\n## Hvad det er\n\nKubernetes, ofte forkortet K8s, er open source-software, der kører\ncontaineriserede applikationer på en gruppe maskiner, en klynge, og hele tiden\nholder dem på den beskrivelse, man har givet den: hvilket image hver applikation\nkører, hvor mange kopier der skal findes, hvor meget hukommelse og CPU hver kopi\nmå bruge, og hvordan andre programmer når frem til den. Projektets egen\ndokumentation kalder det en portabel og udvidelig platform til at styre\ncontaineriserede arbejdsbyrder og tjenester. Navnet er græsk for rorsmand eller\npilot, tallet i K8s tæller de otte bogstaver mellem K og s, og Google frigav\nprojektet som open source i 2014.\n\nEn klynge har to halvdele. Kontrolplanet rummer beskrivelsen: API-serveren er\nden ene HTTP-grænseflade, som enhver ændring går igennem, etcd gemmer det, den\nfår at vide, scheduleren tildeler hver ny pod en passende node, og\ncontroller-manageren kører de løkker, der handler på beskrivelsen. På hver\narbejdsnode sørger kubelet for, at de pods, der er tildelt den, kører,\nkube-proxy vedligeholder netværksreglerne bag Services, og en container-runtime\nsom containerd eller CRI-O starter selve containerne. Docker Engine holdt op med\nat være en indbygget runtime i Kubernetes 1.24, men images bygget med Docker\nkører uændret, fordi de er almindelige OCI-images.\n\nBeskrivelsen består af objekter, som regel skrevet i YAML. En pod er den mindste\nenhed, Kubernetes placerer: en eller flere containere, der deler netværksadresse\nog lager på én maskine. Et Deployment angiver, hvor mange ens pods der skal\nfindes, og udskifter dem trinvis, når deres skabelon ændres. En Service giver en\nskiftende flok pods ét fast navn og én fast adresse og vælger sine medlemmer ud\nfra labels. En lille webapplikation ser sådan ud:\n\n```text\napiVersion: apps/v1\nkind: Deployment\nmetadata:\n  name: web\nspec:\n  replicas: 3\n  selector:\n    matchLabels:\n      app: web\n  template:\n    metadata:\n      labels:\n        app: web\n    spec:\n      containers:\n        - name: web\n          image: registry.example.com/web:1.4.2\n          resources:\n            requests:\n              cpu: 250m\n              memory: 256Mi\n            limits:\n              memory: 256Mi\n          readinessProbe:\n            httpGet:\n              path: /healthz\n              port: 8080\n```\n\nKubernetes holdes typisk op mod tre mindre løsninger. Docker Compose beskriver\ncontainere på én maskine, og forsvinder maskinen, forsvinder de med den. En\ntjenestestyring som systemd kan genstarte en container, der går ned, og starte\nden, når maskinen booter; det dækker rigtig mange behov med langt mindre\nmaskineri, men den kan ikke flytte arbejde til en anden maskine. Hostede\nplatforme som Google Cloud Run eller Azure Container Apps kører containere uden\nat overlade et kontrolplan til dig, til gengæld med færre indstillinger.\nDokumentationen siger også ligeud, at Kubernetes er noget andet end en\ntraditionel alt-i-en-PaaS: det bygger ikke din applikation og leverer hverken\ndatabaser eller beskedkøer selv.\n\n## Hvorfor det betyder noget\n\nGrundtanken er, at klyngen hele tiden arbejder hen imod en skreven beskrivelse i\nstedet for at køre en række kommandoer én gang. Når filen ovenfor anvendes,\nstarter den ikke noget direkte; den registrerer et ønske. Controllere er\nkontrolløkker, der holder øje med klyngen og handler for at bringe den aktuelle\ntilstand tættere på den ønskede. Dør en maskine, så tre kopier bliver til to,\nser Deploymentets controller forskellen, en ny pod oprettes, og scheduleren\nplacerer den på en maskine med plads. Og fordi beskrivelsen er filer, kan den\nligge i et repository og gennemgås på samme måde som den kode, den kører.\n\nUdrulning følger med platformen. Et Deployments standardstrategi er en rullende\nopdatering: nye pods starter, og gamle stopper i takt med, at de nye bliver\nklar, inden for grænser, der som standard er 25 % ekstra og 25 % manglende ad\ngangen. Hver ændring af pod-skabelonen gemmes som en revision, ti som standard,\nog `kubectl rollout undo` går tilbage til den forrige. Det script, der engang\ntømte en server, skiftede en binær fil ud og satte serveren i drift igen, bliver\ntil indbygget adfærd.\n\nScheduleren ændrer også regnestykket for en flåde af maskiner. Den placerer hver\npod efter den CPU og hukommelse, poden anmoder om, så mange små tjenester kan\ndele et sæt maskiner i stedet for at få hver sin server dimensioneret til den\nværste dag.\n\nPrisen er reel. En klynge er selv et distribueret system med versioner, der skal\nopgraderes efter en plan, et netværkslag, et lagerlag, certifikater og\nadgangskontrol, og nogen skal forstå det hele, når det driller. Administrerede\ntilbud som Google Kubernetes Engine, Amazon EKS og Azure Kubernetes Service\ndriver kontrolplanet for dig, men hvert manifest og som regel også\narbejdsnoderne forbliver dit ansvar. Til en håndfuld tjenester på en eller to\nmaskiner klarer en almindelig tjenestestyring ofte opgaven med færre bevægelige\ndele.\n\n## Sådan ser det ud i praksis\n\n[Virksomhedens side om teknologier](/da/tech-stack/) trækker en klar grænse:\nDocker og Kubernetes bruges til de arbejdsbyrder, der har brug for dem, og\nalmindelige systemd-units til resten. Kubernetes vælges efter opgavens størrelse\nog form, ikke som en vane.\n\nArbejdsbyrder af den første slags ses i én opgave.\n[Tyve Docker-applikationer kørte i drift på Google Cloud og AWS](/da/portfolio/ran-20-docker-apps-on-google-cloud-and-aws/),\nheriblandt analyseapps skrevet i R, med ensartet konfiguration og overvågning,\nså hver applikation fulgte samme mønster. Fejlsøgning foregik gennem Podman, og\nfejlsøgning af orkestreringen gennem Kubernetes. Siden melder om hurtigere\ndiagnose af problemer og om udrulninger, der holdt sig stabile og gav samme\nresultat hver gang.\n\nDen anden halvdel af reglen ses på virksomhedens egen platform.\n[Et containerplan bygget på Podman og Quadlet](/da/portfolio/ran-containers-on-podman-and-quadlet/)\nkører hver container som en tjeneste under styresystemets egen supervisor,\nbeskrevet i samme deklarative form som resten af værten. Containerne bruger\nværtens netværk og publicerer ingen porte, så de firewallregler, hærdningsrollen\ninstallerer, bevarer kontrollen. En uprivilegeret bruger udruller ved at køre ét\nfast script, der bygger imaget og genstarter tjenesten. På én vært giver det\nhver container en skreven beskrivelse og den supervisor, værten allerede stoler\npå, uden en ekstra processtyring ved siden af. Det, opsætningen lader ligge, er\nplacering på tværs af maskiner og erstatning af en død node, og det er netop\ndér, Kubernetes begynder at være sin vægt værd.\n\n## Hvor det går galt\n\nDe fleste problemer med Kubernetes opstår i afstanden mellem det, et manifest\nbeder om, og det, klyngen melder tilbage.\n\n**En udrulning går i stå halvvejs, mens udrulningspipelinen melder succes.** Når\nnye pods aldrig bliver klar, på grund af et forkert image-tag, et nedbrud ved\nstart, en readiness-probe, der fejler, eller en kvote, der slipper op, holder\nDeploymentet op med at gøre fremskridt. Efter fremdriftsfristen, som standard\n600 sekunder, registrerer det årsagen `ProgressDeadlineExceeded`, og ifølge\ndokumentationen gør Kubernetes ikke mere end det: de gamle pods, der stadig\nkører, betjener fortsat trafikken, og intet rulles tilbage af sig selv. `kubectl\nrollout status` afslutter med en exitkode forskellig fra nul, når fristen er\noverskredet, så et deploy-trin kan vente på den og rulle udgivelsen tilbage:\n\n```sh\nkubectl apply -f web.yaml\nkubectl rollout status deployment/web --timeout=10m \\\n  || kubectl rollout undo deployment/web\n```\n\n**En container genstarter med `OOMKilled` eller bliver langsom på en node med\nledig CPU.** Grænserne håndhæves af kernen, og de to ressourcer opfører sig\nforskelligt. En container over sin hukommelsesgrænse kan blive dræbt og\ngenstartet, når kernen mærker pres på hukommelsen; en container ved sin\nCPU-grænse bliver droslet og kører langsommere uden at dø, hvilket ligner en\nfejl i applikationen. Scheduleren placerer pods efter det, de anmoder om, og\nikke efter det, de bruger, så lave requests overfylder en node, og høje lader\nmaskiner stå ubrugte hen. En grænse uden request bliver selv til requesten. Sæt\nhukommelse ud fra målt forbrug, og gør CPU-grænser til en bevidst beslutning.\n\n**En applikation, der starter langsomt, bliver dræbt, før den er kommet op.**\nNår en liveness-probe fejler, dræber kubelet containeren og starter den igen, så\nen applikation, der skal bruge et minut på at starte, men tjekkes efter ti\nsekunder, genstarter i det uendelige. En startup-probe holder de andre tjek\ntilbage, indtil applikationen kører. En readiness-probe tager en pod ud af sin\nService uden at genstarte den, hvilket passer til en pod, der har travlt eller\nvarmer en cache op. En liveness-probe, der kalder databasen, genstarter alle\nreplikaer på én gang, når databasen er langsom, og gør dermed en langsom\nafhængighed til et nedbrud.\n\n**En pod, der er startet i hånden, forsvinder, og en rettelse lavet i hånden\nbliver rullet tilbage.** En pod oprettet på egen hånd bliver på sin node, til\nden afslutter, slettes, smides ud, eller noden svigter, og ingen controller\ngenskaber den; dokumentationen anbefaler et Deployment eller et Job, selv til én\nenkelt kopi. En ændring lavet med `kubectl edit` findes kun i klyngen, og næste\napply fra repositoriet sætter den gamle værdi tilbage, så en nødrettelse hører\nhjemme i filerne, så snart nøden er overstået.\n\n## Læs mere\n\n- [Kubernetes overview](https://kubernetes.io/docs/concepts/overview/) —\n  projektets egen beskrivelse af, hvad Kubernetes er, hvad det tilbyder, og hvad\n  det lader ligge.\n- [Pods](https://kubernetes.io/docs/concepts/workloads/pods/) — den mindste\n  enhed, Kubernetes placerer, dens livsforløb, og hvorfor pods sjældent oprettes\n  i hånden.\n- [Deployments](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/)\n  — rullende opdateringer, tilbagerulning, revisionshistorik og\n  fremdriftsfristen.\n- [Service](https://kubernetes.io/docs/concepts/services-networking/service/) —\n  faste navne og adresser foran en skiftende flok pods.\n- [Resource Management for Pods and Containers](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/)\n  — requests, grænser, og hvordan kernen håndhæver hver af dem.\n- [Configure Liveness, Readiness and Startup Probes](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/)\n  — de tre prober, og hvordan en container, der starter langsomt, beskyttes.\n\n\u003chttps://engineer.company/da/glossary/kubernetes/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hvad Kubernetes er, hvordan pods, Deployments og Services spiller sammen, hvornår én vært med systemd rækker, og hvor klynger oftest driller.","formats":{"gemtext":"https://engineer.company/da/glossary/kubernetes/index.gmi","gopher":"https://engineer.company/da/glossary/kubernetes/gophermap","html":"https://engineer.company/da/glossary/kubernetes/","json":"https://engineer.company/da/glossary/kubernetes/index.json","markdown":"https://engineer.company/da/glossary/kubernetes/index.md","pdf":"https://engineer.company/da/glossary/kubernetes/index.pdf"},"kind":"page","language":"da","title":"Hvad er Kubernetes?","url":"https://engineer.company/da/glossary/kubernetes/","version":1}