Docker for Developers: From Zero to Production-Ready Containers

Tien Nguyen Huynh — Sun, 30 Aug 2026 16:40:09 +0000

Every modern developer encounters Docker eventually. You have likely run docker run -p 8080:80 nginx or copied a snippet from a README to get a local database running. But moving from blindly running commands to structuring production-grade container workflows requires a deeper understanding of how Docker operates under the hood.

In this article, we will move beyond the basics of containerization. We will explore core container concepts, build a highly optimized multi-stage Dockerfile for a web application, orchestrate local environments with Docker Compose, and review production best practices that keep your images small and secure.

1. Demystifying the Core Architecture

Before writing code, let us clear up common misconceptions about Docker components.

Image: A read-only template containing your application code, runtime, system tools, libraries, and dependencies. Think of an image as a class definition in OOP.
Container: A runnable instance of an image. It is isolated from the host machine and other containers using Linux namespaces (for isolation) and cgroups (for resource limiting). Think of a container as an object instantiated from a class.
Volume: Persistent storage detached from the container lifecycle. Because containers are ephemeral by default, any data written inside a container disappears when it is destroyed. Volumes mount a directory from the host OS into the container.
Network: The abstraction layer allowing containers to communicate with each other or with external services.

2. Writing a Production-Grade Dockerfile

A simple Dockerfile gets your app running, but an optimized Dockerfile ensures fast CI/CD builds, minimal attack surfaces, and tiny deployment artifacts.

Let's look at a typical Node.js application. Here is a common mistake beginners make:

# Bad Dockerfile Example
FROM node:18
WORKDIR /app
COPY . .
RUN npm install
EXPOSE 3000
CMD ["node", "server.js"]

What is wrong with this approach?

Massive image size: node:18 is based on a full Debian distribution, weighing around 1GB.
Broken build cache: Copying . before running npm install invalidates Docker's layer cache on every single code change, forcing node modules to reinstall every time.
Security risk: The application runs as the root user inside the container.

The Optimized Multi-Stage Approach

Multi-stage builds allow you to use a heavy base image to compile dependencies and a lightweight image to run the final app.

Here is how to structure it properly:

# Stage 1: Build & Dependencies
FROM node:18-alpine AS builder
WORKDIR /usr/src/app

# Copy package manifests first to leverage Docker layer caching
COPY package*.json ./

# Install all dependencies (including devDependencies for building)
RUN npm ci

# Copy remaining source code
COPY . .

# Build application (if using TypeScript or bundlers)
RUN npm run build

# Prune non-production dependencies
RUN npm prune --production

# ---------------------------------------------------
# Stage 2: Production Execution
FROM node:18-alpine AS runner
WORKDIR /usr/src/app

# Set production environment
ENV NODE_ENV=production

# Create a non-privileged system user
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nodejs -u 1001 -G nodejs

# Copy built assets and production node_modules from builder
COPY --from=builder /usr/src/app/package*.json ./
COPY --from=builder /usr/src/app/node_modules ./node_modules
COPY --from=builder /usr/src/app/dist ./dist

# Change ownership to non-root user
USER nodejs

EXPOSE 3000

CMD ["node", "dist/server.js"]

Key Improvements Made:

Minimal Base Image: Switching to alpine reduces the base footprint down to ~150MB.
Layer Caching: package*.json is copied separately before npm ci. Re-building after changing application logic takes seconds instead of minutes.
Multi-Stage Build: Development dependencies and build tools stay in the builder stage, keeping the runner image lean.
Least Privilege Security: Setting USER nodejs prevents potential container breakout exploits from obtaining host root access.

3. Don't Forget `.dockerignore`!

Just as .gitignore keeps clutter out of your Git repository, a .dockerignore file prevents unneeded files from entering the Docker build context. Sending gigabytes of local node modules or git history over to the Docker daemon slows down your builds.

Create a .dockerignore file alongside your Dockerfile:

node_modules
npm-debug.log
.git
.gitignore
Dockerfile
docker-compose.yml
README.md
dist
.env

4. Local Environment Orchestration with Docker Compose

Applications rarely live in isolation. You usually need an app server, a database, and perhaps a caching layer like Redis.

Rather than executing long docker run commands manually, use Docker Compose to define your stack declaratively in docker-compose.yml.

version: '3.8'

services:
  app:
    build:
      context: .
      target: runner
    ports:
      - "3000:3000"
    environment:
      - PORT=3000
      - DATABASE_URL=postgres://devuser:secretpass@db:5432/devdb
    depends_on:
      db:
        condition: service_healthy
    restart: unless-stopped

  db:
    image: postgres:15-alpine
    ports:
      - "5432:5432"
    environment:
      POSTGRES_USER: devuser
      POSTGRES_PASSWORD: secretpass
      POSTGRES_DB: devdb
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U devuser -d devdb"]
      interval: 5s
      timeout: 5s
      retries: 5

volumes:
  pgdata:

Useful Compose Commands:

Start all services in background: docker compose up -d
View aggregated stream logs: docker compose logs -f
Stop and remove containers + networks: docker compose down
Destroy persistent volumes: docker compose down -v

5. Essential CLI Commands for Debugging

When a container refuses to start or acts unexpectedly, these commands will save your sanity:

Inspect container logs:

   docker logs -f --tail 100 <container_id_or_name>

Execute an interactive shell inside a running container:

   docker exec -it <container_id_or_name> sh

Check running container metrics (CPU, Memory, Network I/O):

   docker stats

Clean up unused images, containers, and volumes:

   docker system prune -a --volumes

Summary Checklist for Developers

To ensure your application is containerized cleanly, keep these rules in mind:

[ ] Leverage layer caching: Put commands that change infrequently (installing dependencies) near the top of your Dockerfile.
[ ] Use lightweight base images: Prefer alpine or slim tags over default full distributions.
[ ] Utilize multi-stage builds: Keep build tools out of runtime images.
[ ] Never run as root: Create and switch to a non-root system user inside the Dockerfile.
[ ] Include a .dockerignore: Do not transfer heavy build outputs or confidential .env files to the build context.
[ ] Store state outside containers: Use named volumes or managed database services for persistent storage.

Containerization transforms software delivery from predictable local builds to dependable production deployments. Master these fundamentals, and your workflows will be faster, safer, and far easier to maintain.

DEV Community: Tien Nguyen Huynh