Skip to content
Noroff Case Studies

Docker Case Study

Author: Maksim Batsurko <(X7_C)>

Introduction

Docker is a containerization platform that allows developers to build, package, and run applications in highly portable containers. By leveraging the host machine’s operating system kernel, containers remain lightweight and performant compared to traditional virtual machines. This seamless process of shipping the same container image across different environments (development, testing, production) helps reduce inconsistencies and the “it works on my machine” phenomenon.

Personal Opinion: Docker has revolutionized DevOps by simplifying continuous integration and deployment (CI/CD) processes. Its intuitive CLI, robust tooling, and vast community-driven ecosystem make it the go-to choice for containerization in many modern software projects.

Brief History

  • Pre-2013 (Early Container Concepts)
    Before Docker, container-like technologies existed (e.g., chroot in Unix, LXC (Linux Containers)). These offered isolated environments but were complex to set up and manage.

  • 2013:
    Docker, Inc. (formerly dotCloud) open-sourced Docker. This allowed developers to use a standardized approach to building containers, significantly lowering the barrier to entry for containerization.

  • 2014:
    Major tech players such as Microsoft, Red Hat, and AWS began integrating Docker capabilities into their platforms. Docker Hub was launched as a public registry, making image distribution easier.

  • 2015–2017:

    • Docker Swarm offered native container orchestration, although Kubernetes quickly emerged as a more popular choice for large-scale environments.
    • Docker acquired multiple startups to enhance security, networking, and volume management for containers.

  • 2017:
    The formation of the Open Container Initiative (OCI) set industry standards for container formats and runtimes. Docker contributed heavily, donating components like runC.

  • 2018–2020:
    Growing competition from other container runtime projects (Podman, CRI-O) and orchestration platforms (Kubernetes) urged Docker to refocus on its core mission of building and sharing containers.

  • 2021–Present:
    Docker refines its licensing and product offerings (e.g., Docker Desktop). Community and enterprise usage continue, but the ecosystem is more fragmented as alternatives gain traction.

Insight: Docker’s popularity soared thanks to an intuitive developer experience and the rise of DevOps culture. Though other runtimes and orchestrators exist, Docker remains a foundational tool for container-based development workflows.

Architecture & Workflow

Docker follows a client-server model that consists of various components working together:

  1. Docker Client (CLI)

    • The command-line interface (e.g., docker build, docker run) that users interact with.
    • Sends commands to the Docker daemon via REST APIs.

  2. Docker Daemon (Engine)

    • Runs on the host machine and does the heavy lifting of building, running, and distributing containers.
    • Listens for commands from the Docker Client and manages container life cycles.

  3. Images

    • Read-only templates that contain instructions for creating a container.
    • Built from a Dockerfile which uses a layered filesystem approach (each instruction in the Dockerfile forms a new layer).

  4. Containers

    • Running instances of an image that include everything needed to run an application.
    • Can be started, stopped, deleted, and moved around easily.

  5. Registries

    • A registry (like Docker Hub or a private registry) stores images.
    • The Docker client can push or pull images to and from these registries.

Development Workflow typically looks like this:

  1. Create or use an existing Dockerfile.
  2. Build a container image (docker build).
  3. Run a container from that image (docker run).
  4. Test the container locally.
  5. Push the image to a registry if needed.
  6. Deploy the container(s) to a production environment or orchestrator (Docker Swarm, Kubernetes, etc.).

Main Features

Docker Engine

  • Core Runtime: The backend service that builds and runs Docker images as containers.
  • API: Exposes a RESTful API for CLI or third-party tool integration.
  • Plugins: Extend functionality (network drivers, volume management, etc.).

Docker Desktop

  • All-in-One Solution: Bundles Docker Engine, Docker CLI, Docker Compose, and Kubernetes (optional).
  • Platform-Specific: Available for Windows, macOS, and Linux with a user-friendly GUI for managing containers.
  • Convenient Tooling: Simplifies local development without manual VirtualBox, Hyper-V, or similar VM setups.

Docker Images

  • Layered Filesystem: Each instruction in a Dockerfile (e.g., RUN apt-get install) creates a new read-only layer.
  • Version Control-Like: Layers can be cached, which speeds up rebuilds.
  • Base Images: Common images like ubuntu, alpine, node, or python are often starting points.

Docker Compose

  • Multi-Container Config: Define multiple containers and their relationships (e.g., web + database) in a YAML file.
  • Orchestration on a Small Scale: Simplifies linking containers, managing networks, volumes, and environment variables for local development.
  • Portable Setup: One docker-compose.yml can be used across development teams to ensure consistent services.

Docker Swarm

  • Native Container Orchestration: Allows clustering of Docker hosts to create a swarm.
  • Declarative Services: Define how many replicas of each service you want, and Swarm maintains them.
  • Less Complex: Easier to set up than Kubernetes but lacks advanced features required by large, complex applications.

Docker Hub

  • Public Registry: A centralized place to publish and discover container images.
  • Community & Official Images: Thousands of free, pre-built images (e.g., MySQL, Redis, Nginx).
  • Private Repositories: Offers paid plans for storing private images.

Strengths and Weaknesses

StrengthsWeaknesses
Portability: Containers run on any system with Docker installed.Ecosystem Fragmentation: Multiple container runtimes (Docker, Podman, CRI-O) can confuse newcomers.
Consistency: Eliminates environment discrepancies; reproducible builds.Learning Curve: Requires understanding of images, layered filesystems, and container networking.
Resource Efficiency: Shares the host OS kernel, using fewer resources than VMs.Security Risks: Misconfigurations (e.g., running containers as root) can lead to vulnerabilities.
Rich Community & Tools: Extensive image library, tutorials, support.Orchestration Gap: Docker Swarm is overshadowed by Kubernetes for large-scale deployments.
Speed & Simplicity: Faster startup times than full VMs; simpler in dev workflows.Commercial Licensing: Recent changes to Docker Desktop licensing for businesses introduced some confusion.

Opinion & Insight: Docker excels at simplifying container usage and fosters a strong open-source community. However, production-level orchestration frequently leans towards Kubernetes, leaving Docker primarily as the container build/run tool.

Market Comparison

Docker vs. Virtual Machines

  • Performance: Containers generally use less CPU and RAM due to shared kernel usage.
  • Boot Speed: Containers start in seconds, whereas VMs can take minutes to boot a full OS.
  • Resource Isolation: VMs provide stronger isolation (separate OS), which can be beneficial in multi-tenant setups.

Docker vs. Podman

  • Podman: A daemonless container engine that emphasizes running containers as non-root.
  • Docker: Larger ecosystem with a single daemon approach, plus Docker Compose.

Note: Podman can often be a drop-in replacement for Docker CLI commands, but it lacks integrated tools like Docker Swarm.

Docker vs. Kubernetes

  • Docker: Focuses on building and running containers with optional Swarm mode for simpler orchestration.
  • Kubernetes: The standard for orchestrating containers at scale, with robust features like auto-scaling, rolling updates, and resource scheduling.

Integration: Kubernetes can still use Docker as a container runtime (though “dockershim” deprecation created some confusion).

Docker vs. CRI-O

  • CRI-O: A lightweight container runtime designed specifically for Kubernetes.
  • Docker: General-purpose, broad feature set, but not specialized solely for Kubernetes.

Security Considerations

  1. Rootless Docker

    • Allows Docker to run without root privileges on the host system, reducing the attack surface.

  2. Image Vulnerabilities

    • Official images or third-party images may contain known vulnerabilities if not regularly updated.
    • Tools like Trivy or Clair can scan images for security issues.

  3. Network Isolation

    • Docker supports custom networks (bridge, overlay, macvlan) to restrict container connectivity.
    • Firewalls and ingress controllers may be necessary in production to control traffic flow.

  4. Least Privilege

    • Always run containers with the minimal privileges and capabilities required.
    • Avoid --privileged mode unless absolutely necessary.

Getting Started (Detailed Example)

Below is a more elaborate demonstration of Docker in action:

1. Install Docker

  • *Docker Desktop: For Windows or Mac, download it from Docker’s official website.
  • Linux: Install from your distro’s repository (e.g., apt-get install docker.io on Ubuntu).

2. Simple Dockerfile

# Use an official Node.js runtime as a base image
FROM node:14-alpine


# Set the working directory inside the container
WORKDIR /app


# Copy the package files and install dependencies
COPY package*.json ./
RUN npm install


# Copy the rest of the application code
COPY . .


# Expose an application port (e.g., 3000)
EXPOSE 3000


# Start the Node.js application
CMD ["npm", "start"]

3. Build and Run the Container

Terminal window
# Build the Docker image from the Dockerfile in the current directory
docker build -t my-node-app .


# Run a container from the newly built image
docker run -d -p 3000:3000 --name my-running-node-app my-node-app


# (Optional) Check logs to ensure your app started
docker logs my-running-node-app
  • Conclusion:

Docker has revolutionized the software development landscape by making containerization accessible, portable, and efficient. Its intuitive tooling, extensive ecosystem, and ability to streamline CI/CD workflows have established it as a cornerstone of modern DevOps practices. Despite facing competition from emerging technologies like Podman and the dominance of Kubernetes for large-scale orchestration, Docker continues to hold a vital place in development workflows as the go-to solution for building and sharing containers.

While Docker Swarm has lost ground to Kubernetes in orchestration, Docker’s strengths lie in its simplicity, developer-friendly experience, and broad adoption. Moving forward, Docker’s success will depend on its ability to address challenges such as ecosystem fragmentation and evolving security requirements while maintaining its leadership in containerization.

For developers and organizations, Docker remains a reliable and efficient choice for container-based application development. By continuously refining its offerings and adapting to industry trends, Docker can maintain its relevance and continue to drive innovation in the containerization ecosystem.

References

  1. Docker Official Documentation
    Comprehensive guides and best practices for using Docker’s core features and tools.

  2. Docker Desktop
    A cross-platform GUI for managing Docker containers and environments on Windows, Mac, and Linux.

  3. Open Container Initiative (OCI)
    An organization that develops industry standards for container formats and runtimes.

  4. Docker Licensing FAQ
    Explains the recent licensing changes and what they mean for individual and commercial users.

  5. Podman vs Docker
    Official site for Podman, a daemonless container engine often compared to Docker.

  6. Kubernetes Documentation
    Official docs for Kubernetes, the leading container orchestration platform.

Additional Resources