Skip to main content

Docker

Docker is an open-source platform that automates the development, shipment, and deployment of applications in lightweight, portable containers.

Docker simplifies the process of packaging applications and their dependencies into a standardized unit known as a container, which runs consistently across multiple environments (development, testing, and production). This eliminates the common "it works on my machine" problem while increasing DevOps efficiency.

Docker is widely used to build microservices-based applications, accelerate CI/CD pipelines, and run isolated software environments.

Docker Architecture​

Docker uses a client-server architecture with the following components:

Docker Engine​

Docker Engine is the runtime that builds and containerizes applications. Docker Engine includes:

  • Docker Daemon (dockerd): It is a background service running on the host machine that manages Docker images, containers, networks, and volumes.
  • Docker CLI (docker): It is a command-line tool that allows users to interact with the Docker Daemon using REST APIs.
  • Docker API: It enables communication between the Docker CLI and the Docker Daemon. It is also compatible with third-party tools and GUIs.

Docker Objects​

  • Docker Image: It is a read-only template containing the application code, dependencies, and runtime. Images are the foundation of containers.
  • Docker Container: It is a runnable instance of a Docker image. Containers are isolated environments in which applications can run. Unlike VMs, containers don’t need a full guest OS. They share the host OS kernel, making them much more lightweight and faster to start.

Docker Key Concepts​

Images: Docker images represent layered snapshots of application environments. They are created with a Dockerfile, which is a script that contains instructions on how to build the image (such as which base image to use, which files to copy, and which commands to run). Images are hosted in repositories such as Docker Hub or private registries.

Containers: Containers are image-based runtime environments that are lightweight, portable, and isolated. They include the application and everything it requires to run, but share the host system's OS kernel, making them more efficient than virtual machines. The following Docker CLI commands allow you to start, stop, restart, and remove containers:

docker run <image>
docker stop <container>
docker rm <container>

Volumes: Docker volumes provide containers with persistent storage. Because container file systems are ephemeral, volumes enable data to persist beyond the life of a container:

docker volume create my_volume
docker run -v my_volume:/app/data my_image

Networks: Docker networking enables containers to communicate with one another and with external systems over networks. Docker includes several network drivers:

  • bridge (default)
  • host
  • overlay
  • macvlan

Custom networks enable containers to discover and communicate using DNS names.

Dockerfile: A Dockerfile specifies the steps involved in creating a Docker image. A typical Dockerfile looks like the following:

FROM node:18
WORKDIR /app
COPY . .
RUN npm install
CMD ["node", "server.js"]

This creates a reproducible, portable environment.

Docker Compose: Docker Compose is a tool for creating and managing multi-container applications. It uses a YAML file (docker-compose.yml) to configure services, networks, and volumes. Compose simplifies the local development and testing of complex applications.

version: "3"
services:
  web:
    build: .
    ports:
      - "5000:5000"
  redis:
    image: "redis:alpine"

You can start the entire stack with the following command:

docker-compose up

Benefits of Docker​

  • Consistency Across Environments: Uses the same container for development, staging, and production.
  • Simplified Configuration: Environment variables, volumes, and configuration files are easily manageable and reproducible.
  • CI/CD Integration: Docker seamlessly integrates with continuous integration and delivery tools, automating testing and deployment.
  • Efficiency: Containers require fewer resources than virtual machines because they share the OS kernel.
  • Rapid Deployment: Containers are quick to build and launch, allowing for rapid iteration and scaling.
  • Portability: Docker containers are compatible with any platform that supports Docker (Windows, macOS, Linux, cloud, and on-premise).
  • Isolation: Each container runs in its isolated environment, which helps to reduce application conflicts.
  • Scalability: Containers work well with orchestration tools like Kubernetes for auto-scaling.
  • Security: Container isolation adds a security layer between applications.