Docker containerization in NestJS - Deep Dive

Overview - Docker containerization

What is it?

Docker containerization is a way to package an application and all its parts into a single unit called a container. This container runs the application in the same way no matter where it is deployed. It helps developers build, ship, and run applications quickly and reliably by isolating them from the environment.

Why it matters

Without Docker containerization, developers face problems like "it works on my machine" but not on others, because environments differ. Docker solves this by creating a consistent environment everywhere. This means faster development, easier testing, and smoother deployment, saving time and reducing errors.

Where it fits

Before learning Docker containerization, you should understand basic application development and how software runs on operating systems. After mastering Docker, you can learn about orchestration tools like Kubernetes to manage many containers at once.

Mental Model

Core Idea

Docker containerization packages an app with everything it needs so it runs the same anywhere, like a portable box for software.

Think of it like...

Imagine packing all your clothes, toiletries, and gadgets into a suitcase before a trip. No matter where you go, you have everything you need in one box. Docker containers are like that suitcase for software.

┌─────────────────────────────┐
│        Host Machine          │
│ ┌─────────────────────────┐ │
│ │      Docker Engine       │ │
│ │ ┌─────────────────────┐ │ │
│ │ │   Container 1       │ │ │
│ │ │ ┌───────────────┐  │ │ │
│ │ │ │ App + Env    │  │ │ │
│ │ │ └───────────────┘  │ │ │
│ │ └─────────────────────┘ │ │
│ │ ┌─────────────────────┐ │ │
│ │ │   Container 2       │ │ │
│ │ │ ┌───────────────┐  │ │ │
│ │ │ │ App + Env    │  │ │ │
│ │ │ └───────────────┘  │ │ │
│ │ └─────────────────────┘ │ │
│ └─────────────────────────┘ │
└─────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

What is a Docker container?

Concept: Introduce the basic idea of a container as a lightweight, isolated environment for running software.

A Docker container is like a small box that holds your app and everything it needs to run. It shares the computer's operating system but keeps your app separate from other apps. This means your app runs the same way on any computer with Docker.

Result

You understand that containers isolate apps and their dependencies, making them portable and consistent.

Understanding containers as isolated boxes helps you see why they solve environment problems in software.

2

Foundation

Docker images and containers explained

Concept: Explain the difference between images (blueprints) and containers (running instances).

A Docker image is like a recipe or blueprint that describes what goes inside the container box. When you start a container, Docker uses the image to create a running instance of your app. You can have many containers from the same image.

Result

You know that images are templates and containers are the live apps running from those templates.

Knowing the image-container relationship clarifies how Docker manages app versions and instances.

3

Intermediate

Building a Docker image for NestJS app

🤔Before reading on: Do you think a Dockerfile only copies your app code or also installs dependencies? Commit to your answer.

Concept: Learn how to write a Dockerfile to package a NestJS app with its dependencies.

A Dockerfile is a text file with instructions to build an image. For a NestJS app, it usually starts from a Node.js base image, copies your app code, installs dependencies with npm, and sets the command to start the app. This ensures the container has everything to run your NestJS app.

Result

You can create a Docker image that packages your NestJS app and its environment.

Understanding Dockerfile steps helps you control exactly what goes into your container, ensuring consistency.

4

Intermediate

Running and managing Docker containers

🤔Before reading on: Do you think stopping a container deletes it or just pauses it? Commit to your answer.

Concept: Learn how to start, stop, and remove containers using Docker commands.

You use 'docker run' to start a container from an image. 'docker stop' pauses the container but keeps it saved. 'docker rm' deletes the container. This lets you control your app's lifecycle inside Docker.

Result

You can run your NestJS app inside a container and manage its state.

Knowing container lifecycle commands prevents accidental data loss and helps in debugging.

5

Intermediate

Networking and ports in Docker containers

🤔Before reading on: Does a container automatically share the host's network ports? Commit to your answer.

Concept: Understand how to expose and map ports so your app inside a container is accessible outside.

Containers have their own network space. To let your NestJS app be reachable, you map container ports to host ports using '-p' flag. For example, '-p 3000:3000' maps container port 3000 to host port 3000.

Result

Your app inside Docker can be accessed from your browser or other services.

Understanding port mapping is key to connecting your containerized app with the outside world.

6

Advanced

Optimizing Docker images for NestJS apps

🤔Before reading on: Do you think smaller images always mean faster app startup? Commit to your answer.

Concept: Learn techniques to reduce image size and improve build speed for production-ready containers.

Use multi-stage builds to separate build and runtime environments. For NestJS, first build the app in a Node image, then copy only the compiled files to a smaller Node runtime image. This reduces image size and attack surface.

Result

You create efficient Docker images that start faster and use less disk space.

Knowing how to optimize images improves deployment speed and security in real projects.

7

Expert

Docker container internals and resource isolation

🤔Before reading on: Do you think containers are full virtual machines? Commit to your answer.

Concept: Understand how Docker uses OS features like namespaces and cgroups to isolate containers without full virtualization.

Docker containers share the host OS kernel but use namespaces to isolate processes, filesystems, and networks. Cgroups limit resource usage like CPU and memory. This makes containers lightweight compared to virtual machines.

Result

You grasp why containers are fast and efficient, yet isolated.

Understanding container internals explains their performance benefits and limitations compared to VMs.

Under the Hood

Docker uses Linux kernel features called namespaces to create isolated views of system resources for each container. It also uses cgroups to limit and prioritize resource usage. The Docker Engine manages images and containers, translating Dockerfile instructions into layered images stored on disk. When running a container, Docker creates a writable layer on top of the image layers and sets up isolated networking and process spaces.

Why designed this way?

Docker was designed to be lightweight and fast by avoiding full virtual machines, which are heavy and slow. Using OS-level isolation allows many containers to run on a single host efficiently. The layered image system enables reuse and easy updates. Alternatives like full VMs were too resource-heavy for rapid development and deployment.

Host OS Kernel
├─ Namespaces (process, network, mount)
├─ Cgroups (CPU, memory limits)
└─ Docker Engine
   ├─ Image Layers (read-only)
   └─ Container Writable Layer
       ├─ Isolated Process Namespace
       ├─ Isolated Network Namespace
       └─ Isolated Filesystem Namespace

Myth Busters - 4 Common Misconceptions

Quick: Do you think Docker containers are the same as virtual machines? Commit to yes or no.

Common Belief: Docker containers are just lightweight virtual machines.

Reality: Containers share the host OS kernel and isolate apps using namespaces, unlike virtual machines which run full guest OSes.

Why it matters: Confusing containers with VMs can lead to wrong expectations about performance, security, and resource use.

Quick: Do you think stopping a container deletes its data automatically? Commit to yes or no.

Common Belief: Stopping a container removes all its data and state.

Reality: Stopping pauses the container; data remains unless the container is removed or volumes are deleted.

Why it matters: Misunderstanding this can cause accidental data loss or confusion during development.

Quick: Do you think Docker images always include the entire OS? Commit to yes or no.

Common Belief: Docker images contain a full operating system inside them.

Reality: Images usually contain only the minimal OS libraries needed, not a full OS, making them lightweight.

Why it matters: Thinking images are full OSes leads to unnecessarily large images and inefficient builds.

Quick: Do you think containers automatically update when the base image changes? Commit to yes or no.

Common Belief: Containers update themselves when the base image is updated.

Reality: Containers do not update automatically; you must rebuild and redeploy images to get updates.

Why it matters: Assuming automatic updates can cause security risks and outdated software running in production.

Expert Zone

1

Docker image layers are cached and reused during builds, so changing one line in a Dockerfile can invalidate many layers, affecting build speed.

2

Using volumes for persistent data separates app code from data, which is crucial for stateful applications but often overlooked.

3

Network modes like bridge, host, and overlay affect container communication and security, and choosing the right one is key in complex deployments.

When NOT to use

Docker containerization is not ideal for applications requiring full OS customization or kernel modifications; in such cases, virtual machines or bare-metal deployments are better. Also, for very simple scripts or apps, container overhead might be unnecessary.

Production Patterns

In production, NestJS apps are often containerized with multi-stage builds for small images, use environment variables for configuration, connect to databases via Docker networks, and are orchestrated with Kubernetes or Docker Swarm for scaling and reliability.

Connections

Virtual Machines

Related but different technology for isolation and deployment

Understanding the difference between containers and VMs clarifies tradeoffs in resource use, startup time, and security.

Continuous Integration/Continuous Deployment (CI/CD)

Docker images are often built and tested automatically in CI/CD pipelines

Knowing Docker helps automate app delivery, making deployments faster and less error-prone.

Shipping and Logistics

Both involve packaging and transporting goods reliably

Seeing Docker containers as shipping containers helps grasp the importance of standardization and isolation in software delivery.

Common Pitfalls

#1 Not specifying the correct working directory in Dockerfile causes build failures.

Wrong approach:

FROM node:18
COPY . .
RUN npm install
CMD ["npm", "start"]

Correct approach:

FROM node:18
WORKDIR /app
COPY . .
RUN npm install
CMD ["npm", "start"]

Root cause:

Without setting WORKDIR, commands run in the root directory, so dependencies and files may not be found.

#2 Exposing ports in Dockerfile but not mapping them when running container makes app unreachable.

Wrong approach:

docker run my-nestjs-app

Correct approach:

docker run -p 3000:3000 my-nestjs-app

Root cause:

EXPOSE only documents ports; actual port mapping must be done at runtime.

#3 Including node_modules in the Docker image build context causes large images and slow builds.

Wrong approach:

COPY ./node_modules ./node_modules

Correct approach:

COPY package*.json ./
RUN npm install
COPY . .

Root cause:

node_modules should be installed inside the container to match the environment and avoid copying unnecessary files.

Key Takeaways

Docker containerization packages your app and its environment into a portable, consistent unit that runs anywhere Docker is installed.

Images are blueprints; containers are running instances created from those blueprints.

Writing a Dockerfile carefully controls what goes into your container, ensuring your NestJS app runs reliably.

Understanding container internals like namespaces and cgroups explains why containers are lightweight and efficient.

Avoid common mistakes like missing WORKDIR or port mappings to prevent build and runtime errors.

Practice

1. What is the main purpose of using Docker with a NestJS application?

easy

A. To replace the need for a database in the app

B. To package the app and its environment so it runs the same everywhere

C. To write the NestJS application code faster

D. To automatically generate API documentation

Solution

1. Step 1: Understand Docker's role

   Docker packages an app with all its dependencies and environment settings.

2. Step 2: Apply to NestJS context

   This means the NestJS app runs consistently on any machine with Docker.

3. Final Answer:

   To package the app and its environment so it runs the same everywhere -> Option B

4. Quick Check:

   Docker ensures consistent app environment [OK]

Hint: Docker ensures app runs same everywhere by packaging environment [OK]

Common Mistakes:

• Thinking Docker speeds up coding
• Confusing Docker with database tools
• Assuming Docker auto-generates docs

2. Which of the following is the correct first line in a Dockerfile for a NestJS app using Node 18?

easy

A. USE node@18

B. RUN node install 18

C. FROM node:18-alpine

D. INSTALL node version 18

Solution

1. Step 1: Identify Dockerfile base image syntax

   The Dockerfile starts with FROM followed by the image name and tag.

2. Step 2: Match Node 18 Alpine image

   Correct syntax is 'FROM node:18-alpine' to use Node 18 on Alpine Linux.

3. Final Answer:

   FROM node:18-alpine -> Option C

4. Quick Check:

   Dockerfile base image starts with FROM [OK]

Hint: Dockerfile base image line always starts with FROM [OK]

Common Mistakes:

• Using RUN or INSTALL instead of FROM
• Incorrect syntax like USE node@18
• Confusing Dockerfile commands with shell commands

3. Given this Dockerfile snippet for a NestJS app:

FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
CMD ["npm", "run", "start"]

What happens when you build and run this container?

medium

A. The container fails because 'COPY' is used incorrectly

B. The container runs but does not start the app

C. The app runs but without installing dependencies

D. The app installs dependencies and starts with 'npm run start'

Solution

1. Step 1: Analyze Dockerfile commands

   WORKDIR sets folder, COPY copies package files, RUN installs dependencies, COPY copies rest, CMD starts app.

2. Step 2: Understand container behavior

   Dependencies are installed before copying source, then app starts with 'npm run start'.

3. Final Answer:

   The app installs dependencies and starts with 'npm run start' -> Option D

4. Quick Check:

   RUN npm install before CMD start [OK]

Hint: RUN npm install before CMD starts app means dependencies installed [OK]

Common Mistakes:

• Thinking COPY package*.json copies whole app
• Assuming dependencies install after app start
• Confusing CMD with RUN commands

4. You wrote this Dockerfile for your NestJS app:

FROM node:18-alpine
WORKDIR /app
COPY . .
RUN npm install
CMD ["npm", "start"]

But when running the container, the app crashes with 'Cannot find module'. What is the likely problem?

medium

A. You copied all files before running npm install, causing missing dependencies

B. The CMD syntax is incorrect and should be a string, not array

C. You forgot to expose the app port in Dockerfile

D. Node 18-alpine image does not support NestJS apps

Solution

1. Step 1: Check COPY and RUN order

   COPY . . copies all files including node_modules if present, then RUN npm install may overwrite or fail.

2. Step 2: Understand missing module cause

   If dependencies are not installed properly before copying, app modules may be missing causing crash.

3. Final Answer:

   You copied all files before running npm install, causing missing dependencies -> Option A

4. Quick Check:

   Order of COPY and RUN npm install matters [OK]

Hint: Run npm install before copying full source to avoid missing modules [OK]

Common Mistakes:

• Blaming CMD syntax for module errors
• Ignoring port exposure as cause
• Assuming Node 18-alpine is incompatible

5. You want to optimize your NestJS Dockerfile to reduce build time by caching dependencies. Which Dockerfile order is best?

hard

A. COPY package*.json ./ then RUN npm install then COPY . . then CMD start

B. COPY . . then RUN npm install then CMD start

C. RUN npm install then COPY package*.json ./ then COPY . . then CMD start

D. CMD start then COPY package*.json ./ then RUN npm install then COPY . .

Solution

1. Step 1: Understand Docker layer caching

   Docker caches layers; copying package files and installing dependencies first caches npm install step.

2. Step 2: Apply best practice order

   Copy package*.json, run npm install, then copy rest of source to avoid reinstalling dependencies on code changes.

3. Final Answer:

   COPY package*.json ./ then RUN npm install then COPY . . then CMD start -> Option A

4. Quick Check:

   Cache dependencies by copying package files first [OK]

Hint: Copy package files first to cache npm install step [OK]

Common Mistakes:

• Copying all files before npm install wastes cache
• Running npm install before copying package files
• Placing CMD before install steps