Introduction to Docker: How Containerization Transforms Development Workflows

Introduction

"It works on my machine, but not in someone else's environment or on the server..."

In team software development, this problem of "environment differences" has long troubled many developers. Docker is a technology that solves this problem and allows for the easy construction of consistent environments from development to production.

Docker makes it possible to run applications identically anywhere by packaging them into independent environments called "containers." In this article, I will provide an easy-to-understand explanation of the basic concepts of Docker and how containerization changes the development flow, complete with diagrams.

What is Docker?

Docker is a platform for managing applications in units called "containers." A container is a package that includes the application itself, necessary libraries, and configuration files. It operates in an isolated state regarding processes and file systems while sharing the host OS kernel.

This makes it easy to build and distribute clean, highly reproducible application execution environments without polluting the host environment.

Summary: 3 Key Benefits of Docker

Before diving into the details, here is a summary of why introducing Docker streamlines development. This article will help you understand how the following three points are achieved.

Benefit	Overview	Specific Effects
Environment Consistency	By packaging applications and their dependencies (libraries, config files, etc.) into containers, the same environment can be reproduced anywhere.	Elimination of the "It works on my machine" problem, ensuring consistency across development, staging, and production environments.
Lightweight & Fast	Compared to virtual machines (VMs), it consumes fewer resources and starts up very quickly because it does not include an OS.	Faster development cycles, reduced infrastructure costs.
Portability	Once a container image is created, it can be run anywhere Docker is supported.	Seamless migration from local PCs to cloud servers, high affinity with microservices architecture.

Difference between Containers and Virtual Machines (VMs)

A technology often compared with containers is "Virtual Machines (VMs)." While both are similar in that they execute applications in isolated environments, there are significant differences in their architectures.

Comparison of Container and Virtual Machine (VM) Architectures

• Virtual Machines (VMs): On top of the hardware and host OS, a virtual environment (Guest OS) is built for each instance through software called a "hypervisor." Since it includes the entire OS, resource consumption is high and startup takes time.

• Containers: On top of the host OS, only the elements necessary for application execution are isolated via the "Docker Engine." Since they do not include an OS, they are extremely lightweight and operate fast.

Comparison Item	Container	Virtual Machine (VM)
Startup Speed	Fast (Seconds)	Slow (Minutes)
Resource Efficiency	High	Low
Size	Lightweight (MB)	Heavy (GB)
Isolation Level	Process level	OS level

Basic Concepts of Docker

There are four important elements to understand when learning Docker. Grasping the relationship between these is the key to mastering Docker.

Basic Docker architecture and workflow

1. Dockerfile (Blueprint): A text file that defines the configuration of a container. It describes which OS image to use as a base, which files to copy, which commands to execute, etc.

2. Docker Image (Template): A read-only template created based on a Dockerfile that packages the application and its execution environment. Containers are created based on this image.

3. Docker Container (Execution Environment): An instance created from a Docker image where the application actually operates. It is possible to launch multiple containers from a single image.

4. Docker Registry (Registry): A repository for storing and sharing Docker images. In addition to the official Docker Hub, you can also build your own private registry.

Practical Example: Containerizing a Node.js App

Now, let's containerize a simple Node.js application using Docker. First, prepare a Dockerfile like the following.

# Specify the base Node.js image
FROM node:18-alpine

# Create the application's working directory
WORKDIR /usr/src/app

# Copy dependency files and install them
COPY package*.json ./
RUN npm install

# Copy the source code
COPY . .

# Specify the port the application listens on
EXPOSE 3000

# Command to run when the container starts
CMD [ "node", "server.js" ]

Execute the following commands in the directory where this Dockerfile is located.

# 1. Build the Docker image
$ docker build -t my-node-app .

# 2. Run a container from the built image
$ docker run -p 8080:3000 my-node-app

Now, if you access http://localhost:8080 locally, you can connect to the Node.js application running inside the container.

Changes in Development Flow

Introducing Docker dramatically improves the development flow.

• Before: Each developer manually set up the development environment on their own PC. Problems due to version differences occurred frequently, and manual deployments to production were prone to human error.
• After: Dockerfile and docker-compose.yml are shared via Git. Anyone can instantly build the same development environment with a single docker-compose up command. By integrating with CI/CD pipelines, the built image is deployed directly to the production environment.

By unifying the development environment across the team and codifying infrastructure configuration (Infrastructure as Code), development productivity and quality improve significantly.

Conclusion

In this article, we explained the basic concepts of Docker and the changes it brings to the development flow. Docker is an extremely powerful tool in modern web development, and learning it can significantly improve your skills as a developer.

As next steps, I recommend learning more advanced topics like docker-compose for linking multiple containers or Kubernetes for automating container management in production. To start with, try containerizing one of your own projects with Docker!