Docker containerization in NestJS - Step-by-Step Execution

Concept Flow - Docker containerization

Write Dockerfile

↓

Build Docker Image

↓

Run Docker Container

↓

NestJS App Runs Inside Container

↓

Access App via Port Mapping

↓

Container Stops or Restart

This flow shows how a NestJS app is containerized: writing a Dockerfile, building an image, running a container, and accessing the app.

Execution Sample

NestJS

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

This Dockerfile sets up a NestJS app environment, installs dependencies, copies code, builds the app, and starts the app in production mode.

Execution Table

Step	Action	Details	Result
1	Read Dockerfile	FROM node:18-alpine	Base image set to Node 18 Alpine
2	Set working directory	WORKDIR /app	Working directory inside container is /app
3	Copy package files	COPY package*.json ./	package.json and package-lock.json copied
4	Install dependencies	RUN npm install	Node modules installed inside container
5	Copy app code	COPY . .	All app files copied into /app
6	Build app	RUN npm run build	NestJS app compiled to /app/dist
7	Set start command	CMD ["npm", "run", "start:prod"]	Container will run NestJS app in production
8	Build image	docker build -t nestjs-app .	Docker image 'nestjs-app' created
9	Run container	docker run -p 3000:3000 nestjs-app	Container runs, app accessible on localhost:3000
10	Access app	Open browser at http://localhost:3000	NestJS app responds to requests
11	Stop container	Ctrl+C or docker stop	Container stops running

💡 Container stops when user stops it or system shuts down

Variable Tracker

Variable	Start	After Step 3	After Step 5	After Step 9	Final
Docker Image	None	Base image set	App code added	Image built	Image ready to run
Container	None	None	None	Running with app	Stopped or running

Key Moments - 3 Insights

Why do we copy package.json files before running npm install?

Copying package.json first allows Docker to cache npm install step if dependencies don't change, speeding up rebuilds (see execution_table step 3 and 4).

What does the CMD instruction do in the Dockerfile?

CMD sets the command to run when the container starts, here it runs the NestJS app in production mode (see execution_table step 7).

Why map port 3000 in docker run command?

Port mapping (-p 3000:3000) connects container's port 3000 to host's port 3000, so you can access the app from your browser (see execution_table step 9 and 10).

Visual Quiz - 3 Questions

Look at the execution table, at which step is the NestJS app code copied into the Docker image?

A Step 3

B Step 4

C Step 5

D Step 6

💡 Hint

Check the 'Action' and 'Details' columns for copying app code.

At which step does the container start running the NestJS app?

A Step 9

B Step 7

C Step 8

D Step 6

💡 Hint

Look for 'Run container' action in the execution table.

If you forget to map port 3000 in the docker run command, what happens?

A You can still access the app on localhost:3000

B You cannot access the app from your host machine

C The container will not start

D The app runs on a different port automatically

💡 Hint

Refer to step 9 and 10 about port mapping and app access.

Concept Snapshot

Docker containerization for NestJS:
- Write a Dockerfile with base image, copy files, install dependencies
- Build image with 'docker build'
- Run container with port mapping 'docker run -p host:container'
- Container runs NestJS app isolated
- Access app via mapped port on host
- Stop container when done

Full Transcript

Docker containerization for a NestJS app involves creating a Dockerfile that starts from a Node.js base image, sets a working directory, copies package files, installs dependencies, copies the app code, and sets the command to run the app. The Docker image is built using 'docker build', then run with 'docker run' including port mapping to access the app from the host machine. The container runs the NestJS app isolated from the host environment. You can access the app in a browser via the mapped port. The container stops when you stop it manually or the system shuts down.

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