Docker containerization in Express - Step-by-Step Execution

Concept Flow - Docker containerization

Write Dockerfile

↓

Build Docker Image

↓

Run Docker Container

↓

Container runs Express app

↓

App listens on port

↓

Access app via browser or API client

This flow shows how you write a Dockerfile, build an image, run a container, and access the Express app inside.

Execution Sample

Express

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

This Dockerfile sets up a Node.js environment, installs dependencies, copies app files, and runs the Express app.

Execution Table

Step	Action	Details	Result
1	Read Dockerfile	FROM node:18	Base image node:18 selected
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 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-express-app .	Docker image 'my-express-app' created
8	Run container	docker run -p 3000:3000 my-express-app	Container runs, app listens on port 3000
9	Access app	Open browser at localhost:3000	Express app responds with expected output
10	Exit	Stop container	Container stops running

💡 Container stops when user stops it or system shuts down

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	After Step 8	Final
Docker Image	None	Base node:18 image	Image with dependencies installed	Image with app files	Image running container	Image remains built
Container	None	None	None	None	Running Express app on port 3000	Stopped

Key Moments - 3 Insights

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

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

What does the CMD instruction do in the Dockerfile?

CMD sets the default command to run when the container starts, here it runs 'node index.js' to start the Express app. See execution_table row 6.

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

Port mapping connects the container's internal port 3000 to the host's port 3000, allowing access from outside. See execution_table row 8.

Visual Quiz - 3 Questions

Look at the execution_table, what happens at step 4?

A Install dependencies inside container

B Copy app files to container

C Set working directory

D Run the Express app

💡 Hint

Check the 'Action' and 'Details' columns at step 4 in execution_table

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

A Step 6

B Step 8

C Step 7

D Step 9

💡 Hint

Look for 'Run container' and 'app listens on port 3000' in execution_table

If you change the port mapping to '-p 4000:3000', what changes in the execution?

A App listens on port 4000 inside container

B App listens on port 3000 on host

C App accessible at localhost:4000 on host

D No change in access port

💡 Hint

Port mapping '-p hostPort:containerPort' controls host access port, see execution_table step 8

Concept Snapshot

Docker containerization for Express apps:
- Write a Dockerfile with base node image
- Copy package.json, run npm install
- Copy app files, set CMD to start app
- Build image with 'docker build'
- Run container with port mapping
- Access app via mapped port

Full Transcript

Docker containerization involves writing a Dockerfile that defines the environment for your Express app. The Dockerfile 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. You build this Dockerfile into an image using 'docker build'. Then you run a container from this image, mapping the container's port 3000 to your computer's port 3000. This allows you to access the Express app in a browser or API client at localhost:3000. The container runs the app until you stop it. Key points include copying package.json before npm install to use caching, CMD sets the start command, and port mapping enables external access.