Development vs production Dockerfiles - Practice Questions

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why use separate Dockerfiles for development and production?

Which reason best explains why developers create separate Dockerfiles for development and production environments?

A To use the same image for both environments without any changes.

B To include debugging tools and live reload features only in development images.

C To ensure production images always contain source code for easier debugging.

D To reduce the size of the development image by removing unnecessary tools.

💡 Hint

Think about what features are useful during coding but not needed in production.

Development Dockerfiles often include tools like debuggers and live reload to help developers. Production Dockerfiles exclude these to keep images small and secure.

💻 Command Output

intermediate

Output difference between development and production Docker images

Given two Dockerfiles, one for development and one for production, which output shows the correct difference when running docker images after building both?

Docker

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

Dockerfile.prod:
FROM node:18
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
CMD ["node", "server.js"]

A

REPOSITORY          TAG       SIZE
myapp               dev       800MB
myapp               prod      800MB

B

REPOSITORY          TAG       SIZE
myapp               prod      800MB
myapp               dev       400MB

C

REPOSITORY          TAG       SIZE
myapp               dev       400MB
myapp               prod      400MB

D

REPOSITORY          TAG       SIZE
myapp               dev       800MB
myapp               prod      400MB

💡 Hint

Consider that development images usually have more tools and dependencies.

The development image is larger because it includes all dependencies and tools for development. The production image is smaller because it installs only production dependencies.

❓ Configuration

advanced

Identify the production Dockerfile snippet

Which Dockerfile snippet is best suited for a production environment to optimize image size and security?

A

FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
CMD ["node", "server.js"]

B

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

C

FROM node:18
WORKDIR /app
COPY . .
RUN npm install
CMD ["npm", "start"]

D

FROM node:18
WORKDIR /app
COPY package*.json ./
RUN npm install --production=false
COPY . .
CMD ["node", "server.js"]

💡 Hint

Look for a lightweight base image and installation of only production dependencies.

Using a lightweight base like alpine and installing only production dependencies reduces image size and attack surface, ideal for production.

❓ Troubleshoot

advanced

Why does the production container fail to start?

A production Docker container built with this Dockerfile fails immediately after starting. What is the most likely cause?

FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
CMD ["npm", "run", "dev"]

A COPY commands are in the wrong order, so source code is missing.

B The base image node:18-alpine does not support npm commands.

C The command 'npm run dev' is missing in production dependencies, causing failure.

D The WORKDIR is not set, so the command runs in the wrong directory.

💡 Hint

Check if the command used is available in production dependencies.

'npm run dev' usually requires development dependencies which are not installed with '--only=production', so the command fails.

✅ Best Practice

expert

Choose the best multi-stage Dockerfile for development and production

Which multi-stage Dockerfile correctly separates development and production stages to optimize build time and image size?

Docker

Stage 1: Build
FROM node:18 AS build
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

Stage 2: Production
FROM node:18-alpine
WORKDIR /app
COPY --from=build /app/dist ./dist
COPY package*.json ./
RUN npm ci --only=production
CMD ["node", "dist/server.js"]

Stage 3: Development
FROM node:18
WORKDIR /app
COPY . .
RUN npm install
CMD ["npm", "run", "dev"]

A Use Stage 3 for development and Stage 2 for production.

B Use Stage 1 for development and Stage 2 for production.

C Use Stage 2 for development and Stage 1 for production.

D Use Stage 3 for production and Stage 1 for development.

💡 Hint

Consider which stages include dev tools and which produce minimal production images.

Stage 3 includes full source and dev tools for development. Stage 2 copies only built files and installs production dependencies for a small production image.

Practice

1. Why do we use separate Dockerfiles for development and production environments?

easy

A. Because development needs debugging tools and production needs optimized images

B. Because production requires more debugging tools than development

C. Because development images must be smaller than production images

D. Because production Dockerfiles always include all source code

Solution

1. Step 1: Understand development Dockerfile purpose

   Development Dockerfiles include debugging tools and full dependencies to help developers test and debug easily.

2. Step 2: Understand production Dockerfile purpose

   Production Dockerfiles are optimized for smaller size, speed, and security, removing unnecessary tools.

3. Final Answer:

   Because development needs debugging tools and production needs optimized images -> Option A

4. Quick Check:

   Separate Dockerfiles fit different environment needs [OK]

Hint: Dev needs tools; prod needs speed and security [OK]

Common Mistakes:

• Thinking production needs more debugging tools
• Assuming development images must be smaller
• Believing production always includes all source code

2. Which of the following is a correct way to specify a base image in a production Dockerfile?

easy

A. BASE node:alpine

B. FROM node:latest

C. FROM alpine:node

D. FROM node:alpine

Solution

1. Step 1: Identify correct Dockerfile syntax for base image

   The correct keyword to specify a base image is 'FROM', followed by the image name and tag.

2. Step 2: Choose a lightweight base image for production

   For production, 'node:alpine' is a lightweight image suitable for smaller, optimized containers.

3. Final Answer:

   FROM node:alpine -> Option D

4. Quick Check:

   Use 'FROM' and lightweight image for production [OK]

Hint: Use 'FROM' and lightweight tags like alpine for production [OK]

Common Mistakes:

• Using 'BASE' instead of 'FROM'
• Incorrect image name order like 'alpine:node'
• Using 'latest' tag for production images

3. Given this production Dockerfile snippet:

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

What is the main effect of the npm install --production command?

medium

A. Installs all dependencies including devDependencies

B. Installs no dependencies at all

C. Installs only production dependencies, skipping devDependencies

D. Installs only devDependencies

Solution

1. Step 1: Understand npm install --production flag

   The '--production' flag tells npm to install only dependencies needed for running the app, skipping devDependencies used for development.

2. Step 2: Relate to production Dockerfile purpose

   Skipping devDependencies reduces image size and improves security for production environments.

3. Final Answer:

   Installs only production dependencies, skipping devDependencies -> Option C

4. Quick Check:

   npm install --production = only production deps [OK]

Hint: npm install --production skips devDependencies [OK]

Common Mistakes:

• Assuming it installs all dependencies
• Thinking it installs no dependencies
• Confusing devDependencies with production dependencies

4. You have a development Dockerfile that installs extra debugging tools but your production image is unexpectedly large. What is a likely cause?

medium

A. You used the development Dockerfile to build the production image

B. You forgot to copy source code in production Dockerfile

C. You used a smaller base image in production

D. You ran npm install without --production flag in development

Solution

1. Step 1: Identify cause of large production image

   If the production image is large, it may include unnecessary development tools and dependencies.

2. Step 2: Check which Dockerfile was used for production build

   Using the development Dockerfile for production will include extra tools, increasing image size.

3. Final Answer:

   You used the development Dockerfile to build the production image -> Option A

4. Quick Check:

   Wrong Dockerfile causes large production image [OK]

Hint: Use correct Dockerfile for each environment [OK]

Common Mistakes:

• Assuming missing source code causes large image
• Thinking smaller base image increases size
• Confusing npm install flags in development

5. You want to create a multi-stage Dockerfile that uses a full Node.js image for development and a lightweight Alpine image for production. Which snippet correctly achieves this?

hard

A. FROM node:alpine AS build
WORKDIR /app
COPY . .
RUN npm install
FROM node:alpine
COPY --from=build /app .
CMD ["node", "server.js"]

B. FROM node:latest AS build
WORKDIR /app
COPY . .
RUN npm install
FROM node:alpine
COPY --from=build /app .
CMD ["node", "server.js"]

C. FROM node:alpine AS build
WORKDIR /app
COPY . .
RUN npm install --production
FROM node:latest
COPY --from=build /app .
CMD ["node", "server.js"]

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

Solution

1. Step 1: Identify multi-stage build structure

   The first stage uses a full Node.js image (node:latest) for building with all tools, suitable for development.

2. Step 2: Use lightweight Alpine image for final production stage

   The second stage uses node:alpine to copy only necessary files from build stage, creating a smaller production image.

3. Step 3: Verify correct order and commands

   FROM node:latest AS build WORKDIR /app COPY . . RUN npm install FROM node:alpine COPY --from=build /app . CMD ["node", "server.js"] correctly uses 'AS build' for first stage and copies from it to the lightweight image.

4. Final Answer:

   FROM node:latest AS build WORKDIR /app COPY . . RUN npm install FROM node:alpine COPY --from=build /app . CMD ["node", "server.js"] -> Option B

5. Quick Check:

   Multi-stage: full image build + alpine production [OK]

Hint: Use full image first, then alpine with COPY --from=build [OK]

Common Mistakes:

• Using alpine for build stage losing dev tools
• Using latest image for final production stage
• Not using multi-stage COPY syntax