Docker and Kubernetes

Introduction: The Container Revolution

Containerization has fundamentally transformed how applications are built, deployed, and managed in modern software development. Docker brought containers to the mainstream, and Kubernetes emerged as the orchestration standard for managing these containers at scale. Together, they form the foundation of modern cloud-native application deployment, enabling organizations to achieve unprecedented levels of agility, consistency, and efficiency.

In 2026, containerization skills have become essential for software engineers, DevOps professionals, and cloud architects. Whether you are deploying microservices, implementing CI/CD pipelines, or building cloud-native applications, understanding Docker and Kubernetes provides the foundation for modern application deployment. This comprehensive tutorial covers everything from container basics to production-grade cluster management.

The shift from monolithic applications to containerized microservices has created new architectural patterns and operational practices. Organizations embracing containerization report significant improvements in deployment frequency, lead time for changes, and mean time to recovery. Mastering these technologies opens doors to some of the most in-demand roles in the technology industry.

Understanding Docker: Container Fundamentals

Docker packages applications along with their dependencies into standardized units called containers. Unlike virtual machines, containers share the host operating system kernel, making them lightweight and fast while maintaining isolation from other processes.

Essential Docker Commands

Creating Docker Images: Dockerfile Deep Dive

A Dockerfile is a text document containing instructions for building a Docker image. Each instruction creates a layer in the image, and the final image consists of all these layers stacked together.

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

# Set working directory
WORKDIR /app

# Copy package files first for better caching
COPY package*.json ./

# Install dependencies
RUN npm ci --only=production

# Copy application code
COPY . .

# Expose application port
EXPOSE 3000

# Environment variables
ENV NODE_ENV=production

# Health check
HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost:3000/health || exit 1

# Start the application
CMD ["node", "server.js"]

Key Dockerfile Instructions

Docker Compose: Multi-Container Applications

Docker Compose defines and runs multi-container applications. With a single YAML file, you can define services, networks, volumes, and their configurations, then spin up the entire stack with one command.

version: '3.8'

services:
  web:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DB_HOST=postgres
    depends_on:
      - postgres
      - redis
    restart: unless-stopped

  postgres:
    image: postgres:15-alpine
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      - POSTGRES_DB=myapp
      - POSTGRES_USER=admin
      - POSTGRES_PASSWORD=${DB_PASSWORD}
    restart: unless-stopped

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

volumes:
  postgres_data:
  redis_data:

Common Docker Compose Commands

Kubernetes: Container Orchestration at Scale

Kubernetes (K8s) is an open-source container orchestration platform that automates deployment, scaling, and management of containerized applications. Originally developed by Google and now maintained by the Cloud Native Computing Foundation, Kubernetes has become the industry standard for production container management.

Core Kubernetes Objects

Kubernetes Deployment Examples

Understanding Kubernetes through practical examples accelerates learning. Here are common deployment patterns with corresponding YAML configurations.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
  labels:
    app: web-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
    spec:
      containers:
      - name: web-app
        image: myapp:v1
        ports:
        - containerPort: 3000
        resources:
          requests:
            memory: "128Mi"
            cpu: "250m"
          limits:
            memory: "256Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 10
          periodSeconds: 5
        readinessProbe:
          httpGet:
            path: /ready
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 3

apiVersion: v1
kind: Service
metadata:
  name: web-app-service
spec:
  type: LoadBalancer
  selector:
    app: web-app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 3000
  - protocol: TCP
    port: 443
    targetPort: 3000

Essential kubectl Commands

Helm: Kubernetes Package Manager

Helm simplifies Kubernetes deployments by packaging resources into charts. Charts are reusable, versioned configurations that can be shared through repositories. Helm brings templating, versioning, and dependency management to Kubernetes manifests.

Frequently Asked Questions

Related Resources