Hvordan optimerer du Docker-image-størrelse og build-performance?

Question

Accepted Answer

Optimering af Docker-images handler om at reducere **størrelse** (mindre, hurtigere, mere sikkert) og forbedre **build-performance** (hurtigere builds via caching). Teknikker omfatter minimale base-images, multi-stage builds, layer-optimering, BuildKit og omhyggelig Dockerfile-design.

## Reduktion af image-størrelse

```text
✓ MINIMAL base images:
  - alpine (tiny, ~5MB) — but musl libc can cause compatibility issues for some apps
  - slim variants (e.g. python:3.12-slim) — smaller than full, fewer compat issues
  - DISTROLESS — only the app + runtime, NO shell/package manager (smallest, most secure)
  - scratch — empty base (for static binaries, e.g. Go) → minimal image
✓ MULTI-STAGE builds — build with tools, ship only the artifact (huge size savings)
✓ Combine RUN layers + clean up IN the same layer:
  RUN apt-get update && apt-get install -y x && rm -rf /var/lib/apt/lists/*
  (cleanup in a SEPARATE layer doesn't shrink the image — the files are in the earlier layer)
✓ .dockerignore — keep junk out of the context/image
✓ Remove caches, temp files, dev dependencies in production images
```

## Forbedring af build-performance

```text
✓ LAYER CACHING — order Dockerfile so stable layers (deps) come before volatile (code)
✓ BUILDKIT (DOCKER_BUILDKIT=1 / default in modern Docker) — faster, parallel builds,
  better caching, build secrets, cache mounts
✓ CACHE MOUNTS — RUN --mount=type=cache,target=/root/.npm npm install
  → persist package-manager caches BETWEEN builds (don't re-download every time)
✓ Registry cache / --cache-from — reuse cached layers in CI (where the cache is cold)
```

## Multi-stage + distroless eksempel

```dockerfile
FROM golang:1.22 AS build
WORKDIR /app
COPY . .
RUN CGO_ENABLED=0 go build -o app .

FROM gcr.io/distroless/static     # no shell, no OS — tiny and secure
COPY --from=build /app/app /app
ENTRYPOINT ["/app"]
# → final image is a few MB: just the static binary (vs ~800MB with the full golang image)
```

## Hvorfor det betyder noget

Optimering af Docker-image-størrelse og build-performance er værdifuld senior-level viden, fordi det direkte påvirker **deployment-hastighed, lagringsomkostninger, sikkerhed og udvikler-produktivitet**, så det er praktisk vigtigt for produktions-kvalitet containerization. **Reduktion af image-størrelse** betyder noget, fordi mindre images deployer og pulls hurtigere, koster mindre at lagre, og er **mere sikre** (færre pakker = mindre angrebsflade): ved at bruge **minimale base-images** (alpine, slim, og især **distroless** — indeholdende kun appen og runtime uden shell eller package manager, de mindste og mest sikre — eller `scratch` til statiske binaries), **multi-stage builds** (kun shipping af artifacts), og omhyggelig **layer-optimering** (kombinering af RUN-kommandoer med cleanup i det *samme* layer, da cleanup i et separat layer faktisk ikke shrinkker imagen — en almindelig misforståelse) kan dramtisk reducere images (f.eks. fra ~800MB til få MB). **Forbedring af build-performance** betyder noget, fordi langsomme builds skader udvikler-produktivitet og CI-throughput: ved at udnytte **layer caching** (rækkefølge for stabil-før-volatil), **BuildKit** (hurtigere parallelle builds med bedre caching), og især **cache mounts** (persistering af package-manager-caches mellem builds, så dependencies ikke re-downloades hver gang — en betydelig speedup) og registry cache til CI gør alle builds hurtigere.

Forståelse af disse teknikker — og subtile punkter som hvorfor same-layer cleanup betyder noget og hvordan distroless forbedrer både størrelse og sikkerhed — afspejler den dybde, der kræves for at producere virkelig optimerede images.

Da image-størrelse og build-hastighed har reel, vedvarende indflydelse på deployment, omkostninger, sikkerhed og produktivitet, og da disse optimerings-teknikker (minimale/distroless bases, multi-stage builds, korrekt layer cleanup, BuildKit cache mounts) er det, der opnår magre, hurtige, sikre images, er forståelse af Docker-image og build-optimering værdifuld senior-level viden til produktions-containerization, en nøglekompetence, der skelner professionel, optimeret Docker-brug og afspejler den ekspertise, der forventes for at bygge effektive, sikre container-images i stor skala.