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.

Practice

1. What is the main purpose of using Docker with an Express app?

easy

A. To write the Express app code faster

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

C. To replace the need for Node.js on the host machine

D. To automatically fix bugs in the Express app

Solution

1. Step 1: Understand Docker's role

   Docker packages an app with all its dependencies and environment so it can run consistently on any machine.

2. Step 2: Compare options

   Only To package the app and its environment so it runs the same everywhere describes this packaging and environment consistency purpose. Other options describe unrelated or incorrect uses.

3. Final Answer:

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

4. Quick Check:

   Docker packages app + environment = A [OK]

Hint: Docker ensures app runs same on any machine [OK]

Common Mistakes:

• Thinking Docker writes code
• Believing Docker replaces Node.js installation
• Assuming Docker fixes app bugs automatically

2. Which line correctly sets the base image in a Dockerfile for an Express app using Node.js?

easy

A. BASE node:18-alpine

B. START node:18-alpine

C. IMAGE node:18-alpine

D. FROM node:18-alpine

Solution

1. Step 1: Recall Dockerfile syntax for base image

   The correct Dockerfile command to set the base image is 'FROM'.

2. Step 2: Identify correct option

   Only FROM node:18-alpine uses 'FROM' correctly. Other options use invalid Dockerfile keywords.

3. Final Answer:

   FROM node:18-alpine -> Option D

4. Quick Check:

   Base image line starts with FROM = B [OK]

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

Common Mistakes:

• Using BASE or IMAGE instead of FROM
• Confusing Dockerfile commands with shell commands
• Omitting the version tag in the image name

3. Given this Dockerfile snippet for an Express app:

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

What happens when you run this container?

medium

A. The app listens on port 3000 inside the container

B. The app listens on port 80 inside the container

C. The app will not start because of missing dependencies

D. The container will crash immediately

Solution

1. Step 1: Analyze EXPOSE and CMD instructions

   EXPOSE 3000 means the container listens on port 3000. CMD runs 'node index.js' to start the app.

2. Step 2: Check for dependency installation

   RUN npm install installs dependencies from package.json, so dependencies are present.

3. Final Answer:

   The app listens on port 3000 inside the container -> Option A

4. Quick Check:

   EXPOSE 3000 + CMD node index.js = D [OK]

Hint: EXPOSE shows container port; CMD starts app [OK]

Common Mistakes:

• Assuming default port 80 without EXPOSE
• Thinking dependencies are missing without checking RUN npm install
• Confusing container port with host port

4. You wrote this Dockerfile for your Express app:

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

But when you build and run the container, the app crashes with 'Cannot find module'. What is the likely problem?

medium

A. You forgot to copy package-lock.json, so dependencies are incomplete

B. You did not expose the port, so the app crashes

C. You copied only package.json, missing package-lock.json can cause inconsistent installs

D. The CMD syntax is wrong; it should be a string, not an array

Solution

1. Step 1: Check COPY and RUN npm install steps

   Only package.json is copied before npm install. Without package-lock.json, installs may be inconsistent.

2. Step 2: Understand impact on dependencies

   Missing package-lock.json can cause npm install to install wrong or missing modules, leading to 'Cannot find module' errors.

3. Final Answer:

   You copied only package.json, missing package-lock.json can cause inconsistent installs -> Option C

4. Quick Check:

   Missing package-lock.json causes install issues = C [OK]

Hint: Copy both package.json and package-lock.json before npm install [OK]

Common Mistakes:

• Assuming missing EXPOSE causes crashes
• Thinking CMD array syntax is invalid
• Ignoring package-lock.json importance

5. You want to create a Docker container for your Express app that automatically restarts if it crashes and uses environment variables from a file. Which Docker feature combination should you use?

hard

A. Use Docker Compose with restart policy and env_file settings

B. Use a Dockerfile with CMD to restart and ENV to load variables

C. Use docker run with --restart flag and manually set env vars in command

D. Use Docker Swarm with secrets and volumes for env variables

Solution

1. Step 1: Identify restart and env var management

   Docker Compose supports restart policies and loading environment variables from a file via env_file.

2. Step 2: Compare other options

   Dockerfile CMD cannot auto-restart; docker run can restart but managing env vars manually is error-prone; Docker Swarm is more complex and for orchestration, not simple env files.

3. Final Answer:

   Use Docker Compose with restart policy and env_file settings -> Option A

4. Quick Check:

   Restart + env_file = Docker Compose = A [OK]

Hint: Docker Compose handles restart and env files easily [OK]

Common Mistakes:

• Thinking Dockerfile CMD can restart container
• Ignoring restart policies in docker run
• Confusing Docker Swarm with simple container setup