🐳 Dockerfile & Image Building

# Official image
FROM python:3.11-slim

# Specific version
FROM node:18.16.0-alpine

# Multi-stage build
FROM golang:1.20 AS builder

# Platform-specific
FROM --platform=linux/amd64 ubuntu:22.04

# ARG before FROM
ARG VERSION=3.11
FROM python:${VERSION}-slim

# COPY - simple and predictable
COPY package.json /app/
COPY . /app

# COPY with wildcard
COPY *.py /app/

# COPY with ownership
COPY --chown=user:group app.py /app/
```html
# Documentation: Docker COPY Documentation
# Debugging_help: Kaniko Issue #1524
```

# ADD - auto-extract tar
ADD archive.tar.gz /app/

# ADD - multiple sources
ADD file1.txt file2.txt /app/

# Sets working directory for RUN, CMD, ENTRYPOINT, COPY, ADD
WORKDIR /app

# Creates directory if it doesn't exist
WORKDIR /var/www/html

# Can use environment variables
ENV APP_HOME=/app
WORKDIR ${APP_HOME}

# Single variable
ENV NODE_ENV=production

# Multiple variables (space-separated)
ENV PORT=8080 HOST=0.0.0.0

# Multiple variables (one per line)
ENV API_KEY=abc123 \
    DATABASE_URL=postgres://localhost \
    DEBUG=false

# TCP port (default)
EXPOSE 8080

# UDP port
EXPOSE 53/udp

# Multiple ports
EXPOSE 80 443

# With protocol
EXPOSE 8080/tcp 8081/tcp

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

# Switch to non-root user
USER appuser

# All subsequent instructions run as this user
WORKDIR /home/appuser
COPY --chown=appuser:appuser . .

# Can switch back to root if needed
USER root
RUN apt-get install -y package
USER appuser

# 1. Exec form (preferred)
CMD ["python", "app.py"]

# 2. Shell form
CMD python app.py

# 3. As default parameters to ENTRYPOINT
ENTRYPOINT ["python"]
CMD ["app.py"]

# 1. Exec form (preferred)
ENTRYPOINT ["python", "app.py"]

# 2. Shell form (wraps in /bin/sh -c)
ENTRYPOINT python app.py

FROM python:3.11-slim
WORKDIR /app
COPY app.py .

# ENTRYPOINT is the executable
ENTRYPOINT ["python", "app.py"]

# CMD provides default arguments
CMD ["--host", "0.0.0.0", "--port", "8080"]

# Basic build (looks for Dockerfile in current directory)
docker build .

# Build with tag
docker build -t myapp:1.0 .

# Build with multiple tags
docker build -t myapp:1.0 -t myapp:latest .

# Specify Dockerfile name
docker build -f Dockerfile.dev -t myapp:dev .

# Specify build context
docker build -t myapp:1.0 /path/to/context

# Build with build arguments
docker build --build-arg VERSION=1.0 -t myapp:1.0 .

# Version control
.git
.gitignore
.gitattributes

# Dependencies (will be installed in image)
node_modules
venv
__pycache__

# IDE
.vscode
.idea
*.swp

# Documentation
README.md
docs/

# Testing
tests/
*.test.js
coverage/

# CI/CD
.github
.gitlab-ci.yml
Jenkinsfile

# Local environment
.env.local
docker-compose.yml

# Build artifacts
dist/
build/
*.log

# Stage 1: Build stage
FROM node:18 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Stage 2: Production stage
FROM node:18-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
EXPOSE 3000
CMD ["node", "dist/server.js"]

# Result: Only production dependencies and built code in final image

# ❌ BAD: Copy everything, then install (cache invalidated often)
COPY . /app
RUN npm install

# ✅ GOOD: Copy dependencies first, then source (better caching)
COPY package*.json /app/
RUN npm install
COPY . /app

# Why? package.json changes rarely vs source code changes frequently

# View image layers and sizes
docker history myapp:latest

# Detailed JSON output
docker image inspect myapp:latest

# See layer cache IDs
docker build --progress=plain .

# Export and examine
docker save myapp:latest -o myapp.tar
tar -xvf myapp.tar

# syntax=docker/dockerfile:1
FROM python:3.11-slim

# Cache pip packages across builds
RUN --mount=type=cache,target=/root/.cache/pip \
    pip install -r requirements.txt

# Cache apt packages
RUN --mount=type=cache,target=/var/cache/apt \
    --mount=type=cache,target=/var/lib/apt \
    apt-get update && apt-get install -y git

# Build with BuildKit
DOCKER_BUILDKIT=1 docker build -t myapp .

# syntax=docker/dockerfile:1

# Build stage
FROM node:18-alpine AS builder

# Install build dependencies
RUN apk add --no-cache python3 make g++

WORKDIR /app

# Install dependencies (cached layer)
COPY package*.json ./
RUN --mount=type=cache,target=/root/.npm \
    npm ci --only=production

# Build application
COPY . .
RUN npm run build

# Production stage
FROM node:18-alpine

# Install dumb-init for proper signal handling
RUN apk add --no-cache dumb-init

# Create non-root user
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nodejs -u 1001

WORKDIR /app

# Copy built application from builder
COPY --from=builder --chown=nodejs:nodejs /app/dist ./dist
COPY --from=builder --chown=nodejs:nodejs /app/node_modules ./node_modules
COPY --from=builder --chown=nodejs:nodejs /app/package.json ./

# Switch to non-root user
USER nodejs

# Expose port
EXPOSE 3000

# Add health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s \
  CMD node healthcheck.js || exit 1

# Add metadata
LABEL maintainer="devops@company.com" \
      version="1.0.0" \
      description="Production Node.js API"

# Use dumb-init to handle signals properly
ENTRYPOINT ["dumb-init", "--"]
CMD ["node", "dist/server.js"]