Why image optimization matters in Docker - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the Dockerfile line to set the base image to Alpine Linux, which is small and efficient.

Docker

FROM [1]

Drag options to blanks, or click blank then click option'

Aalpine:latest

Bubuntu:latest

Cdebian:latest

Dcentos:latest

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing a larger base image like ubuntu increases image size unnecessarily.

Using alpine:latest as the base image helps keep the Docker image small and optimized.

2fill in blank

medium

Complete the Dockerfile command to remove package cache after installing packages to reduce image size.

Docker

RUN apk add --no-cache curl && [1]

Drag options to blanks, or click blank then click option'

Aapt-get clean

Brm -rf /var/lib/apt/lists/*

Crm -rf /var/cache/apk/*

Dyum clean all

Attempts:

3 left

💡 Hint

Common Mistakes

Using commands for other package managers like apt or yum.

In Alpine Linux, /var/cache/apk/ holds package cache. Removing it reduces image size.

3fill in blank

hard

Fix the error in the Dockerfile line to copy only necessary files to keep the image small.

Docker

COPY [1] /app/

Drag options to blanks, or click blank then click option'

A.

Bsrc/

Cnode_modules/

Dbuild/

Attempts:

3 left

💡 Hint

Common Mistakes

Copying the entire current directory (.) adds unnecessary files.

Copying the build/ directory ensures only the compiled app files are included, avoiding unnecessary files like source code or dependencies.

4fill in blank

hard

Fill both blanks to create a multi-stage Dockerfile that builds and then copies only the final app.

Docker

FROM node:16-alpine AS builder
RUN npm install && npm run build
FROM alpine:latest
COPY --from=builder [1] [2]

Drag options to blanks, or click blank then click option'

A/app/build

B/app

C/usr/src/app

D/build

Attempts:

3 left

💡 Hint

Common Mistakes

Copying the entire source directory or wrong paths.

The build output is in /app/build in the builder stage, and it is copied to /app in the final image to keep it small.

5fill in blank

hard

Fill all three blanks to write a Dockerfile snippet that cleans up after installing packages and sets a working directory.

Docker

FROM alpine:latest
RUN apk add --no-cache git [1] && [2]
WORKDIR [3]

Drag options to blanks, or click blank then click option'

Abash

Brm -rf /var/cache/apk/*

C/app

Dcurl

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting to clean cache or setting wrong working directory.

Installing bash adds a shell, cleaning cache reduces image size, and setting /app as working directory organizes files.

Practice

1. Why is it important to keep Docker images small and optimized?

easy

A. Larger images are always more secure

B. Optimized images require more bandwidth

C. Image size does not affect deployment speed

D. Smaller images start faster and use less disk space

Solution

1. Step 1: Understand image size impact on startup

   Smaller images load faster because there is less data to transfer and unpack.

2. Step 2: Understand disk space usage

   Smaller images use less disk space on the host, saving resources.

3. Final Answer:

   Smaller images start faster and use less disk space -> Option D

4. Quick Check:

   Small image = faster start + less space [OK]

Hint: Smaller images = faster start and less space used [OK]

Common Mistakes:

• Thinking bigger images are faster
• Ignoring disk space impact
• Assuming image size doesn't affect deployment

2. Which Dockerfile instruction helps reduce image size by removing unnecessary files?

easy

A. RUN apt-get update

B. RUN rm -rf /var/lib/apt/lists/*

C. COPY . /app

D. EXPOSE 80

Solution

1. Step 1: Identify cleanup commands

   Removing package lists after installation reduces image size.

2. Step 2: Understand the command effect

   RUN rm -rf /var/lib/apt/lists/* deletes cached package files, freeing space.

3. Final Answer:

   RUN rm -rf /var/lib/apt/lists/* -> Option B

4. Quick Check:

   Cleanup commands reduce image size [OK]

Hint: Remove cache files after install to shrink image [OK]

Common Mistakes:

• Using COPY to reduce size (it adds files)
• Exposing ports does not affect size
• Forgetting to clean package caches

3. Given this Dockerfile snippet:

FROM python:3.12-slim
RUN pip install flask
COPY . /app
RUN rm -rf /tmp/*

What is the main benefit of using the python:3.12-slim base image here?

medium

A. It is a smaller image, reducing build time and size

B. It disables network access for security

C. It automatically optimizes Python code

D. It includes all development tools by default

Solution

1. Step 1: Understand base image types

   "slim" images are stripped down versions with fewer packages.

2. Step 2: Identify benefits of slim images

   Smaller base images reduce overall image size and speed up builds.

3. Final Answer:

   It is a smaller image, reducing build time and size -> Option A

4. Quick Check:

   Using slim base = smaller image [OK]

Hint: Slim base images reduce size and speed builds [OK]

Common Mistakes:

• Assuming slim includes all tools
• Thinking slim optimizes code automatically
• Confusing security features with image size

4. You have this Dockerfile snippet:

FROM node:20
RUN npm install
RUN rm -rf node_modules
COPY . /app

What is wrong with this Dockerfile regarding image optimization?

medium

A. The base image node:20 is too small

B. COPY should come before RUN commands always

C. Removing node_modules after install wastes build time and space

D. There is no EXPOSE instruction

Solution

1. Step 1: Analyze the RUN commands order

   Installing then deleting node_modules wastes time and space.

2. Step 2: Understand image layers

   Each RUN creates a layer; deleting files in a later layer does not reduce earlier layer size.

3. Final Answer:

   Removing node_modules after install wastes build time and space -> Option C

4. Quick Check:

   Deleting installed files wastes space [OK]

Hint: Don't delete installed files in later layers [OK]

Common Mistakes:

• Thinking COPY order always matters here
• Assuming base image size is the problem
• Believing EXPOSE affects image size

5. You want to optimize a Docker image for a Python app. Which combination of steps best reduces image size and speeds deployment?

hard

A. Use a slim base image, combine RUN commands, and clean package caches

B. Use a full OS base image and install all development tools

C. Copy all files first, then install packages separately

D. Avoid cleaning caches to speed up builds

Solution

1. Step 1: Choose a slim base image

   Slim images have fewer packages, reducing size.

2. Step 2: Combine RUN commands and clean caches

   Combining commands reduces layers; cleaning caches removes unnecessary files.

3. Final Answer:

   Use a slim base image, combine RUN commands, and clean package caches -> Option A

4. Quick Check:

   Combine steps + slim base = optimized image [OK]

Hint: Combine commands and clean caches for smaller images [OK]

Common Mistakes:

• Using full OS base images unnecessarily
• Not cleaning caches after installs
• Copying files before installing dependencies