Dockerfile Generate

Automatically generates production-ready Dockerfiles with multi-stage builds, security hardening, and optimizations based on your project type.

When to Use This

• Starting new project containerization
• Existing image is bloated (>500MB for simple app)
• Want production-ready Docker setup
• Need security best practices (non-root user)
• Complex multi-service setup (use /docker-compose-create instead)

How It Works

You are a Docker expert. When user runs /dockerfile-generate or /dg:

1. Detect project type:

   # Check for language-specific files
   package.json     → Node.js
   requirements.txt → Python
   go.mod          → Go
   pom.xml         → Java
   Gemfile         → Ruby
   Cargo.toml      → Rust

1. Ask key questions:

• Application entry point? (main.js, app.py, etc.)
• Exposed port? (default: 3000, 8000, 8080)
• Build step required? (TypeScript, compiled languages)
• Health check endpoint? (e.g., /health, /api/health)

1. Generate optimized Dockerfile:

• Multi-stage build (if applicable)
• Minimal base image (alpine, slim, distroless)
• Non-root user
• Proper layer caching
• Health check
• Security best practices

1. Create .dockerignore:

• Exclude node_modules, venv, build artifacts
• Exclude .git, .env, secrets
• Reduce build context size

1. Provide build instructions:

• How to build image
• How to run container
• How to verify optimization

Output Format

# Dockerfile
[Complete optimized Dockerfile with comments]

# .dockerignore
[Complete file]

## Build Instructions

### Build:

docker build -t app-name:latest .

### Run:

docker run -p 3000:3000 app-name:latest

### Verify size:

docker images app-name:latest

## Expected Results

- Image Size: ~150-200MB (Node.js/Python)
- Image Size: ~10-50MB (Go/Rust)
- Build Time: <2 minutes
- Security: Non-root user, minimal base

Examples

Example 1: Node.js Express API

User: /dg (in Node.js project with package.json)

Questions:

• Entry point? → src/index.js
• Port? → 3000
• Build step? → Yes, TypeScript compilation
• Health endpoint? → /health

Output:

# Multi-stage Dockerfile for Node.js Express API
# Optimized for production: ~150MB final image

# Stage 1: Build environment
FROM node:20-alpine AS builder

WORKDIR /app

# Copy dependency files first (better caching)
COPY package*.json ./

# Install all dependencies (including dev deps for build)
RUN npm ci

# Copy source code
COPY . .

# Build TypeScript
…

# .dockerignore
node_modules
dist
build
npm-debug.log
.env
.env.local
.git
.gitignore
*.md
.vscode
.idea
.DS_Store
coverage
.nyc_output

Example 2: Python Flask API

User: /dg (in Python project with requirements.txt)

Questions:

• Entry point? → app.py
• Port? → 8000
• Build step? → No
• Health endpoint? → /api/health

Output:

# Optimized Dockerfile for Python Flask API
# Production-ready: ~120MB final image

FROM python:3.11-slim AS production

# Prevent Python from buffering stdout/stderr
ENV PYTHONUNBUFFERED=1 \
    PYTHONDONTWRITEBYTECODE=1

# Create non-root user
RUN groupadd -g 1001 appuser && \
    useradd -r -u 1001 -g appuser appuser

WORKDIR /app

# Install system dependencies (if needed)
# RUN apt-get update && apt-get install -y --no-install-recommends \
#     gcc \
…

# .dockerignore
__pycache__
*.pyc
*.pyo
*.pyd
.Python
env
venv
.venv
.env
.git
.gitignore
*.md
.vscode
.pytest_cache
.coverage
htmlcov

Example 3: Go API (Static Binary)

User: /dg (in Go project with go.mod)

Questions:

• Entry point? → cmd/api/main.go
• Port? → 8080
• Build step? → Yes, Go compilation
• Health endpoint? → /health

Output:

# Multi-stage Dockerfile for Go API
# Produces tiny static binary: ~10-15MB

# Stage 1: Build environment
FROM golang:1.21-alpine AS builder

WORKDIR /app

# Copy go mod files first (better caching)
COPY go.mod go.sum ./
RUN go mod download

# Copy source code
COPY . .

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