Docker image layers र build caching कसरी काम गर्छ?

Question

Accepted Answer

Docker images **layers** मा बनाइन्छन् — प्रत्येक Dockerfile instruction ले एक layer बनाउँछ, र Docker layers **cache** गरेर rebuilds लाई गति दिन्छ। Layers र caching बुझ्नु भनेको efficient Dockerfiles लेख्नको लागि महत्त्वपूर्ण हो जो छिटो build हुन्छन् र सानो images बनाउँछन्।

## Layers — प्रत्येक instruction ले एक layer थप्छ

```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.
```

## Caching rule (order महत्त्वपूर्ण छ)

```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.
```

## Classic optimization: dependencies code भन्दा पहिले

```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!)
```

Dependency files copy गरेर र **पहिले** install गरेर code को बाकी भाग copy गरेर, (ढिलो) dependency-install layer code changes भर cache मा रहन्छ — यो एक अत्यन्त महत्त्वपूर्ण optimization हो जसले rebuilds लाई छिटो बनाउँछ।

## Image size घटाउनु

```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)
```

## यो किन महत्त्वपूर्ण छ

Docker layers र build caching बुझ्नु **efficient Dockerfiles लेख्नको लागि** महत्त्वपूर्ण हो जो छिटो build हुन्छन् र सानो images बनाउँछन्, त्यसैले यो मूल्यवान व्यावहारिक ज्ञान हो जसले developer productivity र deployment लाई उल्लेखनीय रूपमा असर गर्छ।

आधारभूत अवधारणा — प्रत्येक Dockerfile instruction ले एक cached, reusable **layer** बनाउँछ, र Docker **unchanged cached layers लाई पुन: प्रयोग** गर्छ जबकि changed layers र तिनीहरु पछाडिका सबै कुरा rebuild गर्छ — यो व्याख्या गर्छ कि builds लाई कसरी छिटो बनाउने।

**Critical caching rule** (cache पहिलो changed instruction बाट तल invalidate हुन्छ, त्यसैले order महत्त्वपूर्ण छ: stable चीजहरु सुरुमा, frequently-changing चीजहरु पछि) drives गर्छ **एकल सबैभन्दा महत्त्वपूर्ण optimization**: dependency files copy गरेर र dependencies install गरेर **पहिले** application code copy गरेर, त्यसैले slow dependency-install layer frequent code changes भर cache मा रहन्छ (हरेक code change मा `npm install`/`pip install` फिर गरेर दिनु भन्दा पनि — यो छिटो र पीडादायक ढिलो rebuilds को बीचको अन्तर हो)।

यो pattern मात्र बुझ्नु build times लाई नाटकीय रूपमा सुधार गर्छ, यो एक constant developer-experience concern हो।

Image size **घटाउने** को लागि techniques बुझ्नु — RUN commands लाई एकै layer मा cleanup सँग combine गरेर, सानो base images (alpine, slim, distroless) प्रयोग गरेर, `.dockerignore` लाई unneeded files exclude गरेर, र multi-stage builds — सानो, faster-to-deploy images बनाउँछ (storage, transfer time, र attack surface घटाइ)।

Docker builds सधैँ हुन्छन् (development र CI/CD मा) र ढिलो builds वा bloated images ले productivity र deployment लाई हानि गर्छ, र layers र caching बुझ्नु भनेको fast र stay small हुने Dockerfiles लेख्न सक्षम बनाउँछ, र since understanding Docker layers र build caching — layer model, order-dependent caching rule, dependencies-before-code optimization, र size-reduction techniques — valuable, frequently-applied knowledge हो efficient Docker use को लागि, यो key skill हो जो fast, lean Dockerfiles लेख्नेहरुलाई distinguished गर्छ जो ढिलो builds र bloated images को पीडा भोग्नेहरु बाट।