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.