Images & Builds: glossary
187 terms, in plain words, with where each one is taught.
- --name
- A
docker runflag that gives the container a name you choose (--name web), so later commands can saydocker logs webinstead of a random ID. Lesson 12.3 - --network container: (--network container:NAME)
- Starts a container inside another container's network namespace, so localhost is shared. Used to debug images without tools. Lesson 12.38
- --no-cache
- A docker build flag that ignores the build cache and runs every step again. A debugging tool, not an everyday one. Lesson 12.13
- --no-install-recommends
- An apt-get flag that installs only what a package strictly needs, not the extra "recommended" packages. Often halves an install. Lesson 12.10
- --privileged (privileged container)
- A docker run flag that gives a container every capability, all host devices, and no seccomp or AppArmor limits. Root in it is effectively root on the host. Lesson 12.54
- --progress=plain
- A docker build flag that prints every line of every step's output, numbered, instead of the compact view. What you want in build logs. Lesson 12.8
- --pull
- A docker build flag that checks the registry for a newer base image instead of using the copy already on this machine. Lesson 12.13
- --rm
- A
docker runflag: delete the container as soon as it exits, so throwaway runs do not pile up indocker ps -a. Lesson 12.1 - .dockerignore
- A file in the root of the build context listing what not to send to the builder. Patterns are anchored at the root: use **/ for any depth. Lesson 12.21
- .env (.env file)
- A file of local settings and often credentials, read by many apps and tools. It must never be copied into an image. Lesson 12.21
- ADD
- Like COPY, but also downloads URLs and unpacks tar files. Usually avoided because of those surprises. Lesson 12.8
- Alpine (alpine)
- A tiny Linux image (about 8MB) that uses musl and busybox. Its package manager is apk. Great for static binaries, risky for glibc programs. Lesson 12.38
- anchored pattern (**/)
- A pattern matched from a fixed starting point, here the context root:
node_modulesin .dockerignore matches only ./node_modules;**/node_modulesmatches any depth. Lesson 12.21 - apk
- Alpine Linux's package manager, its version of apt:
apk add --no-cache <pkg>. Lesson 12.28 - ARG (--build-arg, build arg)
- A Dockerfile variable that exists only during the build, set with
--build-arg NAME=value. Its value is still recorded in the history of RUN lines that use it. Lesson 12.8 - arm64 (aarch64, amd64, x86_64)
- CPU families. arm64 (aarch64) is Apple Silicon and this VM; amd64 (x86_64) is Intel/AMD, most servers. A program built for one does not run on the other. Lesson 12.3
- base image
- The image a Dockerfile starts from, named in its FROM line. Your layers go on top of it. Lesson 12.5
- blob (blobs)
- One stored piece of an image (a layer archive or the config), named by its sha256 hash. Lesson 12.40
- build cache (layer cache)
- BuildKit's memory of every step it has run. A step whose inputs have not changed is reused instead of run again. Lesson 12.13
- build checks (docker build --check, JSONArgsRecommended, SecretsUsedInArgOrEnv)
- Warnings BuildKit prints about common Dockerfile mistakes, like a shell-form ENTRYPOINT or a secret in ENV.
docker build --check .runs only the checks. Lesson 12.8 - build context
- The directory you give docker build (usually
.). All of it is sent to the builder, and COPY can only reach files inside it. Lesson 12.8 - BuildKit (buildx, docker-buildx)
- The modern builder behind
docker build, installed on Ubuntu as the docker-buildx package. It adds build checks, cache and secret mounts, parallel stages and multi-platform builds. Lesson 12.1 - buildx builder (docker buildx create, docker-container driver)
- One BuildKit instance. The default builder cannot build several platforms at once; one created with
docker buildx create --driver docker-containerruns in its own container and can. - busybox
- One small program that acts as sh, ls, ps, wget and many more, with fewer flags than the usual tools. Alpine uses it; there is no bash or curl. Lesson 12.38
- cache key
- The fingerprint BuildKit computes for a step from the step before, the instruction text, build args and, for COPY, the content of the files. Lesson 12.13
- cache mount (--mount=type=cache)
- A directory BuildKit keeps between builds and lends to one RUN, never stored in a layer. Package managers keep their downloads there so a rerun only fetches what is new. Lesson 12.13
- CACHED (cache hit)
- What build output prints for a step reused from the cache (a hit). A step that runs is a miss, and every step after a miss runs too. Lesson 12.13
- capabilities (capability, CAP_SYS_ADMIN)
- Root's powers split into separate pieces (change file owners, bind low ports...). Docker drops most of them for containers. Lesson 12.40
- CGO (CGO_ENABLED=0, cgo)
- Go's way of calling C code. When on, Go binaries become dynamically linked against glibc; CGO_ENABLED=0 builds a static binary. Lesson 12.33
- CI (build server, runner)
- Continuous integration: a service that automatically builds and tests every commit, usually on a fresh machine (a runner) each time.
- CI pipeline (CI pipelines)
- The list of steps a CI system runs for each push: for images, usually lint, build, tag, push.
- CMD
- The Dockerfile instruction giving the default arguments to ENTRYPOINT (or the whole command if there is no ENTRYPOINT). Anything after the image name in
docker runreplaces it. Lesson 12.5 - compiled binary (static or dynamic binary)
- A compiled program: one executable file the CPU runs directly, like the output of
go build. Lesson 12.33 - container (containers)
- A running (or stopped) copy of an image: an ordinary Linux process, isolated with namespaces and limited with cgroups, with its own writable layer on top of the image. Lesson 12.1
- containerd
- The container supervisor dockerd hands containers to. It starts and watches them through runc and the shims. Lesson 12.1
- COPY
- The Dockerfile instruction that copies files from the build context (or, with --from, another stage) into the image. Files are root-owned unless you pass --chown. Lesson 12.8
- COPY --chown (--chown, --chmod)
- COPY flags that set the owner (--chown=user:group) or mode (--chmod=755) as files are copied, without a second layer. Lesson 12.10
- COPY --from
- Copies a file out of another build stage (or another image) into the current one:
COPY --from=build /app/app.jar .. Lesson 12.24 - copy-up
- What overlayfs does when you change the owner, mode or content of a file from a lower layer: it copies the whole file into the new layer first, so chown -R after COPY doubles the size. Lesson 12.10
- credential helper (credsStore, osxkeychain)
- A small program that keeps registry passwords in the system keychain instead of in ~/.docker/config.json as base64. Lesson 12.54
- cross-compile (cross-compiling, BUILDPLATFORM, TARGETARCH)
- Compile on your own CPU a program for another CPU. BuildKit sets BUILDPLATFORM, TARGETOS and TARGETARCH so the Dockerfile can do it. Lesson 12.54
- CVE (CVEs)
- A publicly listed security vulnerability with an id like CVE-2024-1234. Scanners list the CVEs of the packages in an image. Lesson 12.38
- daemon (daemons)
- A background program that runs all the time, usually started by systemd, waiting for requests. dockerd is the Docker daemon. Lesson 12.1
- daemon.json (/etc/docker/daemon.json)
- dockerd's settings file, in JSON. A typo in it stops dockerd from starting;
journalctl -u dockershows the parse error. Lesson 12.1 - debug container (debug containers)
- A throwaway container full of tools, started in another container's namespaces (for example with --network container:NAME) to look inside an image that has no tools. Lesson 12.38
- Dependabot (Renovate)
- Bots that watch your dependencies (including pinned image digests) and open a pull request when a new version appears. Lesson 12.5
- devDependencies (--omit=dev)
- npm packages needed only to build and test (TypeScript, test runners).
npm ci --omit=devleaves them out of the runtime image. Lesson 12.33 - diff ID (diff IDs, RootFS.Layers, diff_ids)
- The sha256 of a layer's uncompressed tar, listed in the image config. Two images with the same diff ID share that layer.
- digest (image digest, sha256 digest, RepoDigests)
- The sha256 hash of an image's manifest, written
name@sha256:.... It can only ever mean those exact bytes, so pinning it pins the whole image. Lesson 12.5 - distroless
- Images with only a language runtime, its libraries and CA certificates: no shell, no package manager. Small and hard to attack, harder to debug. Lesson 12.24
- dive
- A terminal tool that shows an image layer by layer, with the files each layer added or hid. Lesson 12.40
- Docker
- A tool that packs a program with every file it needs into an image, and runs copies of it as containers on any Linux machine. Lesson 12.1
- docker build
- Builds an image from a Dockerfile.
-t name:tagnames the result; the last argument is the build context, usually.. Lesson 12.8 - docker build -f
- Names the Dockerfile to use when it is not ./Dockerfile. COPY paths still resolve against the context, not the Dockerfile. Lesson 12.21
- docker builder prune
- Deletes the build cache, which can grow to many GB.
docker system dfshows how much disk images, containers and the cache use. Lesson 12.13 - docker buildx du
- Shows what the build cache holds and how much disk it uses; RECLAIMABLE entries are safe to delete. Lesson 12.19
- Docker client (docker CLI, docker command)
- The
dockercommand you type. It does no work itself; it sends each request to dockerd over a socket and prints the answer. Lesson 12.1 - Docker Compose (Compose, docker compose)
- A Docker tool that starts several containers together from one YAML file. Taught in Ch 13. Lesson 12.1
- docker cp
- Copies files between a container and the host:
docker cp api:/app/config.yml .. Lesson 12.38 - docker diff
- Shows what a container changed compared to its image: A added, C changed, D deleted. Lesson 12.3
- docker events
- Docker's live stream of what happens: containers starting, dying, health changes. Lesson 12.44
- docker exec
- Runs one more command inside a container that is already running, like
docker exec web cat /etc/hostname. Lesson 12.3 - docker group
- The group allowed to use /run/docker.sock. Being in it lets you do anything root can, because dockerd runs as root and does what the socket asks. Add yourself with
sudo usermod -aG docker $USER, then log in again ornewgrp docker. Lesson 12.1 - docker history
- Lists an image's build steps, newest first, with the bytes each added.
--no-truncshows full commands, which can reveal leaked build args. Lesson 12.10 - Docker Hub (docker.io)
- The public registry Docker uses when an image name has no registry host.
nginxmeansdocker.io/library/nginx. Lesson 12.5 - docker images (docker image ls)
- Lists the images on this machine: in Docker 29 one row per name (repository:tag) with its ID, disk usage, content size and a U when a container uses it.
--format table(or --digests, -q, --no-trunc) gives the older REPOSITORY TAG IMAGE ID CREATED SIZE table. Lesson 12.5 - docker inspect
- Prints everything Docker knows about a container or image as JSON.
-fpicks fields with a Go template, like-f '{{.State.Pid}}'. Lesson 12.3 - docker login (--password-stdin)
- Stores your credentials for a registry so later pulls and pushes work. Use --password-stdin so the password is not in your history or ps. Lesson 12.54
- docker logs
- Prints what a container wrote to stdout and stderr, like journalctl -u for a unit.
-ffollows new lines. Lesson 12.33 - docker ps
- Lists running containers;
-aalso shows stopped ones. Lesson 12.1 - docker ps -a
- Lists all containers, including stopped ones. Plain
docker pshides every container that is not running, which is why stopped containers seem to "disappear". Lesson 12.28 - docker push (push an image)
- Upload an image to the registry named in its tag. Only layers the registry does not have are sent; the last line prints the digest. Lesson 12.54
- docker rm (docker rm -f)
- Deletes a container and its writable layer.
-fstops it first if it is still running. Lesson 12.3 - docker run
- Creates a container from an image and starts it. Common flags:
-dbackground,--namea name,--rmdelete it when it exits,-vmount a path,-ppublish a port. Lesson 12.1 - docker save
- Writes an image, with its config and every layer, into one tar file you can unpack and inspect. Lesson 12.40
- docker stop
- Asks a running container to end: Docker sends SIGTERM to its PID 1, waits (10 s by default), then sends SIGKILL if it is still running. Lesson 12.3
- docker stop timeout (stop timeout, --stop-timeout)
- How long
docker stopwaits after SIGTERM before sending SIGKILL: 10 seconds by default, changed withdocker stop -tor--stop-timeout. Lesson 12.28 - docker system df
- Docker's disk report: images, containers' writable layers, volumes and build cache. It does not count container log files. Lesson 12.5
- docker tag
- Gives an existing image another name (for example with a registry host). No bytes are copied. Lesson 12.54
- docker top
- Lists the processes inside a container, with their PIDs as the host sees them. Lesson 12.3
- docker-proxy
- The small Docker process that holds a published host port and forwards each connection into the container.
- dockerd
- The Docker daemon: the root-owned background service that manages images, containers, networks and volumes. The docker command only sends it requests. Runs as docker.service. Logs:
journalctl -u docker. Lesson 12.1 - Dockerfile (Dockerfiles)
- The text recipe for building an image: one instruction per line (FROM, RUN, COPY...), read top to bottom by
docker build. Lesson 12.5 - dynamic loader (ld-linux, ld-linux-aarch64.so.1)
- The small program that loads a dynamically linked binary's libraries at start. If it is missing, the kernel reports "no such file or directory" for a binary that exists. Lesson 12.33
- eclipse-temurin
- A widely used set of Java images:
21-jdkto build,21-jreto run. Lesson 12.8 - ENOENT (No such file or directory)
- The kernel's error code for "No such file or directory". When starting a program it can also mean a file the program needs (its interpreter or loader) is missing.
- ENTRYPOINT
- The Dockerfile instruction naming the program a container runs. CMD supplies its default arguments. Lesson 12.5
- entrypoint script (docker-entrypoint.sh)
- A shell script used as ENTRYPOINT to do setup before the app starts. It must end with
exec "$@"so the app replaces the shell as PID 1. Lesson 12.28 - ENV
- The Dockerfile instruction that bakes an environment variable into the image. Visible to anyone with the image, so never for secrets. Lesson 12.8
- envsubst
- Replaces ${NAME} in a text file with the value of the environment variable NAME. Entrypoint scripts use it to fill in config files. Lesson 12.28
- exec form (JSON form)
- Writing ENTRYPOINT/CMD as a JSON array,
["java","-jar","app.jar"]: the program runs directly as PID 1 and receives signals. Lesson 12.28 - exec format error
- The kernel's error when asked to run a program built for a different CPU family, for example an amd64 image on arm64. Lesson 12.3
- EXPOSE
- A Dockerfile note saying which port the app listens on. It publishes nothing; only
docker run -popens a port on the host. Lesson 12.8 - fat jar
- A JAR that contains your code and every dependency in one file, so any code change makes the whole file a new layer. Lesson 12.24
- Flask
- A small Python framework for writing web services.
- FROM
- The Dockerfile instruction that picks the base image. Each FROM also starts a new build stage. Lesson 12.8
- git short SHA (short SHA, commit SHA, git SHA)
- The first 7 characters of a git commit id, as shown by
git log --oneline. Used in tags to trace an image back to its commit. Lesson 12.54 - Go template (--format)
- The
{{.Field}}syntax Docker's-f/--formatflag uses to pick fields out of its JSON. Docker is written in Go, hence the name. Lesson 12.3 - go-offline (dependency:go-offline, mvn dependency:go-offline)
- A Maven command that only downloads every dependency in pom.xml. On its own RUN line it becomes a step the build cache can skip until pom.xml changes. Lesson 12.13
- Gradle
- Another Java build tool, an alternative to Maven. Lesson 12.13
- gunicorn
- A production web server for Python web apps.
-b 0.0.0.0:8000sets the address and port it listens on. Lesson 12.33 - hadolint
- A popular Dockerfile linter, also available as an image:
docker run --rm -i hadolint/hadolint < Dockerfile. Lesson 12.50 - HEALTHCHECK
- A Dockerfile instruction giving a command Docker runs regularly inside the container to see if the app is OK: healthy or unhealthy. Lesson 12.8
- host PID
- The PID a container's process has on the host. Inside its own PID namespace the same process may be PID 1. Lesson 12.3
- hosted runner (self-hosted runner, ephemeral runner)
- A hosted CI runner is a fresh machine the CI company gives you for each job, so it starts with no cache. A self-hosted runner is your own server, kept between jobs. Lesson 12.19
- image (images, container image, Docker image)
- A sealed, read-only bundle: a program plus all the files it needs, stored as layers plus a small config. It never changes; a new version is a new image. Lesson 12.1
- image config (config blob)
- The small JSON part of an image that says how to run it: entrypoint, command, environment, user, working directory, ports, and the build history. Lesson 12.3
- IMAGE ID (image ID)
- The ID
docker imagesshows: with the containerd image store (Docker 29's default) the start of the image's digest; on the classic store a hash of the image config. Two tags with the same IMAGE ID are one image. Lesson 12.5 - image index (manifest list)
- The small file behind a multi-arch tag that points at one manifest per platform. Lesson 12.54
- image repository (registry repository)
- In a registry: all versions (tags) of one image under one name, like
team/orders. (In git, a repository is a project's history.) Lesson 12.5 - image scanner (scanner, vulnerability scan)
- A tool that lists the packages in an image and reports their known vulnerabilities (CVEs) and sometimes leaked secrets. Lesson 12.38
- image signing (cosign, signed image, signed images)
- Attaching a cryptographic proof of who built an image to its digest, so servers can refuse images nobody trusted signed. Lesson 12.53
- immutable tag (immutable tags, tag immutability)
- A registry setting that forbids moving a tag once pushed, so 2.14.1 always means the same image. A fix must be a new version. Lesson 12.54
- JAR (jar, .jar)
- A Java program packed into one zip file. Run it with
java -jar app.jar. Lesson 12.8 - Java module (java.base)
- A named part of Java's standard library, like java.base or java.sql. jlink builds a runtime from a chosen set of them. Lesson 12.24
- jdeps
- A JDK tool that reads a jar and lists the Java modules it uses, so a jlink runtime can include exactly those. Lesson 12.24
- Jib
- A Maven/Gradle plugin that builds Java images without a Dockerfile, splitting libraries and your code into separate layers.
- jlink
- A JDK tool that builds a Java runtime with only the modules you list. Lesson 12.24
- JRE
- The Java Runtime Environment: what you need to run a Java program, without the compiler. Lesson 12.8
- LABEL
- A Dockerfile instruction that stores a key=value note in the image config, like the source repo or the git commit it was built from. Lesson 12.8
- latest (:latest)
- The tag Docker uses when you do not type one. It does not mean newest; it points at whatever was last pushed as latest. Lesson 12.5
- layer (layers, image layer)
- One slice of an image: an archive of the files a single build step added or changed. Layers are stacked, read-only and shared between images. Lesson 12.3
- layered jar (layered jars, jarmode, JarLauncher)
- A Java app's jar unpacked into four folders (dependencies, loader, snapshot dependencies, your code) copied as separate layers, so a code change is a small layer.
java -Djarmode=tools -jar app.jar extract --layers --launcher, then start it withjava org.springframework.boot.loader.launch.JarLauncher. Lesson 12.24 - legacy builder
- The old image builder Docker falls back to when BuildKit is missing. You recognise it by
Sending build context to Docker daemonandStep 1/4in the output. Lesson 12.1 - linter (lint, linting)
- A program that reads a file (code, a Dockerfile) and warns about known mistakes without running it.
- lockfile (package-lock.json, go.sum)
- A file that records the exact version of every dependency, so every install gets the same ones. Copy it before installing, for the cache. Lesson 12.13
- lsns
- Lists the namespaces on the system and the processes in them;
-t netshows only network namespaces. Lesson 12.3 - manifest (image manifest, manifest.json)
- The small JSON file in a registry that lists an image's config and layers by their hashes. The image digest is the hash of this file. Lesson 12.5
- Maven (mvn, pom.xml, .m2)
- A Java build tool. It reads pom.xml, downloads the libraries the app needs into ~/.m2, compiles the code and writes a JAR into target/. Lesson 12.8
- metadata instruction (metadata instructions, filesystem instructions)
- Dockerfile lines that only change the image config (ENV, USER, CMD...) and add zero bytes, as opposed to filesystem lines (FROM, RUN, COPY, ADD, WORKDIR) that make layers. Lesson 12.8
- monorepo
- One git repository holding several services or projects, each in its own folder. Lesson 12.21
- multi-arch image (multi-arch, multi-platform)
- One tag that holds an image for each platform. Each machine pulls the one matching its CPU. Lesson 12.54
- multi-stage build (multi-stage, multistage)
- A Dockerfile with several FROM lines. Early stages build the program; the last stage starts clean and copies in only the result, so build tools never reach the image. Lesson 12.24
- musl
- A small C library used by Alpine instead of glibc. Programs and native libraries built for glibc may fail or crash on it. Lesson 12.38
- namespace (namespaces, Linux namespace, PID namespace)
- A kernel feature that gives a process its own private view of one kind of resource: its own process list (pid), network (net), mounts (mnt), hostname (uts)... Containers are built from them. See them with
sudo ls -l /proc/<pid>/nsorsudo lsns. Lesson 12.3 - native library (native libraries, UnsatisfiedLinkError)
- Compiled C code a Java (or Python) program loads. Built for glibc, it fails on musl with UnsatisfiedLinkError or a crash (exit 139). Lesson 12.38
- netshoot (nicolaka/netshoot)
- A popular debugging image full of network tools (curl, ss, dig, tcpdump), run next to a container that has none. Lesson 12.38
- npm (npm ci, package.json, node_modules)
- Node.js's package manager. It installs the packages in package.json into node_modules;
npm ciinstalls exactly what the lockfile says. Lesson 12.13 - nsenter
- Runs a command inside another process's namespaces.
sudo nsenter -t PID -n ss -tlnpruns the host's ss inside a container's network. Lesson 12.3 - OCI (OCI runtime, Open Container Initiative)
- The Open Container Initiative: the standard image format and runtime rules Docker, runc and other tools follow, so images work everywhere. Lesson 12.38
- OCI labels (org.opencontainers.image.revision, org.opencontainers.image.source, org.opencontainers.image.version)
- Standard LABEL names (org.opencontainers.image.*) for where an image came from: its source repository, commit and version. Lesson 12.13
- official image (library/)
- Images Docker Hub maintains under the
library/namespace, like nginx, ubuntu, node, python. Lesson 12.5 - OOMKilled
- A field
docker inspectshows as true when the kernel OOM killer ended the container because it hit its memory limit. The exit code is then 137. Lesson 12.38 - overlayfs (overlay2, overlay filesystem, union filesystem)
- A Linux filesystem that stacks directories and shows them as one. Docker uses it to combine the image layers (lowerdir) and the container layer (upperdir) into one / (merged). With the containerd image store each layer is a snapshot under /var/lib/containerd; overlay2 is the classic store's name for the same idea. Lesson 12.3
- PID 1 (init process)
- The first process of a PID namespace. The kernel ignores signals it has no handler for, and it must reap orphaned children. Lesson 12.28
- pin (pinning, pinned)
- Refer to an exact version that cannot change, for images a digest:
FROM image:tag@sha256:.... Lesson 12.5 - pip (requirements.txt)
- Python's package manager.
pip install -r requirements.txtinstalls the listed packages. Lesson 12.13 - platform (linux/amd64, linux/arm64, --platform)
- OS plus CPU family an image is built for, written like linux/amd64 or linux/arm64. Lesson 12.54
- prune (docker system prune, docker image prune, docker container prune)
- Delete everything unused of one kind: stopped containers, unused images, build cache, unused volumes.
volume prune -acan delete real data. Lesson 12.13 - publish (publish a port, published port)
- Forward a port on the host to a port in the container:
docker run -p 8080:8080sends host port 8080 to the container's 8080. Lesson 12.8 - pull (docker pull, pulling)
- Download an image from a registry to this machine. Only the layers you do not already have are downloaded. Lesson 12.1
- pull request (PR, PRs, pull requests)
- A proposed change to a git repository that teammates review and approve before it is merged. Lesson 12.5
- PYTHONUNBUFFERED (PYTHONUNBUFFERED=1)
- An environment variable that makes Python print output immediately instead of buffering it, so logs appear in docker logs straight away. Lesson 12.33
- registry (registries, container registry)
- A web server that stores images. You pull from it and push to it. Docker Hub is the public default; companies run private ones. Lesson 12.5
- registry cache (--cache-from, --cache-to, type=registry)
- The build cache uploaded to a registry after a build (--cache-to) and downloaded before the next one (--cache-from), so a fresh CI runner does not build from zero. Lesson 12.19
- release candidate
- A test build of the next version (like 7.5.0-rc1), meant for trying out, not for production.
- restart policy (--restart)
- docker run --restart tells Docker to restart a container when its process exits, like systemd's Restart=. It ignores health status. Lesson 12.44
- rootless Docker (Podman)
- Ways of running containers without a root daemon (rootless Docker, or the Docker alternative Podman), so access to them is not the same as root. Lesson 12.1
- rotate (rotating a secret, rotated)
- Replace a leaked or old secret with a new one and disable the old one. Deleting the image that leaked it is not enough.
- RUN
- The Dockerfile instruction that runs a shell command inside the image being built and saves what changed as a new layer. Lesson 12.8
- runc
- A small program that creates a container: it sets up the namespaces and cgroups, starts your process in them, then exits. Lesson 12.1
- scratch (FROM scratch)
- The empty base image: no files at all, not even CA certificates or /etc/passwd. Only for static binaries. Lesson 12.33
- seccomp
- A kernel filter that blocks dangerous system calls. Docker applies a default one to every container. Lesson 12.40
- secret mount (--mount=type=secret, --secret, build secret)
- A BuildKit feature that lends a secret file to one RUN without writing it to any layer or the history:
RUN --mount=type=secret,id=x ...plusdocker build --secret id=x,src=FILE. Lesson 12.40 - segfault (segmentation fault, SIGSEGV, exit code 139)
- The kernel killing a program that touched memory it does not own (signal 11, SIGSEGV). A bug in the program, usually in native C or C++ code; a container shows it as exit code 139. Lesson 12.38
- semver (semantic versioning)
- Version numbers of the form MAJOR.MINOR.PATCH, like 2.14.1. Lesson 12.54
- shell form
- Writing ENTRYPOINT/CMD as a plain string. Docker wraps it in
/bin/sh -c, so the shell is PID 1 and the app never gets SIGTERM. Lesson 12.28 - shim (containerd-shim, containerd-shim-runc-v2)
- A tiny helper process, one per container, that stays as the parent of the container's first process so the container keeps running even if dockerd restarts. Lesson 12.1
- slim (-slim)
- Image variants (debian:12-slim, node:22-slim) with docs and extras removed but glibc and apt kept. A good default runtime base. Lesson 12.38
- Spring Boot (Spring)
- A popular Java framework for building web services. The orders app in this chapter is one; it ships as a fat jar. Lesson 12.8
- stage (build stage, AS build, --target)
- One FROM section of a Dockerfile, with its own fresh filesystem.
AS namenames it;docker build --target namebuilds only up to it. Lesson 12.24 - start period (--start-period, FailingStreak)
- HEALTHCHECK's grace time after start during which failures do not count. FailingStreak in docker inspect counts failures in a row. Lesson 12.44
- static binary (statically linked, dynamically linked, dynamic linking)
- A static binary has every library built in and runs anywhere. A dynamically linked one needs its libraries and the dynamic loader on disk. Lesson 12.33
- STOPSIGNAL
- The Dockerfile instruction that sets which signal
docker stopsends first (SIGTERM by default). Lesson 12.8 - tag (tags, image tag)
- A version label on an image name, after the colon:
nginx:1.27. A tag is a pointer that can be moved to a different image. Lesson 12.5 - tini (--init, docker-init)
- A tiny init process for containers: it runs as PID 1, forwards signals to your app and reaps zombies.
docker run --initadds it. Lesson 12.28 - TypeScript (tsc)
- JavaScript with type annotations.
tsccompiles it into plain JavaScript (usually into dist/). Lesson 12.33 - Unix socket (socket file, docker.sock, /run/docker.sock)
- A special file that two programs on the same machine use to talk to each other, like a network port but addressed by a path. ls -l shows it with an
stype. Lesson 12.1 - USER
- The Dockerfile instruction that sets which user the following RUN lines and the container run as. It does not change who owns copied files. Lesson 12.8
- user namespace
- A namespace that maps user ids, so root inside a container could be an ordinary user outside. Docker does not turn it on by default: uid 0 inside is uid 0 on the host. Lesson 12.3
- userland
- The files and programs of an operating system, everything except the kernel. An "Ubuntu 22.04 container" is 22.04 userland on the host's kernel. Lesson 12.3
- virtualenv (venv)
- A self-contained Python folder with its own interpreter and packages. Easy to copy between build stages as one directory. Lesson 12.33
- volume (volumes)
- Storage that lives outside a container's writable layer, so data in it survives when the container is deleted. Covered in Ch 13. Lesson 12.3
- wheel (wheels)
- A ready-built Python package; pip installs it without compiling anything.
- whiteout (.wh., whiteout file)
- A marker file a later layer uses to hide a file from an earlier layer. The hidden file's bytes are still in the earlier layer. Lesson 12.10
- WORKDIR
- The Dockerfile instruction that sets the current directory for the next lines and the container, creating it if needed. Lesson 12.8
- writable layer (container layer, upperdir)
- The empty layer Docker puts on top of the image for each container. Everything the container writes goes there, and it is deleted with the container. Lesson 12.3