AI-Generated Content

This exam was created by a large language model. Please use it with caution, as inaccuracies may be present. Always verify critical information.

In the context of Docker, what fundamentally constitutes a 'layer'?

Select one option

A single instruction in a Dockerfile that modifies the filesystem.

The final executable image of an application.

A virtual machine running inside a container.

A network interface connecting containers.

Briefly explain how Docker's build cache works and why its effective utilization is crucial for speeding up Docker image builds.

Consider a common, inefficient Dockerfile practice where all application source code is copied into the image before any dependencies are installed (e.g., COPY . . followed by RUN npm install). Explain why this specific ordering frequently leads to cache invalidation issues, even when only a small part of the source code changes.

Dockerfile for a Node.js application (Problematic)

FROM node:18-alpine WORKDIR /app

This copies all application files into the image

COPY . .

This installs dependencies based on package.json, which is already in the image

RUN npm install

Expose port and start the application

EXPOSE 3000 CMD ["node", "src/index.js"]

Examine the provided Dockerfile. Identify the primary instruction and its placement that causes frequent Docker build cache invalidation, especially during development cycles where application code changes often but dependencies remain stable.

Rewrite the Dockerfile snippet starting from WORKDIR to EXPOSE to optimize for Docker build cache utilization. Ensure that dependency installation is cached effectively even when application source code changes. You can assume package.json and package-lock.json are in the root of the build context and src/index.js is the entry point.

Explain the main benefit achieved by the optimized layer ordering in the rewritten Dockerfile snippet for a Node.js application.

Dockerfile for a Go application (Single-Stage)

FROM golang:1.20-alpine AS builder WORKDIR /app COPY go.mod go.sum ./ RUN go mod download COPY . . RUN CGO_ENABLED=0 GOOS=linux go build -o myapp ./cmd/server EXPOSE 8080 CMD ["./myapp"]

What is a multi-stage build in Docker, and what are its primary benefits in terms of final image size, security, and separation of concerns?

Rewrite the provided Go Dockerfile using a multi-stage build pattern. The goal is to produce the smallest possible final image that can run the compiled myapp binary. The application's entry point is ./cmd/server and the output binary should be named myapp.

Which of the following scenarios is most likely to benefit significantly from a multi-stage Docker build?

Select one option

A simple static HTML website served by Nginx.

A Python application that uses pip install to add dependencies to the final image.

A Java Spring Boot application compiled into a JAR file, or a C++ application that needs compilation.

A database server (e.g., PostgreSQL) running directly from its official image.

Dockerfile for a React application served by Nginx (Inefficient)

FROM node:18-alpine WORKDIR /app COPY . . RUN npm install RUN npm run build

Now install Nginx and copy build artifacts

RUN apk add --no-cache nginx COPY nginx.conf /etc/nginx/nginx.conf COPY build /usr/share/nginx/html

EXPOSE 80 CMD ["nginx", "-g", "daemon off;"]

10.

The provided Dockerfile for a React application served by Nginx is inefficient in terms of both build cache utilization and final image size. Rewrite this Dockerfile to incorporate both best practices: optimized build cache for the React application and a multi-stage build for a slim final Nginx image. Assume nginx.conf is in the root of the build context and needs to be placed at /etc/nginx/nginx.conf in the final image.

11.

Compare the expected build time and final image size implications of the initial 'Inefficient' Dockerfile versus your fully optimized one for the React/Nginx application. Focus on why the optimized version is better.