Hur fungerar Docker-bildlagers och byggcache?

Question

Accepted Answer

Docker-bilder bygges i **lager** — varje Dockerfile-instruktion skapar ett lager, och Docker **cachar** lager för att snabba upp ombyggnader. Förståelse för lager och caching är nyckeln till att skriva effektiva Dockerfiles som bygger snabbt och producerar mindre bilder.

## Lager — varje instruktion lägger till ett lager

```text
Each Dockerfile instruction (FROM, RUN, COPY, etc.) creates a read-only LAYER:
  → layers stack to form the image; layers are CACHED and SHARED between images
  → if a layer is unchanged, Docker REUSES the cached layer (skips rebuilding it)
→ Layer caching makes rebuilds fast — only changed layers (and those AFTER) rebuild.
```

## Cachningsregeln (ordningen är viktig)

```text
Docker caches layers IN ORDER. When an instruction's input changes, that layer AND
ALL layers AFTER IT are rebuilt (cache invalidated from that point down).
→ Put STABLE things EARLY and FREQUENTLY-CHANGING things LATE in the Dockerfile.
```

## Den klassiska optimeringen: beroenden före kod

```dockerfile
# ✅ GOOD — copy dependency manifest first, install, THEN copy code
COPY package*.json ./
RUN npm install          # this layer is cached UNLESS package.json changes
COPY . .                 # code changes here don't invalidate the npm install layer

# ❌ BAD — copy everything first
COPY . .                 # ANY code change invalidates...
RUN npm install          # ...so npm install RE-RUNS on every code change (slow!)
```

Genom att kopiera beroendafiler och installera **före** kopiering av resten av koden, förblir lagret för beroendinstallation (långsamt) i cache över kodändringar — en enormt viktig optimering som gör ombyggnader snabba.

## Minska bildstorlek

```text
✓ Combine related RUN commands (fewer layers) and clean up in the SAME layer
  RUN apt-get update && apt-get install -y x && rm -rf /var/lib/apt/lists/*
✓ Use small base images (alpine, slim, distroless)
✓ Use .dockerignore to exclude unneeded files from the build context
✓ Use multi-stage builds (build artifacts in one stage, copy only what's needed)
```

## Varför det är viktigt

Förståelse för Docker-lager och byggcache är viktigt för **att skriva effektiva Dockerfiles** som bygger snabbt och producerar mindre bilder, därför är det värdefull praktisk kunskap som avsevärt påverkar utvecklarproduktivitet och distribution.

Det fundamentala konceptet — varje Dockerfile-instruktion skapar ett cachad, återanvändbart **lager**, och Docker **återanvänder oförändrade cachade lager** medan det bygger om ändrade lager och allt därefter — förklarar hur man gör byggningar snabba.

Den **kritiska cachningsregeln** (cache ogiltigförklaras från den första ändrade instruktionen nedåt, så ordningen är viktig: stabila saker tidigt, ofta ändrade saker sent) driver den **enskilt viktigaste optimeringen**: kopiera beroendafiler och installera beroenden **före** kopiering av applikationskod, så lagret för långsam beroendinstallation förblir i cache över de frekventa kodändringarna (snarare än att köra `npm install`/`pip install` vid varje kodändring — en skillnad mellan snabba och smärtsamt långsamma ombyggnader).

Förstå bara det här mönstret förbättrar byggningarna dramatiskt, ett konstant utvecklarupplevelseproblem.

Känna till tekniker för att **minska bildstorlek** — kombinera RUN-kommandon med rensning i samma lager, använd små basbilder (alpine, slim, distroless), `.dockerignore` för att utesluta onödiga filer, och flerstegiga byggen — producerar mindre, snabbare att distribuera bilder (reducerar lagring, överföringstid och attackyta).

Eftersom Docker-byggen sker konstant (i utveckling och CI/CD) och långsamma byggen eller överlastad bilder skadar produktivitet och distribution, och eftersom förståelse för lager och caching är vad som möjliggör skrivande av Dockerfiles som bygger snabbt och förblir små, förståelse för Docker-lager och byggcache — lagermodellen, den orderöberoendet cachningsregeln, optimeringen för beroenden-före-kod, och teknikerna för storleksminskning — är värdefull, ofta använd kunskap för effektiv Docker-användning, en nyckelfärdighet som skiljer dem som skriver snabba, magra Dockerfiles från dem som drabbas av långsamma byggen och överlastad bilder.