Docker & Containers MCQ

What is a Docker container?

What is a Docker image?

Which command is used to build a Docker image from a Dockerfile?

What is the purpose of a Dockerfile?

Which command starts a new container from an image?

What does the "docker ps" command show?

What is the FROM instruction in a Dockerfile used for?

What does the Dockerfile instruction "COPY" do?

What is the difference between the Dockerfile "CMD" and "ENTRYPOINT" instructions, at a basic level?

What does "docker stop" do to a running container?

What is the purpose of "docker rm"?

What is the purpose of "docker rmi"?

What is Docker Hub?

What does "docker pull" do?

What is the purpose of port mapping with "docker run -p 8080:80"?

What does the "-d" flag do when used with "docker run -d"?

What is a "volume" in Docker used for?

What does "docker exec -it <container> bash" do?

What is the default isolation mechanism that allows multiple containers to run on the same host without interfering with each other's processes and filesystems?

What is the purpose of a ".dockerignore" file?

What does "docker-compose" (or "docker compose") primarily help you do?

In a "docker-compose.yml" file, what does the "services" key represent?

What is the purpose of the "EXPOSE" instruction in a Dockerfile?

What is a "tag" in the context of a Docker image, e.g. "nginx:1.25"?

What command shows logs output from a running container?

What is the difference between a Docker container and a virtual machine, at a high level?

What does the Dockerfile instruction "WORKDIR" do?

What does the "docker images" command display?

What is the purpose of the "ENV" instruction in a Dockerfile?

What happens to data written inside a container's writable layer if the container is removed (without using volumes)?

What is the purpose of the "docker network" command?

What does the default "bridge" network in Docker provide?

What is the purpose of "docker tag"?

What does "docker push" do?

What is the typical purpose of the "RUN" instruction in a Dockerfile?

What is an Alpine-based image, and why is it commonly used as a base image?

What does "docker container prune" do?

What is the purpose of the "LABEL" instruction in a Dockerfile?

Why is it generally recommended to run only one main process per container?

What information does "docker inspect <container>" provide?

What is a "multi-stage build" in Docker, and why is it useful?

What is the difference between a Docker "volume" and a "bind mount"?

Why does Docker use a layered filesystem for images, and what benefit does this provide?

Why is the ordering of instructions in a Dockerfile important for build performance?

What is the purpose of "docker-compose up -d" versus "docker-compose up"?

What is the purpose of "healthcheck" configuration in Docker?

What does the "depends_on" key in docker-compose.yml control?

What is the effect of running a container with "--rm"?

What is the purpose of "docker-compose down -v"?

How can you limit the amount of memory a container can use?

What is the purpose of "ARG" in a Dockerfile, and how does it differ from "ENV"?

What does "docker system prune -a" do, and why should it be used carefully?

What is the purpose of naming a Docker network and attaching multiple containers to it (instead of using the default bridge)?

What does it mean for a Docker image layer to be "cached", and what invalidates that cache during a rebuild?

What is the difference between "CMD [\"executable\", \"param\"]" (exec form) and "CMD executable param" (shell form) in a Dockerfile?

How does "docker-compose" handle environment-specific configuration, e.g. using multiple compose files?

What is the purpose of "docker cp"?

Why might "RUN apt-get update && apt-get install -y <package>" be written on a single RUN line rather than two separate RUN lines?

What is a "named volume" in Docker, and how does it differ from an anonymous volume?

What does "docker stats" provide?

What problem does setting a non-root "USER" instruction in a Dockerfile address?

What is the purpose of an "init" system or "tini" in some Docker containers?

How does Docker determine which platform/architecture (e.g. amd64 vs arm64) an image is built for, and why does this matter for multi-platform builds?

What does the "--network host" option do when running a container?

What is the purpose of "docker volume create" with a specified driver, e.g. for cloud storage?

What does "restart: unless-stopped" mean in a docker-compose service definition?

Why might you use "COPY --from=<stage>" in a multi-stage Dockerfile?

What is the difference between "docker stop" and "docker kill"?

What is the purpose of "docker-compose.override.yml"?

What does "docker build --no-cache" do, and when might it be needed?

What is the significance of the "PID 1" process inside a container regarding "docker stop"?

What does the ".env" file do in a docker-compose project by default?

Why might a containerized application behave differently regarding available memory than expected, even with "--memory" not set?

What is the purpose of "docker save" and "docker load"?

What is the role of "buildkit" in modern Docker builds?

What is the difference between scaling a service with "docker-compose up --scale web=3" and defining 3 separate services in the compose file?

What is the purpose of "docker logout" and credential storage when working with private registries?

What does "docker run --env-file <file>" allow you to do?

Why might you use "docker-compose config" before running "docker-compose up"?

What is the effect of setting "read_only: true" for a service in docker-compose?

How do Linux namespaces contribute to container isolation, and name at least the type that isolates process IDs?

What is the purpose of "cgroups" (control groups) in the context of Docker, distinct from namespaces?

What is the difference between the "overlay2" storage driver and using bind mounts for a container's root filesystem?

What security concern arises from mounting the Docker socket ("/var/run/docker.sock") into a container, and why is this sometimes called "Docker-in-Docker via socket mounting"?

What does "docker exec" rely on internally to enter a running container's namespaces, and how does this differ conceptually from starting a new container?

What is "container escape", and what are common mitigations?

What does the "--cap-add" and "--cap-drop" flags control, and why might dropping capabilities improve security?

How does Docker's "seccomp" default profile improve container security?

What is the significance of "OCI" (Open Container Initiative) specifications for the Docker ecosystem?

Why can excessive image layers (from many separate RUN/COPY instructions) negatively affect both image size and build performance, and how do multi-stage builds and combining commands address this?

How does Docker's default bridge network differ from user-defined bridge networks regarding inter-container communication, particularly around "--link" (legacy) versus modern approaches?

What is the purpose of "docker manifest" and manifest lists in supporting multi-architecture images?

Why might setting "ulimits" be necessary for certain containerized applications, and what is an example of a ulimit relevant to containers?

What does "docker build --secret" address, and what problem does it solve compared to using "ARG" for sensitive values like API keys?

What is the difference between "docker run --restart=always" and an orchestrator (like Kubernetes or Swarm) restarting a failed container?

How does the choice of base image affect the security and size trade-offs of a production image, particularly regarding "distroless" images?

What is "BuildKit's" cache mount feature (e.g. "RUN --mount=type=cache,target=/root/.cache") used for?

Why is pinning exact image digests (e.g. "FROM node@sha256:abcd...") sometimes preferred over tags like "FROM node:20" in production Dockerfiles?

What does "docker events" allow you to do, and how might it be used in monitoring or automation?

In a CI/CD pipeline, why might "docker build" results vary between runs even with an identical Dockerfile and source code, and what techniques help ensure reproducibility?