Hur fungerar Docker under huven?

Question

IT Interview Practice · Accepted Answer

Docker använder Linux-kernelfunktioner — **namespaces** (isolering), **cgroups** (resurskontroll) och **union-filsystem** (skiktade avbildningar) — för att skapa lätta behållare. Att förstå de underliggande mekanismerna förklarar hur behållare uppnår isolering och effektivitet.

## Namespaces — isolering

```text
Linux NAMESPACES isolate what a process can SEE — giving each container its own view:
  PID namespace     → its own process tree (container sees only its processes)
  NET namespace     → its own network interfaces, IPs, ports
  MNT namespace     → its own filesystem mounts
  UTS namespace     → its own hostname
  IPC, USER namespaces → isolated IPC, user/group ID mapping
→ Namespaces are WHY a container feels like a separate machine (isolated view),
  while actually sharing the host kernel.
```

## cgroups — resurskontroll

```text
Control Groups (CGROUPS) LIMIT and account for resource usage per container:
  → CPU, memory, disk I/O, network bandwidth
→ cgroups are WHY you can set resource limits (-m, --cpus) — the kernel enforces them.
```

## Union-filsystem — skiktade avbildningar

```text
UNION/OVERLAY filesystems (overlayfs) stack image LAYERS:
  → read-only image layers + a thin writable container layer on top, merged into one view
  → layers are SHARED between images/containers (one copy on disk) → space-efficient
→ This is WHY images are layered, cached, and shareable, and containers are lightweight.
```

## Arkitekturen

```text
Docker CLI → Docker DAEMON (dockerd) → containerd → runc (creates containers using
  namespaces + cgroups). The daemon manages images, containers, networks, volumes.
→ Containers are just ISOLATED PROCESSES on the host (not VMs) — using kernel features,
  sharing the host kernel → lightweight and fast.
```

## Varför det är viktigt

Att förstå hur Docker fungerar under huven är värdefull kunskap på seniornivå eftersom det **avmystifierar behållare** och förklarar deras nyckelegenskaper (isolering, effektivitet, resurskontroll), vilket fördjupar förmågan att resonera om, konfigurera och felsöka behållarbaserade system.

Den avgörande insikten är att **behållare inte är virtuella maskiner — de är isolerade processer på värden** som använder Linux-kernelfunktioner, vilket är anledningen till att de är lätta och snabba (delar värdkärnans snarare än att köra separata operativsystem).

Att förstå de **tre kärnmekanismerna** förklarar egenskaperna: **namespaces** isolerar vad en process kan se (dess egen processträd, nätverk, filsystem, värdnamn — vilket är *anledningen till* att en behållare känns som en separat maskin trots att den delar kärnans), **cgroups** begränsar och redogör för resursanvändning (vilket är *anledningen till* att du kan ställa in gränser för CPU och minne — kärnans tillämpar dem), och **union/overlay-filsystem** staplar avbildningsskikt (vilket är *anledningen till* att avbildningar är skiktade, cachade och delbara, och behållare är lätta — skrivskyddade skikt delade över behållare med ett tunt skrivbart skikt överst).

Att förstå **arkitekturen** (CLI → daemon → containerd → runc, där daemonen hanterar allt) ger den kompletta bilden av hur Docker fungerar.

Den här djupare förståelsen hjälper att resonera om isolergränser (och deras säkerhetsbetydelser, eftersom behållare delar kärnans), förklarar prestanda- och effektivitetsegenskaper och hjälper till vid felsökning.

Eftersom förståelse av de underliggande mekanismerna (namespaces, cgroups, union-filsystem) förklarar *varför* behållare beter sig som de gör — deras isolering, effektivitet, resurskontroll och det viktiga faktum att de delar värdkärnans (med säkerhetsbetydelser) — och fördjupar förmågan att arbeta med behållarbaserade system med förtroende, är förståelse för hur Docker fungerar under huven värdefull kunskap på seniornivå som höjer en från att använda Docker till att verkligen förstå det, ett ämne som återspeglar djupet som förväntas för seniorrroller och användbart för att resonera om behållarbeteende, säkerhetsgränser och prestanda.

Namespaces — isolering

cgroups — resurskontroll

Union-filsystem — skiktade avbildningar

Arkitekturen

Varför det är viktigt

Relaterade frågor