DevOps with Docker

Docker has revolutionized how we deploy and manage applications. By containerizing your applications, you can ensure consistency across different environments and simplify deployment processes. This guide will walk you through Docker fundamentals and advanced practices.

Understanding Containers

What are Containers?

Containers are lightweight, portable units that package applications and their dependencies. Unlike virtual machines, containers share the host OS kernel, making them more efficient and faster to start.

Benefits of Containerization

• Consistency: Same environment across development, staging, and production
• Portability: Run anywhere Docker is supported
• Scalability: Easy to scale applications horizontally
• Isolation: Applications run in isolated environments
• Efficiency: Lower resource usage compared to VMs

Getting Started with Docker

Installation

Install Docker on your system:

# Ubuntu/Debian
sudo apt update
sudo apt install docker.io

# macOS (using Homebrew)
brew install docker

# Windows
# Download Docker Desktop from docker.com

Basic Docker Commands

# Pull an image
docker pull nginx

# Run a container
docker run -d -p 8080:80 nginx

# List running containers
docker ps

# List all containers
docker ps -a

# Stop a container
docker stop <container_id>

# Remove a container
docker rm <container_id>

Creating Docker Images

Writing Dockerfiles

Create a Dockerfile for your application:

# Use official Node.js runtime as base image
FROM node:18-alpine

# Set working directory
WORKDIR /app

# Copy package files
COPY package*.json ./

# Install dependencies
RUN npm ci --only=production

# Copy application code
COPY . .

# Expose port
EXPOSE 3000

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

# Change ownership
RUN chown -R nextjs:nodejs /app
USER nextjs

# Start application
CMD ["npm", "start"]

Multi-stage Builds

Optimize your images with multi-stage builds:

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

# Production stage
FROM node:18-alpine AS production
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY --from=builder /app/dist ./dist
EXPOSE 3000
CMD ["npm", "start"]

Docker Compose

Orchestrating Multiple Services

Use Docker Compose for multi-container applications:

version: "3.8"

services:
  web:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgresql://user:password@db:5432/mydb
    depends_on:
      - db
      - redis

  db:
    image: postgres:15
    environment:
      - POSTGRES_DB=mydb
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=password
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  postgres_data:

Running with Compose

# Start all services
docker-compose up -d

# View logs
docker-compose logs -f

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

# Stop services
docker-compose down

Best Practices

Security

Implement security best practices:

# Use specific versions
FROM node:18.15.0-alpine

# Run as non-root user
RUN addgroup -g 1001 -S nodejs
RUN adduser -S appuser -u 1001
USER appuser

# Use .dockerignore
# node_modules
# .git
# .env
# *.log

Optimization

Optimize your Docker images:

# Use Alpine Linux for smaller images
FROM node:18-alpine

# Combine RUN commands to reduce layers
RUN apk add --no-cache \
    python3 \
    make \
    g++ \
    && npm install \
    && apk del python3 make g++

# Use specific COPY instructions
COPY package*.json ./
RUN npm ci --only=production
COPY src/ ./src/

Production Deployment

Using Docker Swarm

Deploy with Docker Swarm for orchestration:

version: "3.8"

services:
  web:
    image: myapp:latest
    deploy:
      replicas: 3
      update_config:
        parallelism: 1
        delay: 10s
      restart_policy:
        condition: on-failure
    ports:
      - "80:3000"
    networks:
      - webnet

networks:
  webnet:

Health Checks

Implement health checks:

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

Monitoring and Logging

Container Logs

Manage container logs effectively:

# View logs
docker logs <container_id>

# Follow logs
docker logs -f <container_id>

# Limit log size
docker run --log-opt max-size=10m --log-opt max-file=3 myapp

Monitoring

Use monitoring tools:

# docker-compose.yml
services:
  prometheus:
    image: prom/prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml

  grafana:
    image: grafana/grafana
    ports:
      - "3001:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin

Conclusion

Docker provides a powerful platform for containerizing and deploying applications. By following these best practices, you can create efficient, secure, and scalable containerized applications.

Key takeaways:

• Use multi-stage builds for optimization
• Implement proper security practices
• Use Docker Compose for multi-service applications
• Monitor and log your containers
• Follow the principle of least privilege
• Keep your images small and efficient

With Docker, you can streamline your development workflow and ensure consistent deployments across all environments.