Docker Multi-Stage Build Generator

Generates optimized Dockerfiles using Docker's multi-stage build feature to create smaller, more secure production images by separating build-time and runtime dependencies.

What This Skill Does

This skill helps you create production-ready Dockerfiles that leverage multi-stage builds to:

Instructions

When the user requests a multi-stage Dockerfile or wants to optimize an existing Dockerfile, follow these steps:

1. Analyze Project Context

First, understand the project requirements:

2. Design Multi-Stage Strategy

Plan the build stages based on the project type:

**For compiled languages (Go, Rust, C++):**

**For interpreted languages (Node.js, Python):**

**For complex applications:**

3. Generate the Dockerfile

Create a multi-stage Dockerfile following these best practices:

**Stage naming:**

**Image selection:**

**Layer optimization:**

**Security:**

**Copy between stages:**

4. Add Build Instructions

Include clear comments in the Dockerfile explaining:

5. Provide Build Commands

Include example commands for:

6. Add .dockerignore

Generate or update `.dockerignore` to exclude unnecessary files:

```

node_modules

.git

.env

*.log

dist

coverage

.DS_Store

```

Examples

Example 1: Node.js Application

**User request:** "Create a multi-stage Dockerfile for my Express.js API"

**Response:**

```dockerfile

Stage 1: Dependencies

FROM node:20-alpine AS dependencies

WORKDIR /app

COPY package*.json ./

RUN npm ci --only=production

Stage 2: Build

FROM node:20-alpine AS builder

WORKDIR /app

COPY package*.json ./

RUN npm ci

COPY . .

RUN npm run build

Stage 3: Production

FROM node:20-alpine AS production

WORKDIR /app

ENV NODE_ENV=production

RUN addgroup -g 1001 -S nodejs && \

adduser -S nodejs -u 1001

COPY --from=dependencies --chown=nodejs:nodejs /app/node_modules ./node_modules

COPY --from=builder --chown=nodejs:nodejs /app/dist ./dist

COPY --chown=nodejs:nodejs package.json ./

USER nodejs

EXPOSE 3000

CMD ["node", "dist/index.js"]

```

**Build command:** `docker build -t express-api:latest .`

Example 2: Go Application

**User request:** "Optimize my Go application Dockerfile"

**Response:**

```dockerfile

Stage 1: Build

FROM golang:1.21-alpine AS builder

WORKDIR /app

COPY go.mod go.sum ./

RUN go mod download

COPY . .

RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o main .

Stage 2: Production

FROM alpine:3.19

RUN apk --no-cache add ca-certificates

WORKDIR /root/

COPY --from=builder /app/main .

EXPOSE 8080

CMD ["./main"]

```

**Size comparison:** Builder stage ~500MB, final image ~15MB

Example 3: Python with Testing

**User request:** "Create a Dockerfile that runs tests in a separate stage"

**Response:**

```dockerfile

Stage 1: Base dependencies

FROM python:3.11-slim AS base

WORKDIR /app

COPY requirements.txt .

RUN pip install --no-cache-dir -r requirements.txt

Stage 2: Test

FROM base AS test

COPY requirements-dev.txt .

RUN pip install --no-cache-dir -r requirements-dev.txt

COPY . .

RUN pytest tests/

Stage 3: Production

FROM python:3.11-slim AS production

WORKDIR /app

RUN useradd -m -u 1000 appuser

COPY --from=base /usr/local/lib/python3.11/site-packages /usr/local/lib/python3.11/site-packages

COPY --from=base /usr/local/bin /usr/local/bin

COPY --chown=appuser:appuser . .

USER appuser

CMD ["python", "app.py"]

```

**Build production:** `docker build --target production -t app:prod .`

**Run tests:** `docker build --target test -t app:test .`

Constraints

Advanced Patterns

When appropriate, suggest: