Docker Fundamentals

Docker fundamentals are essential for understanding containerization, DevOps practices, and modern microservices architecture. Docker enables developers to package applications along with all dependencies into portable containers, ensuring consistent behavior across development, testing, staging, and production environments.

What Is Docker?

Docker is a containerization platform that allows you to build, ship, and run applications inside lightweight, isolated containers.

Containers:

• Share the host operating system kernel
• Start in seconds
• Consume fewer resources than virtual machines
• Provide process-level isolation

This makes Docker ideal for cloud-native applications and microservices deployments.

Docker simplifies:

• Application packaging
• Environment consistency
• CI/CD automation
• Microservices deployment and scaling

Core Docker Concepts

Understanding these core components is essential to mastering Docker.

1. Docker Engine

Docker Engine is the core runtime responsible for building and running containers.

It consists of:

• Docker Daemon (dockerd) – Background service that manages containers
• REST API – Interface for interacting with the daemon
• Docker CLI – Command-line tool used to run Docker commands

The Docker CLI communicates with the Docker Daemon using the REST API.

2. Docker Image

A Docker image is a read-only template used to create containers.

It contains:

• Application code
• Runtime (Java, Python, Node, etc.)
• Libraries
• Dependencies
• Configuration

Images are:

• Immutable
• Versioned
• Layer-based (each instruction creates a new layer)

Example:

docker pull openjdk:21

This command downloads the openjdk:21 image from a Docker registry.

3. Docker Container

A Docker container is a running instance of a Docker image.

Example:

docker run -p 8080:8080 my-app

This command:

• Runs the my-app image
• Maps port 8080 of the container to port 8080 of the host

Containers are:

• Lightweight
• Fast to start
• Isolated
• Portable across environments

Once stopped, containers can be restarted or removed without affecting the base image.

4. Dockerfile

A Dockerfile is a text file that defines instructions for building a Docker image.

Example:

FROM openjdk:21
WORKDIR /app
COPY target/app.jar app.jar
ENTRYPOINT ["java","-jar","app.jar"]

Explanation:

• FROM – Specifies the base image
• WORKDIR – Sets the working directory inside the container
• COPY – Copies files into the container
• RUN – Executes commands during image build
• ENTRYPOINT / CMD – Defines how the container starts

A Dockerfile ensures reproducible and consistent image builds.

Difference Between Images vs Containers

Running Containers with Custom Ports

You can map a custom host port to the container’s internal application port using the -p option.

docker run -p 9090:8080 springboot-app

Here:

• 9090 → Host machine port
• 8080 → Container internal port (where Spring Boot runs)

Access application at:

<http://localhost:9090>

This is useful when:

• Multiple containers run on the same machine
• Port 8080 is already in use
• You want different services exposed on different host ports

Inspecting & Debugging Containers

Docker provides powerful commands to monitor, inspect, and debug running containers.

View Running Containers

Displays active containers, ports, container IDs, and status.

docker ps

View Container Logs

Shows application logs printed to STDOUT/STDERR.

Helpful for debugging crashes, startup failures, or runtime errors.

docker logs container_id

Access Container Shell

Opens an interactive shell inside the container.

Useful for checking files, configurations, environment variables, or installed packages.

docker exec -it container_id /bin/bash

Inspect Container Details

Returns detailed JSON information including:

• Network settings
• Mounted volumes
• Environment variables
• IP address

docker inspect container_id

View Resource Usage

Displays real-time CPU, memory, and network usage for running containers.

docker stats

Docker Compose (Multi-Container Setup)

Docker Compose allows you to define and run multiple containers using a single YAML configuration file (docker-compose.yml).It is especially useful when your application depends on other services like databases, caches, or message brokers.

Example docker-compose.yml

version: '3'

services:
  app:
    image: springboot-app
    ports:
      - "8080:8080"
    depends_on:
      - db

  db:
    image: postgres
    environment:
      POSTGRES_DB: mydb
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    ports:
      - "5432:5432"

Run All Services

docker-compose up

This command:

• Builds (if needed) and starts all defined services
• Creates a default network
• Enables containers to communicate using service names (app, db)

To run in detached mode:

docker-compose up -d

Useful For

• Microservices development
• Local integration testing
• Running API + Database together
• Simulating production-like environments locally

Why Docker Is Important for Microservices

Docker plays a critical role in modern microservices architecture by providing isolation, portability, and scalability.

Docker enables:

• Independent service deployment
• Technology flexibility (each service can use different stacks like Java, Node.js, Python, etc.)
• Environment consistency across dev, test, and production
• Easy horizontal scaling
• Faster CI/CD pipelines

Each microservice runs in its own container, reducing conflicts and improving isolation in distributed systems.

Best Practices for Docker

• Use lightweight base images (e.g., Alpine-based images) to reduce size
• Use multi-stage builds to keep final images clean
• Avoid running containers as root for security
• Minimize image size by removing unnecessary files
• Use .dockerignore to exclude unwanted files
• Tag images properly (e.g., v1.0.0, not just latest)
• Scan images for vulnerabilities using security tools
• Keep containers stateless; store persistent data in volumes or external storage

Difference Between Containers vs Virtual Machines

Real-World Deployment Flow

A typical containerized deployment pipeline looks like this:

Developer → Build JAR → Create Dockerfile → Build Image → Push to Registry → Deploy Container → Scale via Orchestrator

In modern environments, Docker images are pushed to a container registry and deployed using orchestration platforms like Kubernetes.

Docker acts as the foundation for cloud-native deployments by:

• Packaging applications consistently
• Enabling automated CI/CD pipelines
• Supporting rolling updates and scaling
• Integrating with orchestration and monitoring tools

Conclusion

Docker fundamentals form the backbone of modern DevOps and microservices architecture. By mastering images, containers, storage layers, networking, volumes, and debugging techniques, teams can build portable, scalable, and production-ready applications with consistency across environments.