Docker has become a foundational technology in modern software development and DevOps. It enables developers and operations teams to package applications with all their dependencies into lightweight, portable units called containers. These containers run consistently across any environment, from a developer’s laptop to production servers, eliminating the classic “it works on my machine” problem.
Containerization isolates applications at the process level while sharing the host operating system’s kernel. This makes containers far more efficient than traditional virtual machines, which require a full guest OS. The result is faster startup times, lower resource usage, and easier scaling.
In DevOps workflows, Docker bridges the gap between development and operations. Teams can build once and deploy anywhere, integrate containers into CI/CD pipelines, and manage complex multi service applications with tools like Docker Compose or Kubernetes. Understanding Dockerfiles, multi stage builds, and container networking is essential for creating efficient, secure, and production ready containerized applications.
Core Concepts
An image is a read only template that contains the application code, runtime, libraries, and configuration. A container is a running instance of an image. You create images primarily through a Dockerfile, a simple text file of instructions that Docker executes step by step.
Docker uses a layered filesystem. Each instruction in a Dockerfile creates a new layer. Unchanged layers are cached, which dramatically speeds up subsequent builds.
You can learn what is a freeCodeCamp Responsive Web Design Certification using beginner’s guide.
How to Write a Basic Dockerfile?
A Dockerfile defines how to build an image. Here is a practical example for a simple Node.js application:
text
FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]Key instructions explained:
- FROM sets the base image. Prefer official, minimal images such as Alpine variants for smaller size and reduced attack surface.
- WORKDIR sets the working directory inside the container.
- COPY transfers files from the host into the image. Copy dependency files first so that the dependency installation layer remains cached when only application code changes.
- RUN executes commands during the build (for example, installing packages).
- EXPOSE documents the port the application listens on (it does not publish the port).
- CMD (or ENTRYPOINT) defines the default command that runs when the container starts.
Best practices for beginners:
- Always use a .dockerignore file to exclude node_modules, .git, logs, and other unnecessary files from the build context.
- Pin specific image tags (for example, node:20.10-alpine) instead of latest for reproducibility.
- Keep instructions ordered from least frequently changing to most frequently changing to maximize cache hits.
- Run as a non root user in production for better security.
To build and run:
docker build -t my-app:1.0 .
docker run -d -p 3000:3000 –name my-app my-app:1.0
How to Use Multi Stage Builds?
Multi stage builds are one of the most powerful features of modern Dockerfiles. They allow you to use intermediate stages for building and compiling, then copy only the final artifacts into a minimal runtime image. This produces significantly smaller and more secure production images by excluding build tools, source code, and intermediate files.
Example for a Node.js application that requires a build step:
text
# Stage 1: Build
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build
# Stage 2: Production
FROM node:20-alpine AS production
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY --from=builder /app/dist ./dist
EXPOSE 3000
USER node
CMD ["node", "dist/index.js"]Benefits include:
- Dramatically reduced image size (often from hundreds of megabytes to tens of megabytes).
- Separation of build time dependencies from runtime dependencies.
- Improved security because compilers and development tools are not present in the final image.
- Better caching and potential parallel execution of independent stages with BuildKit.
Always name stages with AS so you can reference them clearly with COPY –from.
How to Set Up Container Networking?
Containers need to communicate with each other and with the outside world. Docker provides several network drivers:
- bridge (default): Creates a private network on the host. Containers on the same custom bridge can reach each other by name thanks to Docker’s embedded DNS. Use this for most single host applications.
- host: The container shares the host’s network stack directly. There is no isolation or port mapping; the container uses the host’s IP and ports. Useful for performance sensitive workloads but reduces isolation.
- none: Completely isolates the container from the network.
- overlay: Enables multi host communication (commonly used with Docker Swarm or Kubernetes).
For everyday use, create a custom bridge network:
docker network create my-app-network
Then attach containers:
docker run -d –name db –network my-app-network postgres:16
docker run -d –name web –network my-app-network -p 8080:80 my-web-app
Containers on the same user-defined network can communicate using service names as hostnames (for example, the web container can reach the database at db:5432).
In Docker Compose, a default network is automatically created for all services defined in the compose.yaml file, making inter service communication seamless.
Publishing ports with -p hostPort:containerPort (or the long form –publish) makes a container’s port accessible from the host or external networks. The EXPOSE instruction in a Dockerfile is only documentation; it does not publish the port.
How to Integrate Docker into a DevOps Workflow?
Docker shines in DevOps by enabling consistent environments across the entire software delivery lifecycle:
- Developers build and test locally with the same images used in CI and production.
- CI pipelines build images, run tests inside containers, and push artifacts to a registry.
- Deployment tools pull the exact same images, ensuring parity between environments.
- Multi stage builds keep production images lean and secure.
- Container networking and orchestration tools (Compose for simple cases, Kubernetes for larger systems) manage service discovery and communication.
Additional practical tips:
- Use docker compose for multi container applications. Define services, networks, volumes, and environment variables in a single compose.yaml file.
- Prefer multi stage builds and minimal base images for production.
- Scan images for vulnerabilities regularly.
- Manage secrets carefully (never bake them into images).
- Use volumes for persistent data and bind mounts for development.
Getting Started Checklist
- Install Docker Desktop (or Docker Engine on Linux).
- Verify installation with docker run hello-world.
- Create a simple Dockerfile for an existing application.
- Practice building, running, stopping, and inspecting containers.
- Experiment with multi stage builds to reduce image size.
- Create a custom network and connect multiple containers.
- Introduce Docker Compose for multi service setups.
- Integrate the workflow into a basic CI pipeline.
Docker and containerization form the backbone of modern DevOps practices. Mastering Dockerfiles, multi stage builds, and container networking gives you the ability to build, ship, and run applications reliably at any scale. Start with simple single container applications, then gradually incorporate the advanced patterns described above. With consistent practice, these concepts become second nature and significantly improve development speed, reliability, and collaboration across teams.
