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.