Vad är build-kontexten och varför använda en .dockerignore-fil?

Question

Accepted Answer

När du kör `docker build` skickar Docker **build-kontexten** (filerna i build-mappen) till daemonen. En **.dockerignore**-fil utesluter onödiga filer från denna kontext — vilket snabbar upp byggen, minskar bildstorlek och förhindrar läckage av känsliga filer.

## Build-kontexten

```bash
docker build -t myapp .     # the "." is the build context — the directory sent to the daemon
# → Docker tarballs the ENTIRE context directory and sends it to the daemon BEFORE building
# → a big context (node_modules, .git, large files) = slow builds, more data transferred
```

**Build-kontexten** är uppsättningen filer som Docker skickar till daemonen för att bygga bilden. Allt i build-mappen inkluderas om det inte är uteslutet — så en överlastad kontext gör varje bygge långsammare.

## .dockerignore — uteslut onödiga filer

```text
# .dockerignore (like .gitignore, for the build context)
node_modules        # don't send local deps (they're installed in the image anyway)
.git                # don't send version history
*.log
.env                # ⚠️ don't send SECRETS into the build context/image
Dockerfile
dist
.vscode
```

`.dockerignore` fungerar som `.gitignore` och utesluter filer från build-kontexten.

## Varför det spelar roll (tre fördelar)

```text
✓ FASTER builds — a smaller context transfers faster; fewer files to process
  (also helps caching: COPY . . won't be invalidated by irrelevant file changes)
✓ SMALLER images — excluded files (node_modules, .git) don't get COPYed into the image
✓ SECURITY — keep SECRETS (.env, keys, credentials) out of the context AND the image
  (a COPY . . could otherwise copy a .env file into the image — a real leak risk)
```

## Varför det spelar roll

Att förstå build-kontexten och `.dockerignore` är värdefullt för **effektiva och säkra Docker-byggen**, så det är praktisk kuskap.

Många utvecklare inser inte att `docker build .` skickar **hela build-kontextkatalogen till daemonen** innan bygget startar — så en överlastad kontext (innehållande `node_modules`, `.git`, build-artefakter, stora filer) gör **varje bygge långsammare** (mer data att överföra och bearbeta) och riskerar att kopiera oönskade filer in i bilden.

**`.dockerignore`**-filen (som fungerar som `.gitignore`) löser detta med tre konkreta fördelar: **snabbare byggen** (en mindre kontext överför och bearbetar snabbare, och förbättrar också layer-caching eftersom `COPY . .` inte blir ogiltig av ändringar i irrelevanta filer), **mindre bilder** (uteslutna filer kopieras inte in — t.ex. inte bundling av lokal `node_modules` som installeras om ändå), och kritiskt **säkerhet** (håller **hemligheter som `.env`-filer, nycklar och autentiseringsuppgifter borta från build-kontexten och bilden** — eftersom en `COPY . .` annars skulle kopiera en `.env` in i bilden, en verklig och vanlig risk för läckage av autentiseringsuppgifter).

Denna säkerhetsfördel är särskilt viktig, eftersom att misstag baka in hemligheter eller känsliga filer i bilder via en alltför bred copy är ett verkligt misstag som `.dockerignore` hjälper till att förhindra.

Since byggen sker ständigt och byggeeffektivitet, bildstorlek och att undvika läckage av hemligheter är viktigt, och eftersom att förstå build-kontexten och använda `.dockerignore` direkt förbättrar alla tre, är förståelse för build-kontexten och `.dockerignore` värdefullt, praktiskt relevant Docker-kunskap — en enkel men viktig praxis för snabba, smala och säkra byggen som är lätt att förbise men meningsfullt påverkande, särskilt för att förhindra oavsiktlig inkludering av hemligheter i bilder.