Glossary
Short definitions of terms used in the notes. A term that a note explains in full links to that note.
- API server
- The control plane component that serves the Kubernetes API. Every other component, and every tool such as kubectl, reads and changes cluster state only through it. See Kubernetes architecture.
- AppArmor
- A Linux kernel security feature that limits what a program can do. A profile, matched to the program by its file path, lists the files, capabilities, and network access it may use.
- bandwidth
- How much data a link can carry per second, measured in bits per second. See Networking basics.
- chain-of-thought
- A prompting technique in which the model writes out intermediate reasoning steps before its answer, which improves results on multi-step problems. See Prompting techniques.
- cloud-controller-manager
- An optional control plane component that connects a cluster to a cloud provider, for example to create load balancers and to track the virtual machines behind nodes. See Managed Kubernetes clusters.
- cluster DNS
- The DNS server inside a Kubernetes cluster, usually CoreDNS. It answers lookups of Service names, such as web.default.svc.cluster.local, and pods use it by default. See Services.
- CNI plugin
- A program, called through the Container Network Interface, that connects a new pod's network namespace to the cluster network and gives the pod its IP address, such as Calico, Cilium, or Flannel. See The Kubernetes network model.
- container image
- A package of the files and settings a container starts from, named like nginx:1.27 and stored in a registry such as Docker Hub.
- container runtime
- The software on a node that runs containers. It pulls images and asks the kernel to set up each container.
- context window
- The most tokens a language model can take in at once, prompt and reply together. See Large language models.
- controller
- A control loop that watches the cluster through the API server and makes or requests changes to move its current state toward the desired state. See Kubernetes architecture.
- controller manager
- The control plane component that runs the built-in controllers, such as the Deployment and ReplicaSet controllers, in one process. See Kubernetes architecture.
- Deployment
- A Kubernetes object that keeps a chosen number of identical pods running and replaces them gradually when you change them. See From containers to Deployments.
- EndpointSlice
- A Kubernetes object that lists the IP addresses and ports of the pods behind a Service, each marked ready or not. A controller keeps it in step with the Service selector. See Services.
- ephemeral container
- A container added to a running pod for troubleshooting, usually with kubectl debug. It is never restarted and stays in the pod until the pod is deleted. See kubectl debug.
- etcd
- A consistent, highly available key-value store that Kubernetes uses to keep all cluster data. Only the API server talks to it. See Kubernetes architecture.
- eval
- A fixed set of test inputs run through an LLM application, with a way to score each output, so that versions of the application can be compared. See Evaluating LLM applications.
- hallucination
- A fluent statement from a language model that is false. Models produce likely text and do not look facts up. See Large language models.
- init container
- A container in a pod that runs to completion before the app containers start, for setup work such as waiting for a dependency.
- IP address
- The address that names a host's network interface across networks: 32 bits in IPv4, such as 10.244.2.5, and 128 bits in IPv6. See Networking basics.
- kube-proxy
- A process on each node that watches Services and EndpointSlices and writes kernel rules, such as iptables rules, that send traffic for a Service to one of its pods. See Services.
- kubeadm
- A Kubernetes tool that sets up a cluster: it starts the control plane on one machine and joins other machines to it as nodes. See Local Kubernetes clusters.
- kubeconfig
- A file that tells kubectl which clusters exist, how to reach and trust their API servers, and which credentials to use. See Local Kubernetes clusters.
- kubectl
- The command-line tool for working with a Kubernetes cluster. It sends requests to the API server.
- kubelet
- The agent that runs on each node in a Kubernetes cluster and makes sure the containers in its pods are running. See Kubernetes architecture.
- label
- A key-value pair, such as app=web, attached to a Kubernetes object to identify it. A label selector uses labels to pick out a set of objects, such as the pods a ReplicaSet counts as its own.
- large language model (LLM)
- A neural network trained on a very large amount of text to predict the next token from the tokens before it. It writes by repeating that prediction one token at a time. See Large language models.
- latency
- The time data takes to get from sender to receiver. It decides how long small transfers take, and more bandwidth doesn't lower it. See Networking basics.
- LLM-as-a-judge
- Using an LLM to grade outputs, such as against a rubric or by comparing two answers. Judges have known biases, such as favoring the first or the longer answer. See Evaluating LLM applications.
- MCP
- Model Context Protocol: an open standard, published by Anthropic in November 2024, that lets one program, an MCP server, offer tools to any application that speaks it, over JSON-RPC. See Tool use.
- MTU
- Maximum transmission unit: the largest payload one frame on a link can carry, 1,500 bytes on standard Ethernet. See Networking basics.
- namespace (Kubernetes)
- A named group of objects inside a Kubernetes cluster, used to keep teams or apps apart. Unrelated to Linux namespaces.
- NAT
- Network address translation: rewriting the IP addresses, and often the ports, of packets as they pass a router, such as to share one public address among many hosts.
- network namespace
- A Linux namespace that gives a group of processes their own network interfaces, IP addresses, routes, and ports. The containers in a pod share one. See Namespaces.
- NetworkPolicy
- A Kubernetes object that limits which traffic may reach or leave selected pods. The network plugin enforces it; a plugin without support ignores it. See The Kubernetes network model.
- node
- A machine, physical or virtual, that runs pods in a Kubernetes cluster. See Kubernetes architecture.
- OSI model
- A seven-layer reference model of networking from ISO, from the physical layer up to the application layer. Names such as "layer 2" and "layer 7" come from it. See Networking basics.
- pod
- The smallest unit Kubernetes runs: one or more containers that run on the same node and share some resources, such as a network namespace. See From containers to Deployments.
- port
- A 16-bit number that names an endpoint inside a host, so that many programs can share one IP address. Servers listen on known ports, such as 80 for HTTP. See Networking basics.
- prompt injection
- An attack that hides instructions in text an LLM reads, such as a web page or a tool result, so that the model follows them instead of its application's instructions. See Tool use.
- readiness probe
- A check the kubelet runs on a container, such as an HTTP request, to decide whether its pod is ready to receive traffic from Services. See Services.
- reflection
- An agentic pattern in which an LLM critiques an output, often its own draft, and then revises it, over one or more rounds. See Agentic design patterns.
- ReplicaSet
- A Kubernetes object that keeps a chosen number of identical pods running. Deployments create and manage ReplicaSets. See From containers to Deployments.
- RTT
- Round-trip time: the time for data to reach the other end and a reply to come back. Each request that waits for a reply costs at least one. See Networking basics.
- rubric
- A written list of criteria that an output is graded against, such as "the chart has a title". Each criterion is often passed or failed, and the passes are added up. See Evaluating LLM applications.
- scheduler
- The control plane component that watches for new pods with no node assigned and picks a node for each one to run on. See Kubernetes architecture.
- SELinux
- A Linux kernel security feature, first developed by the NSA, that labels every process and resource. An access is allowed only if the policy permits that pair of labels.
- Service
- A Kubernetes object that gives a set of pods one stable network address and spreads traffic among them. See Services.
- service mesh
- A layer of proxies, often one sidecar per pod, that carries the traffic between services and adds encryption, retries, and metrics. Istio is one. See Sidecar containers.
- sidecar container
- A helper container in a pod that runs beside the main application for the pod's whole life, adding a feature such as log shipping or a proxy. See Sidecar containers.
- static pod
- A pod that the kubelet starts from a manifest file on its node, without the API server. kubeadm runs the control plane this way. See Local Kubernetes clusters.
- TCP
- Transmission Control Protocol: the transport protocol that gives two programs a reliable, ordered stream of bytes over IP, on a connection opened with a handshake.
- token
- The unit of text a language model reads and writes, often a word or part of a word. Context limits and API prices are counted in tokens. See Large language models.
- tool use
- A way for an LLM to ask the application around it to run a named function with given arguments, and to read the result. Also called function calling. See Tool use.
- volume
- A directory of data that the containers in a pod can access. Its data survives when a container in the pod restarts.