Docker containerization for Node.js in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when this Dockerfile runs?

Consider this Dockerfile for a Node.js app. What will be the output when the container starts?

Node.js

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

A The container runs the Node.js app defined in index.js after installing dependencies.

B The container fails because it does not copy package-lock.json before npm install.

C The container runs but skips npm install because package.json is missing.

D The container runs but uses the default Node.js REPL instead of the app.

💡 Hint

Think about the order of commands and what files are copied before npm install.

The Dockerfile copies package.json first, runs npm install to install dependencies, then copies the rest of the app files. Finally, it runs the app with node index.js.

📝 Syntax

intermediate

Identify the syntax error in this Dockerfile snippet

Which option correctly fixes the syntax error in this Dockerfile snippet?

Node.js

FROM node:20
WORKDIR /app
COPY package.json ./
RUN npm install
COPY . .
CMD node index.js

A Replace COPY . . with COPY ./ ./app

B Add a missing colon after RUN npm install:

C Add a semicolon after WORKDIR /app;

D Change CMD node index.js to CMD ["node", "index.js"]

💡 Hint

Look at how CMD expects its arguments in JSON array format.

CMD should be an array of strings to avoid shell parsing issues. Using CMD ["node", "index.js"] is the correct syntax.

🔧 Debug

advanced

Why does this container fail to start?

This Dockerfile builds a Node.js app but the container fails immediately after starting. What is the cause?

Node.js

FROM node:20
WORKDIR /app
COPY . .
RUN npm install
CMD ["node", "server.js"]

A COPY . . copies files after npm install, so node_modules is overwritten.

B npm install runs before copying package.json, so dependencies are missing.

C The CMD command is missing the shell form, causing a syntax error.

D The working directory /app does not exist, causing a runtime error.

💡 Hint

Consider the order of COPY and RUN commands and what files get overwritten.

Since COPY . . happens before npm install, node_modules is created. But if COPY . . happens after npm install, it overwrites node_modules, causing missing dependencies.

❓ state_output

advanced

What is the value of NODE_ENV inside the container?

Given this Dockerfile snippet, what will be the value of the environment variable NODE_ENV inside the running container?

Node.js

FROM node:20
ENV NODE_ENV=production
WORKDIR /app
COPY package.json ./
RUN npm install
COPY . .
CMD ["node", "app.js"]

A "NODE_ENV"

B undefined

C "production"

D "development"

💡 Hint

Look at the ENV instruction and how environment variables are set in Dockerfiles.

The ENV instruction sets NODE_ENV to "production" for all subsequent instructions and the running container.

🧠 Conceptual

expert

Which Dockerfile layering strategy optimizes build speed for Node.js apps?

To speed up Docker builds for a Node.js app, which layering order is best?

A Copy package.json and package-lock.json, run npm install, then copy app source files.

B Copy all source files first, then run npm install.

C Run npm install before copying any files.

D Copy only node_modules folder, then copy source files.

💡 Hint

Think about which files change frequently and which don't.

Copying package.json and package-lock.json first and running npm install caches dependencies. Then copying source files avoids reinstalling dependencies if only source changes.

Practice

1. What is the main purpose of using Docker with a Node.js application?

easy

A. To make the app run only on Windows machines

B. To write Node.js code faster

C. To replace the need for npm packages

D. To package the app and its environment so it runs consistently anywhere

Solution

1. Step 1: Understand Docker's role

   Docker packages an app with everything it needs to run, including system libraries and settings.

2. Step 2: Apply this to Node.js apps

   This means your Node.js app will behave the same on any machine with Docker installed.

3. Final Answer:

   To package the app and its environment so it runs consistently anywhere -> Option D

4. Quick Check:

   Docker ensures consistent app environment = A [OK]

Hint: Docker bundles app + environment for consistent runs [OK]

Common Mistakes:

• Thinking Docker speeds up coding
• Believing Docker replaces npm
• Assuming Docker limits OS compatibility

2. Which of the following is the correct first line in a Dockerfile for a Node.js app using Node version 18?

easy

A. FROM node:18

B. RUN node 18

C. INSTALL node@18

D. USE node version 18

Solution

1. Step 1: Identify Dockerfile syntax for base image

   The Dockerfile starts with FROM followed by the image name and tag, e.g., node:18.

2. Step 2: Check options for correct syntax

   Only 'FROM node:18' correctly specifies the base image for Node.js version 18.

3. Final Answer:

   FROM node:18 -> Option A

4. Quick Check:

   Dockerfile base image starts with FROM = B [OK]

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

Common Mistakes:

• Using RUN instead of FROM for base image
• Writing INSTALL which is not a Dockerfile command
• Using USE which is invalid in Dockerfile

3. Given this Dockerfile snippet:

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

What happens when you build and run this container?

medium

A. The container fails because CMD syntax is wrong

B. The container runs the Node.js app starting at index.js after installing dependencies

C. The container runs npm install every time it starts

D. The container only copies files but does not install dependencies

Solution

1. Step 1: Analyze Dockerfile commands

   WORKDIR sets /app, COPY adds package.json, RUN npm install installs dependencies, COPY . . adds all files, CMD runs node index.js.

2. Step 2: Understand build vs run behavior

   npm install runs during build, so dependencies are ready when container runs. CMD starts the app.

3. Final Answer:

   The container runs the Node.js app starting at index.js after installing dependencies -> Option B

4. Quick Check:

   RUN npm install during build, CMD runs app = D [OK]

Hint: RUN commands execute at build, CMD runs app at container start [OK]

Common Mistakes:

• Thinking npm install runs at container start
• Believing CMD syntax is invalid
• Assuming dependencies are not installed

4. You wrote this Dockerfile:

FROM node:18
WORKDIR /app
COPY . .
RUN npm install
CMD node index.js

But when you build and run, the app does not start correctly. What is the likely problem?

medium

A. COPY . . should be before FROM node:18

B. WORKDIR should be set after RUN npm install

C. CMD should be an array like ["node", "index.js"] instead of a string

D. npm install should be RUN npm start

Solution

1. Step 1: Check CMD syntax

   CMD can be a string or array, but string form runs via shell which can cause issues. Array form is recommended for direct exec.

2. Step 2: Identify best practice for Node.js Dockerfiles

   Using CMD ["node", "index.js"] avoids shell parsing problems and ensures correct app start.

3. Final Answer:

   CMD should be an array like ["node", "index.js"] instead of a string -> Option C

4. Quick Check:

   Use array form for CMD to start Node app correctly = A [OK]

Hint: Use array syntax for CMD to avoid shell issues [OK]

Common Mistakes:

• Placing COPY before FROM
• Confusing RUN npm install with RUN npm start
• Changing WORKDIR order unnecessarily

5. You want to optimize your Node.js Docker image to avoid reinstalling dependencies if only source code changes. Which Dockerfile change helps achieve this?

hard

A. Copy only package.json and package-lock.json first, run npm install, then copy the rest of the app files

B. Run npm install before copying any files

C. Copy all files first, then run npm install

D. Use RUN npm install every time the container starts

Solution

1. Step 1: Understand Docker layer caching

   Docker caches layers; if package.json doesn't change, npm install layer is reused.

2. Step 2: Optimize Dockerfile order

   Copy package.json and package-lock.json first, run npm install, then copy app files to avoid reinstalling dependencies on code changes.

3. Final Answer:

   Copy only package.json and package-lock.json first, run npm install, then copy the rest of the app files -> Option A

4. Quick Check:

   Separate dependency files copy before install = C [OK]

Hint: Copy package files first to cache npm install layer [OK]

Common Mistakes:

• Running npm install before copying files
• Copying all files before npm install
• Running npm install at container start