docker-patterns

IvanTorresEdge's avatarfrom IvanTorresEdge

Docker containerization best practices. Use when creating Dockerfiles.

⭐0stars🔀0forks📁View on GitHub🕐Updated Jan 1, 2026
[Cloud Infrastructure]

When & Why to Use This Skill

This Claude skill provides a comprehensive set of Docker containerization best practices and production-ready templates, specifically optimized for Go applications. It enables developers to build efficient, secure, and high-performance container images by implementing multi-stage builds, distroless configurations, and optimized layer caching.

Use Cases

  • Optimizing Image Size: Implementing multi-stage builds to separate the compilation environment from the runtime, resulting in significantly smaller and faster-to-deploy production images.
  • Enhancing Container Security: Utilizing distroless images and non-root user instructions to minimize the attack surface and ensure compliance with security best practices.
  • Accelerating CI/CD Pipelines: Leveraging optimized .dockerignore files and strategic layer caching (like pre-loading go.mod) to drastically reduce build times in automated pipelines.
  • Local Environment Orchestration: Quickly setting up standardized Docker Compose configurations for multi-service Go applications, including database integration and volume persistence.
  • Production Readiness: Adding robust health checks and static binary compilation (CGO_ENABLED=0) to ensure containers are stable and portable across different cloud environments.
namedocker-patterns
descriptionDocker containerization best practices. Use when creating Dockerfiles.

Docker Patterns Skill

Docker containerization best practices for Go.

When to Use

Use when creating or optimizing Docker images.

Multi-Stage Dockerfile

# Build stage
FROM golang:1.23-alpine AS builder

WORKDIR /app

# Copy go mod files
COPY go.mod go.sum ./
RUN go mod download

# Copy source
COPY . .

# Build static binary
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o main cmd/app/main.go

# Runtime stage
FROM alpine:latest

RUN apk --no-cache add ca-certificates

WORKDIR /root/

# Copy binary from builder
COPY --from=builder /app/main .

EXPOSE 8080

CMD ["./main"]

Distroless Image

# Build stage
FROM golang:1.23 AS builder
WORKDIR /app
COPY go.* ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -o main cmd/app/main.go

# Runtime stage
FROM gcr.io/distroless/static-debian11
COPY --from=builder /app/main /
CMD ["/main"]

Docker Compose

version: '3.8'

services:
  app:
    build: .
    ports:
      - "8080:8080"
    environment:
      - DB_HOST=db
      - DB_PORT=5432
    depends_on:
      - db

  db:
    image: postgres:15-alpine
    environment:
      - POSTGRES_PASSWORD=secret
    volumes:
      - db-data:/var/lib/postgresql/data

volumes:
  db-data:

.dockerignore

bin/
.git/
.gitignore
*.md
.env
.vscode/
.idea/
*.test
coverage.out

Best Practices

  1. Multi-stage builds - Small final images
  2. Static binaries - CGO_ENABLED=0
  3. Small base images - Alpine or distroless
  4. Layer caching - Copy go.mod before source
  5. Health checks - Add HEALTHCHECK instruction
  6. Non-root user - Run as non-root
  7. .dockerignore - Exclude unnecessary files
  8. Security - Scan with trivy

Health Check

HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD wget --no-verbose --tries=1 --spider http://localhost:8080/health || exit 1