Docker Commands Reference

Overview

Essential Docker commands for AzmX development, covering container lifecycle management, image operations, networking, volumes, and Docker Compose workflows. This reference focuses on practical commands used in development and deployment.

Container Lifecycle Management

Container Operations Flow

graph LR
    A[Docker Image] --> B[docker run]
    B --> C[Running Container]
    C --> D[docker stop]
    D --> E[Stopped Container]
    E --> F[docker start]
    F --> C
    E --> G[docker rm]
    G --> H[Container Removed]

    C --> I[docker exec]
    I --> J[Interactive Session]

    style A fill:#4ecdc4
    style C fill:#00b894
    style E fill:#fdcb6e
    style H fill:#ff6b6b

Running Containers

# Run container from image
docker run nginx

# Run container in background (detached)
docker run -d nginx

# Run with custom name
docker run --name web-server -d nginx

# Run with port mapping
docker run -p 8080:80 -d nginx

# Run with environment variables
docker run -e NODE_ENV=production -e PORT=3000 -d node-app

# Run with volume mount
docker run -v $(pwd):/app -d node-app

# Run with interactive terminal
docker run -it ubuntu bash

# Run with resource limits
docker run --memory=512m --cpus=1 -d nginx

# Run and remove after exit
docker run --rm ubuntu echo "Hello World"

Container Control

# List running containers
docker ps

# List all containers (including stopped)
docker ps -a

# Stop container
docker stop web-server
docker stop container-id

# Start stopped container
docker start web-server

# Restart container
docker restart web-server

# Pause container
docker pause web-server

# Unpause container
docker unpause web-server

# Kill container (force stop)
docker kill web-server

Container Interaction

# Execute command in running container
docker exec web-server ls /app

# Interactive shell in running container
docker exec -it web-server bash
docker exec -it web-server sh

# Execute as specific user
docker exec -u root -it web-server bash

# Run command as one-off
docker exec web-server nginx -s reload

# Attach to running container
docker attach web-server

# Copy files to/from container
docker cp local-file.txt web-server:/app/
docker cp web-server:/app/config.json local-config.json

Image Management

Image Operations Flow

graph TD
    A[Dockerfile] --> B[docker build]
    B --> C[Local Image]

    D[Registry] --> E[docker pull]
    E --> C

    C --> F[docker push]
    F --> D

    C --> G[docker run]
    G --> H[Container]

    C --> I[docker tag]
    I --> J[Tagged Image]

    style A fill:#74b9ff
    style C fill:#4ecdc4
    style D fill:#fdcb6e
    style H fill:#00b894

Building Images

# Build image from Dockerfile
docker build -t my-app .

# Build with custom Dockerfile
docker build -f Dockerfile.prod -t my-app:prod .

# Build with build arguments
docker build --build-arg NODE_VERSION=18 -t my-app .

# Build without cache
docker build --no-cache -t my-app .

# Build for specific platform
docker build --platform linux/amd64 -t my-app .

# Multi-stage build targeting specific stage
docker build --target production -t my-app:prod .

Image Information

# List local images
docker images
docker image ls

# Show image details
docker inspect my-app:latest

# Show image history
docker history my-app:latest

# Show image layers
docker image inspect my-app:latest | jq '.[0].RootFS.Layers'

# Check image size
docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.Size}}"

Image Operations

# Pull image from registry
docker pull nginx:latest
docker pull registry.digitalocean.com/azmx/my-app:v1.2.3

# Push image to registry
docker push my-app:latest
docker push registry.digitalocean.com/azmx/my-app:v1.2.3

# Tag image
docker tag my-app:latest my-app:v1.2.3
docker tag my-app:latest registry.digitalocean.com/azmx/my-app:v1.2.3

# Remove image
docker rmi my-app:latest
docker image rm my-app:latest

# Remove unused images
docker image prune

# Remove all images
docker image prune -a

Volume Management

Volume Operations

# Create named volume
docker volume create app-data

# List volumes
docker volume ls

# Inspect volume
docker volume inspect app-data

# Remove volume
docker volume rm app-data

# Remove unused volumes
docker volume prune

# Mount volume in container
docker run -v app-data:/data my-app

# Bind mount (host directory)
docker run -v $(pwd)/data:/app/data my-app
docker run -v /host/path:/container/path my-app

# Read-only mount
docker run -v $(pwd)/config:/app/config:ro my-app

Volume Types Comparison

graph TD
    A[Volume Types] --> B[Named Volumes]
    A --> C[Bind Mounts]
    A --> D[tmpfs Mounts]

    B --> E[Managed by Docker]
    B --> F[Persistent Storage]
    B --> G[Portable]

    C --> H[Host Directory]
    C --> I[Development]
    C --> J[Configuration]

    D --> K[Memory Storage]
    D --> L[Temporary Data]
    D --> M[No Persistence]

    style B fill:#4ecdc4
    style C fill:#74b9ff
    style D fill:#fdcb6e

Network Management

Network Operations

# List networks
docker network ls

# Create network
docker network create app-network

# Create network with specific driver
docker network create -d bridge app-network

# Inspect network
docker network inspect app-network

# Remove network
docker network rm app-network

# Remove unused networks
docker network prune

# Connect container to network
docker network connect app-network web-server

# Disconnect container from network
docker network disconnect app-network web-server

Container Networking

# Run container on specific network
docker run --network app-network -d nginx

# Run with custom hostname
docker run --hostname web-server --network app-network -d nginx

# Link containers (legacy, use networks instead)
docker run --link database:db -d app

# Expose ports
docker run -p 8080:80 -d nginx           # Host port 8080 -> Container port 80
docker run -p 127.0.0.1:8080:80 -d nginx # Bind to specific interface
docker run -P -d nginx                   # Publish all exposed ports

Docker Compose

Compose File Management

# Start services
docker-compose up

# Start in background
docker-compose up -d

# Start specific service
docker-compose up web

# Build and start
docker-compose up --build

# Force recreate containers
docker-compose up --force-recreate

# Scale services
docker-compose up --scale web=3

Service Management

# Stop services
docker-compose stop

# Stop specific service
docker-compose stop web

# Restart services
docker-compose restart

# Remove stopped containers
docker-compose rm

# Stop and remove containers, networks, volumes
docker-compose down

# Remove everything including volumes
docker-compose down -v

# Remove everything including images
docker-compose down --rmi all

Compose Operations

# View service logs
docker-compose logs
docker-compose logs web
docker-compose logs -f web  # Follow logs

# Execute command in service
docker-compose exec web bash
docker-compose exec db psql -U postgres

# Run one-off command
docker-compose run web npm test
docker-compose run --rm web bash

# View running services
docker-compose ps

# View service configuration
docker-compose config

# Validate compose file
docker-compose config --quiet

Multi-Environment Compose

# Use specific compose file
docker-compose -f docker-compose.yml -f docker-compose.prod.yml up

# Set environment
COMPOSE_FILE=docker-compose.yml:docker-compose.prod.yml docker-compose up

# Use .env file
echo "COMPOSE_FILE=docker-compose.yml:docker-compose.override.yml" > .env
docker-compose up

Development Workflows

Local Development Setup

# Development Dockerfile
cat << 'EOF' > Dockerfile.dev
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD ["npm", "run", "dev"]
EOF

# Development compose file
cat << 'EOF' > docker-compose.dev.yml
version: '3.8'
services:
  web:
    build:
      context: .
      dockerfile: Dockerfile.dev
    ports:
      - "3000:3000"
    volumes:
      - .:/app
      - /app/node_modules
    environment:
      - NODE_ENV=development
  db:
    image: postgres:14
    environment:
      - POSTGRES_DB=app_db
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=password
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"
volumes:
  postgres_data:
EOF

# Start development environment
docker-compose -f docker-compose.dev.yml up -d

Hot Reload Development

# Node.js with nodemon
docker run -v $(pwd):/app -w /app -p 3000:3000 node:18 npm run dev

# Python with Flask
docker run -v $(pwd):/app -w /app -p 5000:5000 -e FLASK_ENV=development python:3.9 flask run --host=0.0.0.0

# React development server
docker run -v $(pwd):/app -w /app -p 3000:3000 node:18 npm start

Production Deployment

Multi-stage Build Example

# Multi-stage Dockerfile
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

FROM node:18-alpine AS production
WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY . .
EXPOSE 3000
USER node
CMD ["node", "server.js"]

Production Compose

version: '3.8'
services:
  web:
    image: registry.digitalocean.com/azmx/app:${VERSION}
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - DATABASE_URL=${DATABASE_URL}
    ports:
      - "80:3000"
    depends_on:
      - redis
    deploy:
      replicas: 3
      resources:
        limits:
          memory: 512M
        reservations:
          memory: 256M

  redis:
    image: redis:7-alpine
    restart: unless-stopped
    volumes:
      - redis_data:/data

volumes:
  redis_data:

Monitoring and Debugging

Container Monitoring

# View container resource usage
docker stats

# View specific container stats
docker stats web-server

# View container processes
docker top web-server

# View container logs
docker logs web-server
docker logs -f web-server      # Follow logs
docker logs --tail 100 web-server  # Last 100 lines
docker logs --since 1h web-server  # Last hour

# View container events
docker events
docker events --filter container=web-server

Health Checks

# Add health check to Dockerfile
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD curl -f http://localhost:3000/health || exit 1

# Check container health
docker inspect --format='{{.State.Health.Status}}' web-server

# View health check logs
docker inspect --format='{{range .State.Health.Log}}{{.Output}}{{end}}' web-server

Performance Analysis

# Export container filesystem as tar
docker export web-server > container-backup.tar

# Create image from container
docker commit web-server my-app:snapshot

# Analyze image layers
docker history my-app:latest

# Check image vulnerabilities (if using Docker Scout)
docker scout cves my-app:latest

Registry Operations

Docker Hub

# Login to Docker Hub
docker login

# Tag for Docker Hub
docker tag my-app:latest username/my-app:latest

# Push to Docker Hub
docker push username/my-app:latest

# Pull from Docker Hub
docker pull username/my-app:latest

Private Registry

# Login to private registry
docker login registry.digitalocean.com

# Tag for private registry
docker tag my-app:latest registry.digitalocean.com/azmx/my-app:v1.2.3

# Push to private registry
docker push registry.digitalocean.com/azmx/my-app:v1.2.3

# Pull from private registry
docker pull registry.digitalocean.com/azmx/my-app:v1.2.3

System Maintenance

Cleanup Operations

# Remove stopped containers
docker container prune

# Remove unused images
docker image prune

# Remove unused volumes
docker volume prune

# Remove unused networks
docker network prune

# Remove all unused objects
docker system prune

# Remove everything (including volumes)
docker system prune -a --volumes

# Check disk usage
docker system df

# Detailed disk usage
docker system df -v

Resource Management

# Set memory limit
docker run --memory=512m my-app

# Set CPU limit
docker run --cpus=1.5 my-app

# Set CPU priority
docker run --cpu-shares=512 my-app

# Limit I/O
docker run --device-read-bps /dev/sda:1mb my-app

# Set restart policy
docker run --restart=unless-stopped my-app

Troubleshooting

Common Issues

Container Won't Start

# Check container logs
docker logs container-name

# Inspect container configuration
docker inspect container-name

# Run container interactively to debug
docker run -it --entrypoint sh image-name

Port Conflicts

# Check what's using a port
lsof -i :8080
netstat -tulpn | grep :8080

# Use different port mapping
docker run -p 8081:80 nginx

Volume Permission Issues

# Fix volume permissions
docker run --rm -v volume-name:/data alpine chown -R 1000:1000 /data

# Run as specific user
docker run --user $(id -u):$(id -g) -v $(pwd):/app my-app

Network Connectivity Issues

# Test network connectivity
docker run --rm alpine ping google.com

# Check container networking
docker exec container-name ip addr
docker exec container-name nslookup google.com

# Inspect network configuration
docker network inspect bridge

Performance Issues

# Monitor container resources
docker stats --no-stream

# Check container processes
docker exec container-name ps aux

# Analyze image size
docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.Size}}"

# Use multi-stage builds to reduce size
# Use alpine images for smaller footprint
# Remove package managers and caches in Dockerfile

Best Practices

Dockerfile Optimization

# Use multi-stage builds
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

FROM node:18-alpine
WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY . .
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nextjs -u 1001
USER nextjs
EXPOSE 3000
CMD ["node", "server.js"]

Security Best Practices

# Don't run as root
USER 1001

# Use specific image tags
FROM node:18.16.0-alpine

# Scan for vulnerabilities
docker scout cves my-app:latest

# Use distroless images when possible
FROM gcr.io/distroless/nodejs18-debian11

Kubernetes Commands (for container orchestration)
DigitalOcean Commands - Cloud deployment
Environment Setup - Local development setup

Last Updated: 2025-01-20 Tools Required: Docker, Docker Compose Team Contacts: DevOps Lead for production deployment, Tech Lead for development workflows