{"canonical_url":"https://engineer.company/sv/glossary/container-runtime/","content_markdown":"# Containerkörmiljö\n\n## Vad det är\n\nEn containerkörmiljö är programvaran som står mellan en containeravbildning på\ndisken och en isolerad process i kärnan. På engelska heter den container\nruntime, och i svenskt tal hörs ofta bara runtime eller körmiljö. Uttrycket\ntäcker två lager, och folk menar ofta olika saker med det: körmiljön på låg\nnivå, som också kallas OCI-körmiljön, och körmiljön på hög nivå, som oftare\nkallas containermotor (container engine).\n\nKörmiljön på låg nivå gör ett enda smalt jobb. Den läser in ett paket, i\nspecifikationen kallat bundle, som körmiljöspecifikationen från Open Container\nInitiative definierar som en katalog med en `config.json`-fil och containerns\nrotfilsystem. Den ber kärnan om de namnrymder, cgroups och monteringar som\nkonfigurationen beskriver och startar processen inuti dem. Specifikationen\nnamnger de operationer som varje körmiljö måste stödja, nämligen create, start,\nkill, delete och en fråga om tillståndet, och lämnar kommandoraden åt varje\nimplementation. Version 1.0 publicerades i juli 2017. runc, som OCI självt\nunderhåller, beskriver sig som ett verktyg på låg nivå som inte är tänkt för en\nslutanvändare. crun gör samma jobb i C med ett mindre minnesavtryck och är den\nstandard som Podmans dokumentation anger. youki är en tredje, skriven i Rust.\n\nMotorn ligger ovanpå. containerd beskriver sig som en daemon som hanterar hela\nlivscykeln för containrarna på sin maskin: överföring och lagring av\navbildningar, körning och tillsyn av containrar och de lagrings- och\nnätverkskopplingar som hör till dem. CRI-O gör ett liknande jobb, byggt enbart\nför Kubernetes. En motor hämtar och packar upp avbildningen, skriver paketet,\nlämnar över det till körmiljön på låg nivå och fortsätter att bevaka processen\nefter att den körmiljön har avslutats. Docker Engine ligger ytterligare ett steg\nhögre: enligt dess dokumentation använder den containerd för containrarnas\nlivscykel, och containerd använder i sin tur runc som standard. Podman går den\nandra vägen och har ingen daemon som körs hela tiden. Varje kommando förbereder\npaketet självt, anropar crun eller runc och lämnar en liten övervakare som heter\nconmon att ta hand om den körande containern.\n\nKubernetes lägger till ytterligare ett ord i vokabulären. Kubelet på varje nod\ntalar med motorn via Container Runtime Interface, CRI, ett gRPC-protokoll som\nbåde containerd och CRI-O implementerar. Docker Engine är äldre än CRI, så i\nflera år bar Kubernetes med sig en adapter för den som hette dockershim, och den\ntogs bort i v1.24.\n\n## Varför det spelar roll\n\nAtt välja containerkörmiljö är i själva verket att välja vilket lager man byter,\noch de två lagren ger olika saker.\n\nMotorn avgör hur containrarna lever från dag till dag: vem som hämtar och lagrar\navbildningar, vem som startar om en container som har kraschat, vart dess loggar\ntar vägen, vilket API andra verktyg talar och vem som äger processträdet. Att\nbyta Docker Engine mot Podman på en server, eller mot containerd på en nod i\nKubernetes, ändrar allt detta och lämnar själva containrarna orörda, eftersom\navbildningsformatet och paketet bygger på samma OCI-standarder därunder.\nKubernetes dokumentation om borttagningen av dockershim säger det rakt ut:\navbildningar som har byggts med `docker build` fungerar med alla\nCRI-implementationer.\n\nKörmiljön på låg nivå avgör hur isolerad processen är. runc och crun startar en\nvanlig process på maskinens egen kärna, vilket är snabbt och helt kompatibelt\noch betyder att varje container på maskinen delar just den kärnan. gVisors\nkörmiljö, runsc, lägger en applikationskärna skriven i Go mellan containern och\nmaskinen och besvarar containerns systemanrop själv. Projektets egen\ndokumentation anger priset som sämre kompatibilitet för applikationer och högre\noverhead per systemanrop. Kata Containers startar varje arbetslast i en lätt\nvirtuell maskin med en egen kärna, använder hårdvaruvirtualisering som ett andra\nförsvarslager och behöver en hypervisor på varje nod som kör den.\n\nKubernetes låter det andra valet göras per pod i stället för per kluster. En\nRuntimeClass namnger en hanterare som är konfigurerad i motorn, och en pod som\nsätter `runtimeClassName` körs under den hanteraren, så att en arbetslast man\ninte litar på kan ligga i gVisor eller Kata medan allt annat stannar på runc.\nDokumentationen beskriver detta som en avvägning mellan prestanda och säkerhet.\n\n## Så ser det ut i praktiken\n\nI vardagligt tal glider uttrycket mot motorlagret, och arbetet på den här\nwebbplatsen använder det i den betydelsen.\n\nTjugo applikationer paketerade med Docker,\n[utspridda över två moln och några körmiljöer för containrar](/sv/portfolio/ran-20-docker-apps-on-google-cloud-and-aws/),\nbehövde driftsättas konsekvent och kunna felsökas snabbt när något gick sönder.\nDocker paketerade dem, felsökningen gick genom Podman och felsökningen av\norkestreringen genom Kubernetes. Att arbeta över flera motorer på det sättet\nvilar på lagerindelningen ovan: motorerna skiljer sig åt, men OCI-standarderna\nför avbildningar och körmiljöer under dem är gemensamma.\n\nPå en nyare server gjordes valet i motorlagret.\n[Containerskiktet körs på Podman och Quadlet i stället för Docker](/sv/portfolio/ran-containers-on-podman-and-quadlet/),\neftersom standardmotorn publicerar containerportar ovanför de brandväggsregler\nsom härdningsrollen installerar, och eftersom den skulle lägga till en andra\ntillsynsprocess bredvid systemd. Det valet ändrade är vem som startar varje\ncontainer och vem som bevakar den efteråt: containrarna blev tjänster som\nstartar på samma sätt som tjänster startar, under den tillsyn som maskinen redan\nlitade på.\n\nSamma resonemang gäller för [en värddator med 512 MB för företagets publika\ntjänster](/sv/portfolio/a-whole-company-on-one-small-server/), där minnet\navgjorde varje diskussion. Containerskiktet där är Quadlet-enheter under systemd\nsnarare än en daemon med en egen tillsynsprocess, ett val som gjordes på en\nmaskin där ungefär 464 MB minne går att använda.\n\n## Var det går fel\n\nProblem med körmiljön brukar dyka upp i skarvarna mellan lagren, där varje sida\nutgår från att den andra är uppsatt på det sätt den själv väntar sig.\n\n**Verktygen på noden tappar sikten efter en uppgradering av klustret.** Från och\nmed Kubernetes v1.24 talar kubelet direkt med containerd eller CRI-O, så de\ncontainrar som klustret startar passerar aldrig genom Docker Engine.\n`docker ps` på noden listar bara det som Docker själv har startat, och\növervakningsagenter, startskript och privilegierade poddar som anropar Dockers\nCLI eller monterar `docker.sock` förlorar sin överblick. Arbetslasterna\nfortsätter att köras. Det är verktygen runt dem som behöver flyttas till\n`crictl` eller till motorns eget API.\n\n**Kubelet och körmiljön hanterar cgroups på två olika sätt.** Båda måste använda\nsamma cgroup-drivrutin, `cgroupfs` eller `systemd`, och kubelet använder\n`cgroupfs` som standard. På en maskin där systemd är init-systemet blir det två\nhanterare av cgroups med två bilder av samma resurser, och Kubernetes\ndokumentation varnar för att sådana noder kan bli instabila när resurserna\ntryter. Lösningen är systemd-drivrutinen på båda sidor, som också är den\nrekommenderade drivrutinen med cgroup v2. För containerd 2.x med runc ser\nkörmiljöns sida ut så här:\n\n```toml\n# /etc/containerd/config.toml, containerd 2.x\n[plugins.'io.containerd.cri.v1.runtime'.containerd.runtimes.runc.options]\n  SystemdCgroup = true\n```\n\nKubelets sida är `cgroupDriver: systemd` i dess konfiguration, och containerd\nbehöver startas om efteråt. containerd 1.x stavar avsnittet annorlunda, och\nKubernetes sida visar båda formerna. Att byta drivrutin på en nod som redan har\ngått med i ett kluster är känsligt: poddar som skapades under den ena\ndrivrutinen kan stöta på fel när de skapas på nytt under den andra, så det\ndokumenterade rådet är att ersätta eller installera om noden med den nya\nkonfigurationen.\n\n**En pod som flyttas till en sandlådad körmiljö stannar vid start.** En\nRuntimeClass vars hanterare nodens motor saknar skickar podden direkt till fasen\nFailed, med orsaken i en händelse. Därefter måste arbetslasten passa sandlådan.\ngVisor besvarar systemanrop i sin egen kärna, så programvara som lutar sig mot\nmindre vanliga funktioner i kärnan kan bete sig annorlunda, och dokumentationen\npekar ut arbetslaster med många systemanrop som en dålig matchning. Kata behöver\nhårdvaruvirtualisering på noden, vilket på en virtuell maskin i molnet betyder\nnästlad virtualisering. En nodväljare under `scheduling` i RuntimeClass håller\nsådana poddar på de noder som kan köra dem.\n\n**En avbildning som har importerats för hand syns aldrig för kubelet.**\ncontainerd håller namn och metadata för avbildningar per namnrymd. Klienten\n`ctr` arbetar i namnrymden `default` om inget annat anges, medan\nCRI-insticksmodulen som kubelet talar med arbetar i `k8s.io`. En avbildning som\nläses in med ett vanligt `ctr images import` hamnar därför där kubelet aldrig\ntittar, och podden går tillbaka till registret eller stannar med ett fel vid\nhämtningen av avbildningen. Att importera med `ctr -n k8s.io images import` och\nkontrollera med `crictl images`, som ser det som kubelet ser, täpper till\nglappet.\n\n## Läs mer\n\n- [OCI Runtime Specification](https://github.com/opencontainers/runtime-spec) —\n  standarden som varje körmiljö på låg nivå implementerar: paketet,\n  `config.json` och operationerna i livscykeln.\n- [runc](https://github.com/opencontainers/runc) — OCI:s egen körmiljö, med\n  anteckningar om hur verktyg på högre nivå styr den.\n- [Container Runtimes](https://kubernetes.io/docs/setup/production-environment/container-runtimes/)\n  — cgroup-drivrutiner, CRI-versioner och de inställningar för containerd och\n  CRI-O som Kubernetes förväntar sig.\n- [Container Runtime Interface (CRI)](https://kubernetes.io/docs/concepts/containers/cri/)\n  — gRPC-protokollet mellan kubelet och motorn.\n- [Runtime Class](https://kubernetes.io/docs/concepts/containers/runtime-class/)\n  — att välja en annan hanterare för körmiljön per pod och hålla de poddarna på\n  noder som stöder den.\n- [Alternative container runtimes](https://docs.docker.com/engine/daemon/alternative-runtimes/)\n  — hur Docker Engine lämnar över containrar till gVisor, Kata Containers, youki\n  eller Wasmtime.\n\n\u003chttps://engineer.company/sv/glossary/container-runtime/\u003e\n","date_modified":"2026-11-08T02:22:23Z","description":"Skillnaden mellan runc och en containermotor, var Docker, containerd och CRI-O hör hemma och vad noderna i ett kluster tappar när dockershim försvinner.","formats":{"gemtext":"https://engineer.company/sv/glossary/container-runtime/index.gmi","gopher":"https://engineer.company/sv/glossary/container-runtime/gophermap","html":"https://engineer.company/sv/glossary/container-runtime/","json":"https://engineer.company/sv/glossary/container-runtime/index.json","markdown":"https://engineer.company/sv/glossary/container-runtime/index.md","pdf":"https://engineer.company/sv/glossary/container-runtime/index.pdf"},"kind":"page","language":"sv","title":"Vad är en containerkörmiljö?","url":"https://engineer.company/sv/glossary/container-runtime/","version":1}