Docker Comprehensive Cheatsheet

1. Installation and Setup

Linux (Ubuntu/Debian)

Bash

1
2
3
4
5
6
7
8
9
10
11
# Install Docker Engine
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io

# Install using convenience script
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Add user to docker group (avoid sudo for docker commands)
sudo usermod -aG docker $USER

macOS

Download Docker Desktop from official website
Install using DMG or Homebrew:

Bash

1
2
brew install --cask docker

Windows

Download Docker Desktop from official website
Ensure WSL 2 is installed for best performance
Enable Hyper-V and Windows Containers

2. Basic Docker Concepts

Core Terminology

Image: Read-only template for creating containers
Container: Runnable instance of an image
Registry: Repository for storing and sharing images
Dockerfile: Script for building Docker images

3. Dockerfile Syntax and Best Practices

Basic Dockerfile Structure

Dockerfile

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# Use an official base image
FROM ubuntu:20.04

# Set metadata
LABEL maintainer="your.email@example.com"

# Set working directory
WORKDIR /app

# Copy application files
COPY . /app

# Install dependencies
RUN apt-get update && \
    apt-get install -y python3 python3-pip && \
    pip3 install -r requirements.txt

# Set environment variables
ENV APP_ENV=production

# Expose ports
EXPOSE 8080

# Define default command
CMD ["python3", "app.py"]

Best Practices

Use specific image tags
Minimize layer count
Use .dockerignore
Don't run as root
Keep images small
Use multi-stage builds

4. Image Management

Bash

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# Pull an image
docker pull ubuntu:20.04

# Build an image
docker build -t myapp:v1 .

# List local images
docker images

# Tag an image
docker tag myapp:v1 username/myapp:v1

# Push to Docker Hub
docker push username/myapp:v1

# Remove an image
docker rmi myapp:v1

5. Container Lifecycle Management

Bash

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# Run a container
docker run -d --name mycontainer ubuntu:20.04

# List running containers
docker ps

# List all containers
docker ps -a

# Start a stopped container
docker start mycontainer

# Stop a running container
docker stop mycontainer

# Restart a container
docker restart mycontainer

# Remove a container
docker rm mycontainer

# Remove all stopped containers
docker container prune

6. Volume Management

Bash

1
2
3
4
5
6
7
8
9
10
11
12
# Create a volume
docker volume create myvolume

# List volumes
docker volume ls

# Mount volume during container run
docker run -v myvolume:/app/data myimage

# Remove unused volumes
docker volume prune

7. Network Configuration

Bash

1
2
3
4
5
6
7
8
9
10
11
12
# Create a network
docker network create mynetwork

# List networks
docker network ls

# Connect container to network
docker network connect mynetwork mycontainer

# Inspect network
docker network inspect mynetwork

8. Environment Variables

Bash

1
2
3
4
5
6
# Pass environment variables
docker run -e DB_HOST=localhost -e DB_PORT=5432 myimage

# Use env file
docker run --env-file ./env.list myimage

9. Port Mapping

Bash

1
2
3
4
5
6
# Map container port to host
docker run -p 8080:80 myimage

# Map to specific host interface
docker run -p 127.0.0.1:8080:80 myimage

10. Multi-Stage Builds

Dockerfile

1
2
3
4
5
6
7
8
9
10
11
12
# Build stage
FROM maven:3.8.1-openjdk-11 AS build
WORKDIR /app
COPY pom.xml .
COPY src ./src
RUN mvn package

# Final stage
FROM openjdk:11-slim
COPY --from=build /app/target/myapp.jar /app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]

11. Docker Compose

YAML

1
2
3
4
5
6
7
8
9
version: '3.8'
services:
  web:
    build: .
    ports:
      - "5000:5000"
  redis:
    image: redis:alpine

Bash

1
2
3
4
5
6
# Start services
docker-compose up -d

# Stop services
docker-compose down

12. Logging and Debugging

Bash

1
2
3
4
5
6
7
8
9
# View container logs
docker logs mycontainer

# Follow log output
docker logs -f mycontainer

# Inspect container details
docker inspect mycontainer

13. Resource Limits

Bash

1
2
3
# Run container with CPU and memory limits
docker run --cpus=1.5 --memory=512m myimage

14. Security Best Practices

Use official images
Scan images for vulnerabilities
Don't run containers as root
Use read-only file systems
Limit container capabilities

Bash

1
2
3
# Scan image for vulnerabilities
docker scan myimage

15. Registry Operations

Bash

1
2
3
4
5
6
7
8
9
# Login to Docker Hub
docker login

# Pull from private registry
docker pull myregistry.azurecr.io/myimage:tag

# Push to private registry
docker push myregistry.azurecr.io/myimage:tag

16. Backup and Migration

Bash

1
2
3
4
5
6
7
8
9
# Export container as image
docker commit mycontainer mybackup:latest

# Save image to tar
docker save -o myimage.tar myimage

# Load image from tar
docker load -i myimage.tar

17. Performance Optimization

Use Alpine-based images
Leverage build cache
Remove unnecessary packages
Use multi-stage builds
Minimize image layers

18. CI/CD Integration

Example GitHub Actions workflow:

YAML

1
2
3
4
5
6
7
8
9
10
name: Docker Build
on: [push]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Build Docker Image
      run: docker build -t myapp .

19. Troubleshooting

Bash

1
2
3
4
5
6
7
8
9
# Check Docker system info
docker info

# Prune unused resources
docker system prune -a

# Verify Docker installation
docker run hello-world

20. Production Deployment Considerations

Use orchestration (Kubernetes)
Implement health checks
Use secrets management
Set up monitoring
Configure proper logging
Implement rolling updates

Additional Resources

Docker Documentation: https://docs.docker.com
Best Practices: https://docs.docker.com/develop/develop-images/best-practices/

Docker

Continue Learning