Docker

Description

Docker is an open-source platform that enables developers to automate the deployment, scaling, and management of applications by packaging them into lightweight, portable containers. These containers include everything an application needs to run — code, runtime, libraries, environment variables, and system tools — ensuring consistency across development, testing, and production environments.

Unlike traditional virtual machines (VMs), which require a full operating system per application, Docker uses OS-level virtualization, sharing the host kernel and isolating processes in a more efficient way. This makes Docker containers much faster to start and less resource-intensive.

How Docker Works

Docker uses a client-server architecture:

Docker Client: The command-line interface (docker) that communicates with the Docker daemon.
Docker Daemon (dockerd): The background service that builds, runs, and manages Docker containers.
Docker Images: Immutable snapshots that contain everything needed to run a container.
Docker Containers: Running instances of Docker images.
Docker Registry: A repository of Docker images, such as Docker Hub or private registries.

Basic Flow

Developer writes a Dockerfile.
Docker builds an image using the docker build command.
Image is stored locally or pushed to a registry.
Image is run using docker run, creating a container.

Dockerfile Example

# Use official Python image
FROM python:3.11-slim

# Set working directory
WORKDIR /app

# Copy files
COPY requirements.txt ./
RUN pip install -r requirements.txt
COPY . .

# Run the application
CMD ["python", "app.py"]

To build and run:

docker build -t my-python-app .
docker run -p 5000:5000 my-python-app

Key Concepts

Term	Description
Image	Read-only template used to create containers
Container	A lightweight, isolated instance of an image
Volume	A persistent data storage mechanism outside the container filesystem
Dockerfile	A text file with instructions to build a Docker image
Layer	Each command in a Dockerfile adds a layer; layers are cached
Docker Compose	Tool for defining and running multi-container applications

Docker vs Virtual Machines

Feature	Docker	Virtual Machine (VM)
Startup Time	Seconds	Minutes
Resource Usage	Lightweight	Heavy (requires full OS per VM)
Isolation	Process-level	Full system-level
Portability	High	Moderate
Performance	Near-native	Slower due to OS overhead

Docker Compose

Used to define and manage multi-container applications with a YAML configuration file (docker-compose.yml).

Example:

version: '3'
services:
  web:
    build: .
    ports:
      - "8000:8000"
  redis:
    image: redis

To run:

docker-compose up

Use Cases

Microservices Architecture
CI/CD Pipelines
Environment Standardization
Dev/Test Automation
Cloud Deployments
Legacy App Modernization

Volumes and Persistent Data

By default, container data is ephemeral. Volumes provide persistent storage.

docker volume create mydata
docker run -v mydata:/data mycontainer

Volumes are ideal for databases, logs, or user-generated content.

Networking in Docker

Docker creates a default bridge network, but you can define your own:

docker network create my_network
docker run --network my_network mycontainer

Each container can be referenced by its service name when using Docker Compose, which simplifies service discovery.

Docker Registry

Public:

Docker Hub

Private:

GitHub Container Registry
Amazon ECR
Google Artifact Registry

To pull from Docker Hub:

docker pull nginx

To push:

docker tag myimage username/myimage
docker push username/myimage

Security Considerations

Use trusted base images.
Run containers as non-root users.
Regularly scan images with tools like:
- Docker Scan
- Trivy
- Snyk
Apply least privilege principle.
Use AppArmor/SELinux profiles.

Best Practices

Keep images minimal (e.g., Alpine Linux).
Use .dockerignore to avoid copying unnecessary files.
Combine related RUN commands to reduce image layers.
Pin exact image versions for reproducibility.
Clean up temporary files in Dockerfile to reduce size.

Common Commands

docker build -t myapp .
docker run -d -p 80:80 myapp
docker ps -a
docker stop 
docker rm 
docker rmi 
docker exec -it  /bin/bash

Docker Swarm and Kubernetes

While Docker alone handles single-node container management, tools like:

Docker Swarm (native clustering for Docker)
Kubernetes (industry-standard container orchestration platform)

…allow for distributed, scalable, production-grade container deployments.

Troubleshooting

Issue	Solution
Image too large	Use minimal base images (e.g., `alpine`)
Container exits immediately	Check `docker logs`
Port not accessible	Ensure `-p` is set and firewall is open
Permission errors	Avoid running as root or adjust volumes
Network issues	Check container network configurations

Related Terms

Container
Virtual Machine
Microservices
Kubernetes
Infrastructure as Code (IaC)
CI/CD
Podman (alternative to Docker)
Image Registry
Container Orchestration

Summary

Docker has revolutionized the way software is built, shipped, and deployed. Its container-based model brings consistency across environments, faster development cycles, and efficient resource usage.

Whether you’re deploying a simple web app or architecting a complex microservice ecosystem, Docker provides the foundation for modern DevOps and cloud-native development.