Docker containerization in Express - Mini Project: Build & Apply

Docker containerization

📖 Scenario: You are building a simple Express.js web server that responds with a greeting message. You want to package this server inside a Docker container so it can run anywhere easily.

🎯 Goal: Create a basic Express.js app, configure it to listen on a port, write a Dockerfile to containerize the app, and add the final Docker command to run the container.

📋 What You'll Learn

Create an Express.js app with a single route '/' that sends 'Hello from Docker!'

Set the app to listen on port 3000

Write a Dockerfile that uses the official Node.js image, copies app files, installs dependencies, and exposes port 3000

Add the Docker command to run the container mapping port 3000

💡 Why This Matters

🌍 Real World

Docker helps developers package apps with all dependencies so they run the same everywhere, like on your laptop, a server, or cloud.

💼 Career

Knowing Docker containerization is essential for modern backend development, deployment, and DevOps roles.

1

Create the Express.js app

Create a file app.js with an Express.js app that imports express, creates an app instance, and sets a route '/' that sends the text 'Hello from Docker!'.

Express

// Your code here to create the Express app with route '/'

Hint

Use require('express') to import Express. Create an app with express(). Use app.get to define the route.

2

Set the app to listen on port 3000

Add a line to make the Express app listen on port 3000 using app.listen(3000).

Express

const express = require('express');
const app = express();

app.get('/', (req, res) => {
  res.send('Hello from Docker!');
});

// Add app.listen on port 3000 below

Hint

Use app.listen(3000) to start the server on port 3000.

3

Write the Dockerfile to containerize the app

Create a Dockerfile with these lines: FROM node:18, WORKDIR /app, COPY . ., RUN npm install express, EXPOSE 3000, and CMD ["node", "app.js"].

Express

# Your Dockerfile content here

Hint

Use the official Node.js 18 image. Set working directory, copy all files, install express, expose port 3000, and set the command to run app.js.

4

Add the Docker run command

Write the Docker command to run the container named my-express-app mapping host port 3000 to container port 3000 using docker run -p 3000:3000 --name my-express-app and the image name my-express-image.

Express

# Your Docker run command here

Hint

Use docker run with -p 3000:3000 to map ports and --name my-express-app to name the container.

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