Docker containerization for Node.js in Node.js - Step-by-Step Execution

Concept Flow - Docker containerization for Node.js

Write Node.js app

↓

Create Dockerfile

↓

Build Docker image

↓

Run Docker container

↓

App runs isolated inside container

This flow shows how you start with a Node.js app, create a Dockerfile, build an image, then run it as a container where the app runs isolated.

Execution Sample

Node.js

FROM node:18
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
CMD ["node", "index.js"]

This Dockerfile sets up a Node.js 18 environment, installs dependencies, copies app files, and runs the app with node index.js.

Execution Table

Step	Action	Details	Result
1	Read Dockerfile	FROM node:18	Base image node:18 pulled or used
2	Set working directory	WORKDIR /app	Working directory inside container set to /app
3	Copy package files	COPY package*.json ./	package.json and package-lock.json copied to /app
4	Install dependencies	RUN npm install	npm installs packages inside container
5	Copy app files	COPY . .	All app files copied to /app
6	Set start command	CMD ["node", "index.js"]	Container will run node index.js on start
7	Build image	docker build -t my-node-app .	Docker image 'my-node-app' created
8	Run container	docker run -p 3000:3000 my-node-app	Container runs app, port 3000 exposed
9	App runs	Node.js app listens on port 3000	App accessible at localhost:3000

💡 Execution stops after container runs and app is accessible

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	Final
Working Directory	undefined	/app	/app	/app	/app
Files in /app	empty	package.json, package-lock.json	package.json, package-lock.json, node_modules	all app files including index.js	all app files including index.js
Docker Image	none	base node:18	with dependencies installed	with app files copied	final image ready
Container State	not running	not running	not running	not running	running with app listening on port 3000

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 rows 3 and 4).

What happens if the CMD line is missing in the Dockerfile?

Without CMD, the container starts but does not run the Node.js app automatically, so the app won't run (see execution_table row 6).

Why do we map ports with -p 3000:3000 when running the container?

Port mapping exposes the container's internal port 3000 to the host machine's port 3000, making the app accessible outside the container (see execution_table row 8).

Visual Quiz - 3 Questions

Look at the execution_table, what files exist in /app after step 5?

A Only package.json and package-lock.json

B Only node_modules folder

C All app files including index.js

D Empty directory

💡 Hint

Check 'Files in /app' in variable_tracker after Step 5

At which step does the container start running the Node.js app?

A Step 8

B Step 6

C Step 4

D Step 9

💡 Hint

Look at execution_table rows describing 'Run container' and 'App runs'

If we skip copying package.json before npm install, what changes in the execution?

A npm install will run faster

B Docker cache for npm install won't work, slowing rebuilds

C App files won't be copied

D Container won't start

💡 Hint

Refer to key_moments about copying package.json before npm install

Concept Snapshot

Docker containerization for Node.js:
- Write your Node.js app
- Create a Dockerfile starting FROM node base image
- COPY package.json, RUN npm install
- COPY app files
- CMD to run node index.js
- Build image with docker build
- Run container with docker run -p hostPort:containerPort
- App runs isolated, accessible via mapped port

Full Transcript

Docker containerization for Node.js involves creating a Dockerfile that starts from a Node.js base image. You set a working directory inside the container, copy package.json files first, then run npm install to install dependencies. Next, you copy all your app files into the container. The CMD instruction tells Docker how to start your app, usually with 'node index.js'. You build the Docker image using 'docker build' and then run it with 'docker run', mapping the container's port to your host machine so you can access the app. This process isolates your app environment and makes it easy to run anywhere Docker is installed.