OnCallReadyStart learning

Images & Builds: glossary

187 terms, in plain words, with where each one is taught.

--name
A docker run flag that gives the container a name you choose (--name web), so later commands can say docker logs web instead 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 run flag: delete the container as soon as it exits, so throwaway runs do not pile up in docker 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_modules in .dockerignore matches only ./node_modules; **/node_modules matches 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-container runs 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 run replaces 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 docker shows 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=dev leaves 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:tag names 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 df shows 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 docker command 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 or newgrp docker. Lesson 12.1
docker history
Lists an image's build steps, newest first, with the bytes each added. --no-trunc shows 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. nginx means docker.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. -f picks 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. -f follows new lines. Lesson 12.33
docker ps
Lists running containers; -a also shows stopped ones. Lesson 12.1
docker ps -a
Lists all containers, including stopped ones. Plain docker ps hides 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. -f stops it first if it is still running. Lesson 12.3
docker run
Creates a container from an image and starts it. Common flags: -d background, --name a name, --rm delete it when it exits, -v mount a path, -p publish 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 stop waits after SIGTERM before sending SIGKILL: 10 seconds by default, changed with docker stop -t or --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-jdk to build, 21-jre to 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 -p opens 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/--format flag 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:8000 sets 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 images shows: 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.
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 with java 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 daemon and Step 1/4 in 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 net shows 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>/ns or sudo 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 ci installs exactly what the lockfile says. Lesson 12.13
nsenter
Runs a command inside another process's namespaces. sudo nsenter -t PID -n ss -tlnp runs 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 inspect shows 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.txt installs 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 -a can 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:8080 sends 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 ... plus docker 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 name names it; docker build --target name builds 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 stop sends 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 --init adds it. Lesson 12.28
TypeScript (tsc)
JavaScript with type annotations. tsc compiles 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 s type. 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