{"canonical_url":"https://engineer.company/sv/glossary/kubernetes/","content_markdown":"# Kubernetes\n\n## Vad det är\n\nKubernetes, ofta skrivet K8s, är programvara med öppen källkod som kör containeriserade\napplikationer på en grupp maskiner, ett kluster, och håller dem i linje med en beskrivning som du\nger den: vilken avbildning varje applikation kör, hur många kopior som finns, hur mycket minne och\nprocessor varje kopia får använda och hur andra program når den. Projektets egen dokumentation\nkallar den en portabel och utbyggbar plattform med öppen källkod för att hantera containeriserade\narbetslaster och tjänster. Namnet är grekiska för rorsman eller lots, K8s räknar de åtta\nbokstäverna mellan K och s, och Google släppte projektet som öppen källkod 2014.\n\nEtt kluster har två halvor. Styrplanet (control plane) håller beskrivningen: API-servern är det enda\nHTTP-gränssnitt som varje ändring passerar, etcd lagrar det som den får veta, schemaläggaren\ntilldelar varje ny pod en lämplig nod, och controller manager kör de styrslingor som agerar utifrån\nbeskrivningen. På varje arbetsnod ser kubelet till att de poddar som har tilldelats noden körs,\n`kube-proxy` underhåller nätverksreglerna bakom en Service, och en containerkörmiljö som containerd\neller CRI-O startar containrarna. Docker Engine slutade vara en inbyggd körmiljö i Kubernetes 1.24,\noch avbildningar som har byggts med Docker körs ändå oförändrade, eftersom de är vanliga\nOCI-avbildningar.\n\nBeskrivningen är en uppsättning objekt, oftast skrivna som YAML. En Pod är den minsta enhet som\nKubernetes schemalägger: en eller flera containrar som delar nätverksadress och lagring på en\nmaskin, i dagligt tal en pod, flera poddar. En Deployment anger hur många likadana poddar som ska\nfinnas och byter ut dem steg för steg när deras mall ändras. En Service ger en föränderlig\nuppsättning poddar ett stabilt namn och en stabil adress och väljer sina medlemmar efter etikett.\nEn liten webbapplikation ser ut så här:\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 vägs oftast mot tre mindre alternativ. Docker Compose beskriver containrar på en\nmaskin, och när maskinen försvinner gör de det också. En tjänstehanterare som systemd kan starta om\nen container som har kraschat och starta den vid uppstart, vilket täcker väldigt många behov med\nbetydligt mindre maskineri, men den har inget begrepp om att flytta arbete till en annan maskin.\nHostade plattformar som Google Cloud Run eller Azure Container Apps kör containrar utan att lämna\növer ett styrplan som du måste driva, i utbyte mot färre inställningar. Dokumentationen säger också\nrakt ut vad Kubernetes inte är: en traditionell, allomfattande plattform som tjänst. Den bygger\ninte din applikation, och den levereras inte med några egna databaser eller meddelandeköer.\n\n## Varför det spelar roll\n\nDen bärande idén är att klustret hela tiden arbetar mot en skriven beskrivning, i stället för att\nköra en lista med kommandon en gång. Att tillämpa filen ovan startar ingenting direkt; den\nregistrerar en önskan. Controllers är styrslingor som bevakar klustret och agerar för att föra\ndess nuvarande tillstånd närmare det önskade. Om en maskin dör och tre kopior blir två ser\ncontrollern för din Deployment glappet, en ny pod skapas, och schemaläggaren placerar den på en\nmaskin med utrymme. Eftersom beskrivningen är en uppsättning filer kan den ligga i ett repo och gå\nigenom samma granskning som koden den kör.\n\nReleaser följer med plattformen. En Deployments förvalda strategi är en rullande uppdatering: nya\npoddar startar, och gamla stoppas i takt med att de nya blir redo, inom gränser som förvalt är\n25 % extra och 25 % saknade vid varje tidpunkt. Varje ändring av poddmallen sparas som en\nrevision, tio som förval, och `kubectl rollout undo` går tillbaka till den föregående. Skriptet\nsom en gång tömde en server, bytte en binär och tog tillbaka den blir inbyggt beteende.\n\nSchemaläggaren ändrar också ekonomin för en maskinpark. Den placerar varje pod efter den processor\noch det minne som podden begär, så att många små tjänster delar en uppsättning maskiner i stället\nför att var och en får en server dimensionerad för sin sämsta dag.\n\nPriset är verkligt. Ett kluster är ett distribuerat system i sin egen rätt, med versioner att\nuppgradera enligt schema, ett nätverkslager, ett lagringslager, certifikat och åtkomstkontroll,\noch någon måste förstå allt det när det beter sig illa. Hanterade tjänster som Google Kubernetes\nEngine, Amazon EKS och Azure Kubernetes Service driver styrplanet åt dig, men varje manifest, och\noftast arbetsnoderna, förblir ditt ansvar. För en handfull tjänster på en eller två maskiner gör en\nvanlig tjänstehanterare ofta jobbet med färre rörliga delar.\n\n## Så ser det ut i praktiken\n\n[Företagets sida om teknikstacken](/sv/tech-stack/) säger regeln rakt ut: Docker och Kubernetes för\nde arbetslaster som förtjänar dem, och vanliga systemd-enheter för dem som inte gör det. Kubernetes\nväljs per arbetslast, efter jobbets storlek och form, och inte som förval.\n\nArbetslaster som förtjänade det finns i ett uppdrag.\n[Tjugo Docker-applikationer driftsattes och underhölls i Google Cloud och AWS](/sv/portfolio/ran-20-docker-apps-on-google-cloud-and-aws/),\ndäribland några R-baserade analysappar, med enhetlig konfiguration och övervakning så att ingen\napplikation blev ett specialfall. Felsökningen gjordes med Podman, och orkestreringen felsöktes\nmed Kubernetes. Sidan redovisar att problem diagnostiserades snabbare och att driftsättningarna\nförblev stabila och reproducerbara.\n\nDen andra halvan av regeln syns på företagets egen plattform.\n[En containermiljö byggd på Podman och Quadlet](/sv/portfolio/ran-containers-on-podman-and-quadlet/)\nkör varje container som en tjänst under operativsystemets egen tjänstehanterare, beskriven i samma\ndeklarativa form som allt annat på värden. Containrarna använder värdnätverk och publicerar inga\nportar, så brandväggsreglerna som härdningsrollen installerar behåller kontrollen. En release görs\nav en användare utan privilegier, som kör ett och samma fasta skript; skriptet bygger avbildningen\noch startar om tjänsten. På en enda värd ger det varje container en skriven beskrivning och den\ntjänstehanterare som värden redan litar på, utan någon andra processhanterare. Det som lämnas\nutanför är placering över flera maskiner och att ersätta en död nod, och det är där Kubernetes\nbörjar betala för sin vikt.\n\n## Var det går fel\n\nDe flesta problem med Kubernetes kommer ur glappet mellan vad ett manifest begär och vad klustret\nrapporterar tillbaka.\n\n**En utrullning står halvfärdig medan pipelinen rapporterar framgång.** När nya poddar aldrig blir\nredo, på grund av fel avbildningstagg, en krasch vid start, en readiness-prob som fallerar eller en\nkvot som tar slut, slutar din Deployment att göra framsteg. Efter tidsgränsen för framsteg, som\nförvalt är 600 sekunder, registrerar den orsaken `ProgressDeadlineExceeded`, och dokumentationen\nsäger att Kubernetes inte vidtar någon annan åtgärd: de gamla poddar som fortfarande körs fortsätter\natt svara, och ingenting rullas tillbaka av sig självt. `kubectl rollout status` avslutas med en\nnollskild kod när tidsgränsen har passerats, så ett driftsättningssteg kan vänta på det och ångra\nreleasen:\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 startas om med `OOMKilled`, eller går långsamt på en nod med ledig processorkraft.**\nSystemkärnan upprätthåller gränserna, och de två resurserna beter sig olika. En container över sin\nminnesgräns kan dödas och startas om; en som ligger vid sin processorgräns stryps, så den går\nlångsammare utan att dö, vilket ser ut som ett problem i applikationen. Schemaläggaren placerar\npoddar efter vad de begär, inte efter vad de använder, så låga begäranden tränger ihop en nod och\nhöga lämnar maskiner sysslolösa. En gräns som anges utan en begäran blir begäran. Sätt minnet\nutifrån uppmätt användning, och behandla processorgränser som ett medvetet beslut.\n\n**En applikation som startar långsamt dödas innan den har startat färdigt.** En liveness-prob som\nfallerar får kubelet att döda och starta om containern, så en applikation som behöver en minut för\natt läsa in sig, och som kontrolleras efter tio sekunder, startar om i all evighet. En startup-prob\nhåller de andra kontrollerna borta tills applikationen är uppe. En readiness-prob tar ut en pod ur\ndess Service utan att starta om den, vilket passar en pod som är upptagen eller värmer upp en\ncache. En liveness-prob som anropar databasen startar om varje replik på en gång när databasen är\nlångsam, och gör ett långsamt beroende till ett driftstopp.\n\n**En pod som startats för hand försvinner, och en rättning gjord för hand går förlorad.** En pod\nsom skapats på egen hand ligger kvar på sin nod tills den avslutas, raderas eller vräks, eller tills\nnoden går sönder, och ingen controller skapar den på nytt; dokumentationen råder till en Deployment\neller ett Job även för en enda kopia. En ändring gjord med `kubectl edit` lever bara i klustret,\noch nästa tillämpning från repot lägger tillbaka det gamla värdet, så en nödrättning hör hemma i\nfilerna så snart nödläget är över.\n\n## Läs mer\n\n- [Kubernetes overview](https://kubernetes.io/docs/concepts/overview/) — projektets egen\n  redogörelse för vad Kubernetes är, vad det erbjuder och vad det lämnar utanför.\n- [Pods](https://kubernetes.io/docs/concepts/workloads/pods/) — den minsta enhet som Kubernetes\n  schemalägger, dess livscykel och varför poddar sällan skapas för hand.\n- [Deployments](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/)\n  — rullande uppdateringar, återställningar, revisionshistorik och tidsgränsen för framsteg.\n- [Service](https://kubernetes.io/docs/concepts/services-networking/service/) — stabila namn och\n  adresser framför en föränderlig uppsättning poddar.\n- [Resource Management for Pods and Containers](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/)\n  — begäranden, gränser och hur kärnan upprätthåller var och en.\n- [Configure Liveness, Readiness and Startup Probes](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/)\n  — de tre proberna och hur en container som startar långsamt skyddas.\n\n\u003chttps://engineer.company/sv/glossary/kubernetes/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hur poddar, Deployments och Services hänger ihop i Kubernetes, när en enda värd med systemd räcker, och de fyra sätt som ett kluster oftast orsakar problem på.","formats":{"gemtext":"https://engineer.company/sv/glossary/kubernetes/index.gmi","gopher":"https://engineer.company/sv/glossary/kubernetes/gophermap","html":"https://engineer.company/sv/glossary/kubernetes/","json":"https://engineer.company/sv/glossary/kubernetes/index.json","markdown":"https://engineer.company/sv/glossary/kubernetes/index.md","pdf":"https://engineer.company/sv/glossary/kubernetes/index.pdf"},"kind":"page","language":"sv","title":"Vad är Kubernetes?","url":"https://engineer.company/sv/glossary/kubernetes/","version":1}