Modern application development involves more than writing code. Developers also need to manage dependencies, configure environments, install services, and ensure applications run consistently across different machines.
This is one of the reasons Docker has become an important technology in modern software development and DevOps.
Docker helps developers package applications and their dependencies into containers, making it easier to develop, test, distribute, and deploy software.
Two important components of the Docker ecosystem are Dockerfile and Docker Compose.
Although they are closely related, they serve different purposes. Understanding how they work together is essential for developers working with containerized applications.
A Dockerfile is a text file containing instructions used to build a Docker image.
It tells Docker how to prepare an application environment, including:
Instead of manually configuring an application environment every time, developers can define the process once in a Dockerfile and use it to build consistent Docker images.
Consider a simple Node.js application.
devutilitykits
FROM node:22-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD ["npm", "start"]
Let's understand the instructions:
| Instruction | Purpose |
|---|---|
| FROM | Defines the base Docker image |
| WORKDIR | Sets the working directory |
| COPY | Copies files into the image |
| RUN | Executes commands during image building |
| EXPOSE | Documents the intended container port |
| CMD | Defines the default startup command |
To build the Docker image:
docker build -t my-node-app .
To start a container:
docker run -p 3000:3000 my-node-app
For developers who frequently create container configurations, a Dockerfile Generator can help prepare Dockerfile templates without writing every instruction manually. Generated configurations should still be reviewed according to application requirements.
Docker Compose is a tool for defining and managing applications that use multiple Docker containers.
In real-world development, applications rarely operate independently.
For example, a typical web application might require:
Managing these services individually can become complicated.
Docker Compose simplifies this process by allowing developers to define multiple services in a single YAML configuration file, usually named compose.yaml.
Consider a simple application that requires a Node.js backend and a PostgreSQL database.
services:
app:
build: .
ports:
- "3000:3000"
environment:
DATABASE_URL: postgres://user:password@db:5432/myapp
depends_on:
- db
db:
image: postgres:16-alpine
environment:
POSTGRES_USER: user
POSTGRES_PASSWORD: password
POSTGRES_DB: myapp
volumes:
- postgres_data:/var/lib/postgresql/data
volumes:
postgres_data:
This configuration defines two services:
App Service: Builds the application image using the Dockerfile in the current directory and exposes port 3000.
Database Service: Runs a PostgreSQL container and stores database files in a persistent Docker volume.
The application can connect to the database using the service name db as its hostname.
To start both services:
docker compose up -d
To stop the services:
docker compose down
The database volume remains available after stopping the services. Running docker compose down -v, however, removes the associated named volumes.
One important consideration: depends_on controls service startup order, but does not necessarily mean the database is ready to accept connections. Applications should handle connection retries or use appropriate health checks.
Although both are important in containerized development, they solve different problems.
| Feature | Dockerfile | Docker Compose |
|---|---|---|
| Main purpose | Build Docker images | Manage multiple services |
| File format | Dockerfile instructions | YAML |
| Main responsibility | Define application environment | Define application services |
| Container management | Used to build images | Starts and manages containers |
| Typical usage | Application packaging | Multi-container applications |
In simple terms:
Dockerfile defines how to build an image. Docker Compose defines how multiple services work together.
They are complementary technologies rather than competing alternatives.
Consider a web application with a backend API and a database.
The development workflow typically looks like this:
The overall architecture looks like this:
Docker Compose
|
-------------------
| |
App Service Database Service
| |
Docker Image PostgreSQL
|
Dockerfile
|
Node.js Application
This separation makes it easier to maintain application configurations and manage development environments.
Working with Docker also requires understanding its command-line interface.
Here are some frequently used commands.
Build an image
docker build -t my-app .
List running containers
docker ps
List all containers
docker ps -a
Run a container
docker run -d -p 8080:80 nginx
View container logs
docker logs container_name
Stop a container
docker stop container_name
List available images
docker images
Remove a container
docker rm container_name
Developers who regularly work with Docker can use a Docker Command Generator to prepare commonly used Docker commands more conveniently.
Creating a working Docker configuration is only the first step. Maintaining secure, efficient, and reliable containers is equally important.
Here are some practical recommendations:
Use Appropriate Base Images
Choose trusted and maintained base images. Lightweight images can reduce image size, but compatibility and security should also be considered.
Avoid Running Containers as Root
Where possible, configure applications to run using a dedicated non-root user.
Use .dockerignore
Exclude unnecessary files such as node_modules, .git, temporary files, and local environment files from the Docker build context.
Manage Environment Variables Carefully
Avoid hardcoding production credentials or sensitive information directly into Dockerfiles or Compose files.
Use Persistent Volumes
Database and application data that must survive container recreation should be stored using appropriate persistent storage.
Optimize Docker Images
Use multi-stage builds where appropriate, minimize unnecessary dependencies, and take advantage of Docker build caching.
Review Configurations Before Production
Always inspect generated configurations, exposed ports, permissions, network settings, and resource requirements before deploying applications.
Dockerfile and Docker Compose are two essential building blocks of modern containerized development.
A Dockerfile helps developers define and build consistent application images, while Docker Compose simplifies the management of multiple services that work together.
Whether you're developing a small Node.js application, managing a backend API, or building a more complex microservices environment, understanding these technologies can make development and deployment workflows significantly easier.
The best way to learn Docker is to experiment with real applications, build your own images, configure multiple services, and understand how containers communicate with each other.
Understanding the fundamentals is the first step toward building more reliable, portable, and maintainable applications with Docker.
iThome鐵人賽
看影片追技術