Docker & Containerization Mastery Flashcards

Question 1

Docker Image vs. Docker Container

Accepted Answer

A **Docker Image** is a read-only, immutable template containing application code, libraries, and dependencies. A **Docker Container** is a runnable, isolated instance of an image with a thin writable layer added on top.

Question 2

Underlying Linux Technologies for Containers

Accepted Answer

Containers rely on two key Linux kernel features:
- **Namespaces**: Provide process, network, user, and mount point isolation.
- **Control Groups (cgroups)**: Enforce limits and monitor usage of system resources like CPU, memory, and disk I/O.

Question 3

Dockerfile: `CMD` vs. `ENTRYPOINT`

Accepted Answer

- `ENTRYPOINT`: Defines the core executable that always runs when the container starts.
- `CMD`: Provides default arguments to `ENTRYPOINT` or acts as a default command. Can be easily overridden from the command line (e.g., `docker run image <new-cmd>`).

Question 4

Dockerfile: `COPY` vs. `ADD`

Accepted Answer

- `COPY`: Copies local files/directories from the host into the container filesystem. Preferred for basic file copying.
- `ADD`: Inherits `COPY` functionality but also automatically extracts compressed archives (`.tar.gz`) and supports fetching remote URLs.

Question 5

Docker Layer Caching

Accepted Answer

Each instruction in a `Dockerfile` creates a read-only image layer. Docker caches these layers during builds. If an instruction and its context remain unchanged, Docker reuses the cached layer, significantly speeding up subsequent builds.

Question 6

Optimizing Layer Caching Order

Accepted Answer

Order Dockerfile commands from **least frequently changed to most frequently changed**. For example, copy dependency definitions (`package.json`, `requirements.txt`) and run installations *before* copying the application source code.

Question 7

Multi-Stage Builds

Accepted Answer

A technique using multiple `FROM` statements in a single `Dockerfile`. It allows building artifacts in heavyweight temporary stages (with build tools/compilers) and copying only the final binaries/assets into a lean runtime image.

Question 8

Default Bridge Network vs. User-Defined Bridge Network

Accepted Answer

- **Default Bridge**: Containers can only communicate via raw IP addresses unless linked legacy-style.
- **User-Defined Bridge**: Provides automatic DNS resolution, allowing containers on the same network to communicate using their container names.

Question 9

Docker Network Driver: Host Mode

Accepted Answer

Using `--network host` removes network isolation between the container and the Docker host. The container shares the host's IP address and network interfaces directly, offering maximum performance but reduced security isolation.

Question 10

Docker Network Driver: Overlay Mode

Accepted Answer

An **Overlay** network enables distributed communication across multiple Docker daemons/hosts without requiring OS-level routing configuration. It is the primary network type for Docker Swarm and multi-host setups.

Question 11

Volume Types: Named Volumes vs. Bind Mounts

Accepted Answer

- **Named Volumes**: Managed entirely by Docker in host storage (`/var/lib/docker/volumes/`). Ideal for persistent data independent of host path structures.
- **Bind Mounts**: Maps a specific file or directory from anywhere on the host filesystem directly into the container.

Question 12

Volume Types: `tmpfs` Mounts

Accepted Answer

A **tmpfs mount** stores container data in the host system's memory (RAM) instead of writing to disk. It is volatile and useful for storing sensitive information (e.g., keys) or transient high-performance data.

Question 13

Dangling Images vs. Unused Images

Accepted Answer

- **Dangling Images**: Untagged images created during builds, appearing as `:`. - **Unused Images**: Images that are tagged but not currently referenced by any active or stopped container. Clean both using `docker image prune`.

Question 14

Dockerfile Instruction: `EXPOSE`

Accepted Answer

Functions as metadata documentation indicating which ports the application inside the container listens on. It **does not** actually publish or map the port on the host network; that requires the `-p` or `-P` flag during `docker run`.

Question 15

Dockerfile Instruction: `WORKDIR`

Accepted Answer

Sets the working directory for subsequent commands (`RUN`, `CMD`, `ENTRYPOINT`, `COPY`, `ADD`). If the directory does not exist, Docker creates it automatically.

Question 16

Docker Compose Purpose

Accepted Answer

A tool used to define, configure, and manage multi-container Docker applications using a declarative YAML configuration file (`docker-compose.yml`).

Question 17

Docker Compose: `depends_on` Limitation

Accepted Answer

`depends_on` controls the startup and shutdown **order** of containers, but it does **not** wait for a container to be "ready" (e.g., database accepting connections) before starting the dependent container unless paired with a healthcheck.

Question 18

Container Healthcheck (`HEALTHCHECK`)

Accepted Answer

An instruction in a `Dockerfile` or `docker-compose.yml` that periodically runs a command inside the container (e.g., `curl -f http://localhost/`) to test whether the containerized service is functionally healthy.

Question 19

Docker Architecture: Client-Server Model

Accepted Answer

Docker operates on a client-server architecture. The `docker` CLI (client) communicates with the `dockerd` (Docker Daemon) via a REST API over UNIX sockets or a network interface to perform operations like building, running, and managing containers.

Question 20

Publishing Ports (`-p host:container`)

Accepted Answer

The `-p host_port:container_port` option binds a port on the host machine to a port inside the container network namespace (e.g., `-p 8080:80` maps host port `8080` to container port `80`).

Docker & Containerization Mastery

Cards in this deck

Related Flashcard Sets

JLPT N4 - Grammar Patterns & Kanji

German B1 - Intermediate Grammar & Vocabulary

Kubernetes Fundamentals & Orchestration

CFA Level I - Ethical and Professional Standards