What are the differences between Docker and Kubernetes?

Docker is a platform for containerization that allows packaging applications and their dependencies into isolated units (containers). Kubernetes is a container orchestrator designed to automate deployment, scaling, and management of containerized applications.

Docker:

• Focused on creating and running individual containers.
• Provides tools for building images (Dockerfile), managing images, and running container instances.
• For orchestrating multiple containers in Docker, Docker Compose (for local development) or the outdated Docker Swarm is used.

Kubernetes (K8s):

• Designed to manage a large number of containers in a cluster.
• Provides high-level abstractions such as Pods, Services, Deployments.
• Automates tasks like:
  • Deploying new versions of applications.
  • Scaling applications based on load.
  • Recovering from container failures.
  • Load balancing between replicas.
  • Self-diagnosis and restarting faulty containers.
• Can work with any container runtime compatible with Container Runtime Interface (CRI), including Docker.

Main differences summarized in the table:

Characteristic	Docker	Kubernetes
Purpose	Containerization, creating and running	Orchestration, managing container clusters
Level of abstraction	Individual container	Pod, Deployment, Service, Cluster
Scaling	Manual or with additional tools	Automatic, at the cluster level
High availability	Manual or with additional tools	Built-in, automatic recovery
Load balancing	Manual or with additional tools	Automatic, at the Service level
Applicability	Local development, small applications	Industrial scale, complex systems

Example:

Suppose we have a microservices application consisting of a web server, a database, and a message queue.

• Docker allows packaging each component into its container, defining dependencies in Docker Compose (for local run), and running them together.

  // docker-compose.yml
  version: '3.8'
  services:
    web:
      image: my-web-app
      ports:
        - "80:80"
    db:
      image: postgres
      environment:
        POSTGRES_DB: mydatabase
        POSTGRES_USER: user
        POSTGRES_PASSWORD: password
  # ... other services
  

• Kubernetes allows describing the desired state of the entire application: how many replicas of each service should run, how they should interact, how data should be stored. Kubernetes will ensure this state is maintained, automatically restarting failed containers or scaling their number as needed.

  // deployment.yaml
  apiVersion: apps/v1
  kind: Deployment
  metadata:
    name: web-deployment
  spec:
    replicas: 3 # Run 3 replicas of the web server
    selector:
      matchLabels:
        app: web
    template:
      metadata:
        labels:
          app: web
      spec:
        containers:
        - name: web-container
          image: my-web-app
          ports:
          - containerPort: 80
  

Thus, Docker is a tool for creating building blocks (containers), and Kubernetes is a tool for managing a complex building made from these blocks. In real production environments, they are often used together. Docker creates containers, and Kubernetes orchestrates them.