Docker - Layer Caching

Layer Caching in Docker means Docker reuses previously built image layers instead of rebuilding everything from scratch.

In AWS + .NET context, this is very important for CI/CD speed, cost, and developer productivity.

“Docker layer caching improves AWS CI/CD performance by reusing unchanged build steps. In .NET, copying the .csproj and running dotnet restore before copying source code prevents unnecessary dependency restores, reducing build time, ECR push size, and deployment latency.”

---

First Understand Docker Layers

Every Dockerfile instruction creates a layer:

FROM ...
WORKDIR ...
COPY ...
RUN ...

Docker stores each layer as a snapshot.

If nothing changes in that step → Docker reuses the cached layer.

---

Why It Matters on AWS

Layer caching helps in:

AWS Service	Benefit
CodeBuild	Faster builds
ECR	Smaller push size
ECS/EKS	Faster deployments
Lambda Containers	Reduced cold start
CI/CD Pipelines	Minutes saved per build

---

Example Without Layer Optimization (.NET)

FROM mcr.microsoft.com/dotnet/sdk:8.0
WORKDIR /app
COPY . .
RUN dotnet restore
RUN dotnet publish -c Release -o out

Problem:

• Any small code change invalidates COPY . .
• Docker reruns restore + publish
• Slow builds (2–5 minutes)

---

Optimized Version Using Layer Caching

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /app

# Copy only project files first
COPY *.csproj .
RUN dotnet restore

# Then copy rest of source
COPY . .
RUN dotnet publish -c Release -o out

Why This Works

• .csproj changes rarely
• Source code changes frequently

Docker cache logic:

Step	Changes Often?	Cache Used?
COPY *.csproj	Rare	Yes
RUN dotnet restore	Rare	Yes
COPY . .	Often	No
RUN publish	Often	No

So NuGet restore is skipped most builds, saving time.

---

AWS CI/CD Impact Example

Without caching:

• Build time = 6 minutes
• Every commit full rebuild

With caching:

• Build time = 1.5–2 minutes
• Only changed layers rebuilt

In CodeBuild or GitHub Actions, this saves hours per week.

---

ECR Push Optimization

Docker only pushes changed layers.

If only app code changed:

• Push size maybe 20–30 MB
• Instead of 300–500 MB

Less network → faster deploy → lower cost.

---

Real-World Analogy

Think of it like Excel recalculation:

• Change one cell → not entire sheet recalculated
• Docker only rebuilds changed steps

---

Best Practices for Layer Caching (.NET + AWS)

1. Order Matters

Stable steps first, changing steps later.

2. Separate Restore

COPY *.csproj .
RUN dotnet restore

3. Use .dockerignore

Exclude:

• bin/
• obj/
• .git/
• logs/

Reduces invalid cache triggers.

4. Multi-Stage Build

Keeps final image small and cache efficient.