Kubernetes: Scheduling, Health & Security: glossary
143 terms, in plain words, with where each one is taught.
- 401 means the apiserver does not know who you are (bad or expired credential); 403 means it knows you and RBAC says no. Lesson 19.33
- Actuator (/actuator/health, Spring Boot Actuator)
- Spring Boot's built-in set of operational URLs, such as /actuator/health/liveness and /actuator/health/readiness for probes. Lesson 19.22
- admission (admission controller, admission plugin, admission control)
- Checks the apiserver runs on every create or update after it knows who you are and before it saves the object. An admission plugin may fill in defaults or reject the object. Lesson 19.9
- allocatable
- What is left of a node for pods: its capacity minus what the kubelet keeps back for the operating system, itself and the eviction threshold. Lesson 19.1
- Allocated resources
- The table at the bottom of kubectl describe node that sums the requests and limits of every pod on the node. It is the scheduler's ledger. Lesson 19.1
- Allowed disruptions (ALLOWED DISRUPTIONS)
- The number a PDB shows: healthy pods minus pods that must stay healthy. 0 means no eviction will be allowed right now. Lesson 19.26
- allowPrivilegeEscalation (no_new_privs)
- When false, the kernel's no_new_privs flag is set: no setuid program can gain more privileges inside the container. Lesson 19.37
- API group (apiGroups, core group)
- The family a kind of object belongs to: "" (core) for pods and secrets, apps for Deployments, batch for Jobs. RBAC rules must name the right one. Lesson 19.30
- audit log
- A record the apiserver can write of every request: who did what, when, and the result. Lesson 19.39
- authentication (authenticated, authn)
- Proving who you are to the apiserver, with a client certificate or a token. Failure is 401 Unauthorized. Lesson 19.30
- Deciding whether an identity may do a given action. In Kubernetes that is RBAC; failure is 403 Forbidden. Lesson 19.30
- automountServiceAccountToken
- A ServiceAccount or pod field; false means the pod gets no API token, which is right for apps that never call the apiserver. Lesson 19.33
- bearer token (token)
- A secret string sent with every request that proves who you are, like a session cookie. Lesson 19.30
- BestEffort
- The weakest QoS class: no requests or limits anywhere in the pod. Evicted first, oom_score_adj 1000. Lesson 19.3
- bound token (bound, short-lived token, TokenRequest, kubectl create token)
- The ServiceAccount token the kubelet mounts into pods: tied to the pod, valid about an hour and rotated automatically. kubectl create token issues one on demand. Lesson 19.33
- break-glass (break-glass access)
- Emergency access kept aside for when the normal login path is broken.
- Burstable
- The middle QoS class: some requests or limits are set, but not all equal. Evicted when it uses more than it requested. Lesson 19.3
- capacity (node capacity)
- The total CPU, memory and pod slots a node physically has, as reported by its kubelet. Lesson 19.1
- CFS (Completely Fair Scheduler, CFS period, CFS quota)
- The Linux kernel's CPU scheduler. A CPU limit becomes a CFS quota: at most X microseconds of CPU in every 100 ms period. Lesson 19.1
- change-cause (kubernetes.io/change-cause)
- An annotation whose text appears in the CHANGE-CAUSE column of kubectl rollout history, so you can see why each revision exists. Lesson 19.24
- CKA (Certified Kubernetes Administrator)
- Certified Kubernetes Administrator: a hands-on exam where you fix and build things in real clusters from a terminal, against the clock. Lesson 19.43
- client library (client-go, Kubernetes client)
- Code that apps use to call the Kubernetes API from a program instead of kubectl, for example client-go for Go. Lesson 19.33
- cluster autoscaler
- An add-on that adds nodes when pods are Pending for lack of room and removes nodes that stay empty.
- cluster-admin
- Built-in ClusterRoles: view (read, no secrets), edit (change workloads and secrets), admin (edit plus roles in a namespace), cluster-admin (everything). Lesson 19.30
- ClusterRole
- Like a Role but not tied to a namespace: needed for cluster-wide resources such as nodes, and reusable in many namespaces. Lesson 19.30
- ClusterRoleBinding
- Gives a ClusterRole to subjects in every namespace and for cluster-scoped resources. Lesson 19.30
- compressible (incompressible)
- CPU is compressible: if you want more than allowed you just run slower. Memory is incompressible: it either exists or the process is killed. Lesson 19.6
- connection pool (connection pools)
- A set of open connections (usually to a database) that an application keeps ready and reuses, so it does not have to connect for every request. Lesson 19.22
- cordon (kubectl cordon, uncordon, cordoned)
- Marking a node "no new pods" (kubectl cordon NODE) before maintenance; running pods stay. kubectl uncordon undoes it. Lesson 19.13
- cpu.stat (nr_throttled, nr_periods, throttled_usec)
- The cgroup file with CPU counters: nr_periods (periods with work), nr_throttled (periods that hit the quota) and throttled_usec (time spent paused). Sample twice and subtract. Lesson 19.6
- cpu.weight
- The cgroup v2 file that sets a container's share of CPU when the node is busy. The kubelet derives it from the CPU request. Lesson 19.1
- CRD (CustomResourceDefinition, custom resource)
- CustomResourceDefinition: a way to add a new kind of object to the Kubernetes API, which a controller then acts on. Lesson 19.30
- CreateContainerConfigError
- A pod status when the kubelet cannot build the container from its settings, for example runAsNonRoot with a root image or a missing ConfigMap key. Lesson 19.37
- CSR (certificate signing request, CertificateSigningRequest)
- A certificate signing request: your public key plus the name you want, signed with your private key. In Kubernetes also an API object that an admin approves and the cluster CA signs. Lesson 19.43
- custom metrics (metrics adapter)
- Numbers other than CPU and memory (requests per second, queue length) that an extra add-on serves to the HPA so it can scale on them. Lesson 19.28
- dedicated node (dedicated nodes)
- A node reserved for one kind of work by combining a taint (keeps others off), a toleration (lets the chosen pods on) and a selector (keeps them there). Lesson 19.13
- descheduler
- An optional add-on that evicts running pods so the scheduler can place them better, since Kubernetes itself never rebalances running pods. Lesson 19.15
- embed-certs (--embed-certs, client-certificate-data)
- A kubectl config option that copies certificate and key contents into the kubeconfig instead of storing file paths. Lesson 19.43
- encryption at rest (EncryptionConfiguration)
- The apiserver encrypting Secrets before storing them in etcd, so a stolen disk or backup does not reveal them. Lesson 19.41
- escalation prevention (escalate, bind verb)
- The RBAC rule that you cannot create or bind a role granting more than you already have, unless you hold the special escalate or bind verbs. Lesson 19.30
- etcdctl
- etcd's own command-line client, used to read keys directly, take snapshots and restore them. Lesson 19.41
- eviction (evict, evicted, Evicted)
- The kubelet stopping pods on purpose to save a node that is low on memory or disk. The pod ends as Failed with reason Evicted and its controller creates a replacement elsewhere. Lesson 19.3
- Eviction API
- The API call that asks for a pod to be evicted instead of deleted; the apiserver refuses it if it would break a PDB. kubectl drain uses it, kubectl delete does not. Lesson 19.26
- eviction threshold (memory.available, eviction thresholds)
- The "too little left" line (default: less than 100Mi memory available) below which the kubelet starts evicting pods. Lesson 19.3
- FailedCreate
- The event a ReplicaSet (or Job) records when the apiserver refused to create one of its pods, for example because of a quota. Lesson 19.9
- FailedScheduling
- The event the scheduler writes when it cannot place a pod. It lists, per node, the first rule that rejected it. Lesson 19.18
- failureThreshold (periodSeconds, timeoutSeconds, initialDelaySeconds)
- Probe timing fields: periodSeconds = how often, timeoutSeconds = how long an answer may take, failureThreshold = how many failures in a row before acting, initialDelaySeconds = wait before the first check. Lesson 19.20
- field selector (--field-selector)
- A kubectl filter on an object's fields rather than its labels, for example --field-selector=status.phase=Failed. Lesson 19.3
- filter and score (filter plugin, score plugin, scheduler filters)
- The scheduler's two phases: filters throw out nodes that cannot take the pod, scores rank the rest; the highest score wins. Lesson 19.18
- fsGroup
- A pod securityContext field: the group that owns mounted volumes, so a non-root app can still write to them. Lesson 19.37
- Group
- A group name that comes with a user's credentials (a certificate's O= field, a login token's groups). RBAC can bind roles to groups. Lesson 19.30
- gRPC
- A way for programs to call each other over HTTP/2 using a compact binary format. It has a standard health-check call that probes can use. Lesson 19.20
- Guaranteed
- The safest QoS class: every container has CPU and memory limits equal to its requests. Evicted last, oom_score_adj -997. Lesson 19.3
- host namespaces (hostNetwork, hostPID, hostIPC)
- Pod settings that share the node's own network, process list or files instead of the container's private ones. Baseline forbids them. Lesson 19.39
- HPA (HorizontalPodAutoscaler)
- HorizontalPodAutoscaler: a control loop that changes a Deployment's replica count every 15s so that average usage (for example CPU as a % of requests) stays near a target. Lesson 19.28
- HSM (hardware security module)
- Hardware security module: a tamper-proof device that stores keys and never lets them out. Lesson 19.41
- IgnoredDuringExecution (requiredDuringSchedulingIgnoredDuringExecution, preferredDuringSchedulingIgnoredDuringExecution)
- The part of an affinity rule's name that says it is checked only when the pod is placed; pods already running are never moved when labels change. Lesson 19.11
- immutable Secret
- A Secret or ConfigMap with immutable: true: it cannot be changed, only replaced by a new one with a new name. Lesson 19.41
- impersonation (--as, --as-group, impersonate)
- Sending a request as if you were someone else (kubectl --as=jane). Needs the impersonate permission; the quickest way to test another identity's rights. Lesson 19.30
- JWT (JSON Web Token)
- JSON Web Token: three base64url parts (header.payload.signature). Anyone can read the payload; the signature proves who issued it. Lesson 19.33
- KMS (Key Management Service)
- Key Management Service: an external service that holds encryption keys and does the encrypting, so the key never sits on the node. Lesson 19.41
- krew
- The plugin installer for kubectl; plugins add subcommands such as kubectl who-can. Lesson 19.35
- kube-system
- The namespace where the cluster's own components run (CoreDNS, kube-proxy, the network plugin, the control plane). Lesson 19.18
- kubectl auth can-i (can-i)
- Asks the apiserver whether an action is allowed and prints yes or no (exit code 0 or 1). With --as it checks for someone else; --list shows everything allowed. Lesson 19.35
- kubectl autoscale
- Creates an HPA for a workload, for example kubectl autoscale deployment web --cpu=50% --min=1 --max=10. Lesson 19.28
- kubectl certificate approve (certificate deny, Approved,Issued)
- Records an admin's approval of a CertificateSigningRequest; the controller-manager then signs it (Issued) or refuses it (Failed). Lesson 19.43
- kubectl set resources
- Changes the requests and limits in a workload's pod template, for example --requests=cpu=100m --limits=memory=256Mi. It triggers a rollout. Lesson 19.1
- kubectl top
- Shows current CPU and memory usage of nodes (kubectl top node) or pods (kubectl top pod). Needs metrics-server; the numbers are short averages. Lesson 19.1
- Last State
- The part of kubectl describe pod that shows how the previous run of a container ended: reason, exit code, start and finish times. Lesson 19.6
- limit (limits, resource limit, resources.limits)
- The most CPU or memory a container may use. The kernel enforces it through the cgroup: over the CPU limit you are slowed down, over the memory limit you are killed. Lesson 19.1
- LimitRange
- A namespaced object that fills in default requests and limits for containers that set none, and enforces a min and max per container. Lesson 19.9
- liveness probe (livenessProbe, liveness)
- A probe that asks "is this process stuck beyond repair?". If it fails failureThreshold times in a row, the kubelet kills and restarts the container. Lesson 19.20
- maxSkew (skew)
- In a topology spread constraint: the largest allowed difference between the domain with the most matching pods and the one with the fewest. Lesson 19.15
- maxSurge (maxUnavailable)
- Rolling-update limits: maxSurge = how many extra pods may exist during the update, maxUnavailable = how many may be missing. 1 and 0 means zero downtime. Lesson 19.24
- metrics-server
- A small cluster add-on that collects live CPU and memory usage from every kubelet so that kubectl top (and the autoscaler) can read it. Lesson 19.1
- Mi (mebibyte, Gi, gibibyte)
- Binary size units: 1 Mi = 1024 x 1024 bytes, 1 Gi = 1024 Mi. M and G (without the i) are powers of 1000 and slightly smaller. Lesson 19.1
- millicore (millicores, millicpu)
- One thousandth of a CPU core, written with an m: 250m is a quarter of a core, 1000m is one core. Lesson 19.1
- minReadySeconds
- How long a new pod must stay Ready before a rollout counts it as available and moves on. Lesson 19.24
- MKNOD (CAP_MKNOD)
- The capability to create device files (the special files in /dev). Ordinary apps never need it. Lesson 19.37
- node affinity (nodeAffinity)
- A pod rule that attracts it to nodes with certain labels, either required (a hard filter) or preferred (a weighted score). More expressive than nodeSelector. Lesson 19.11
- node condition (MemoryPressure, DiskPressure, PIDPressure)
- A true/false health flag the kubelet reports on its node, such as Ready or MemoryPressure. kubectl describe node lists them. Lesson 19.3
- node controller (node lifecycle controller)
- A control-plane loop that watches node heartbeats and taints nodes that stop reporting as not-ready or unreachable. Lesson 19.13
- nodeSelector
- A pod field listing node labels the node must have, for example disktype: ssd. The simplest hard placement rule. Lesson 19.11
- noisy neighbour (noisy neighbor, noisy neighbours)
- A workload on a shared node that uses so much CPU, memory or disk that the other workloads on that node slow down. Lesson 19.6
- nominatedNodeName
- The pod status field where the scheduler notes the node it is freeing up for a preempting pod. Lesson 19.18
- NoSchedule (PreferNoSchedule, NoExecute, taint effect)
- Taint effects: NoSchedule keeps new pods off, PreferNoSchedule only tries to, NoExecute also evicts running pods that do not tolerate it. Lesson 19.13
- OIDC (OpenID Connect)
- OpenID Connect: a standard for logging in through a company identity system, which hands out signed tokens saying who you are and which groups you are in. Lesson 19.30
- operator (operators)
- A controller that manages one kind of application or resource for you, usually through its own CRD. Lesson 19.41
- PDB (PodDisruptionBudget, disruption budget, PodDisruptionBudgets)
- PodDisruptionBudget: a rule that says how many pods of a set may be down at once for planned reasons (drains, upgrades). Evictions that would break it are refused. Lesson 19.26
- pod affinity (podAffinity, inter-pod affinity)
- A rule that places a pod in a domain (node, zone) that already runs certain other pods, to keep them together. Lesson 19.15
- pod anti-affinity (podAntiAffinity, anti-affinity)
- A rule that keeps a pod out of domains that already run certain pods, usually its own replicas, so one failure cannot take them all. Lesson 19.15
- Pod Security Admission (PSA, pod-security.kubernetes.io)
- The built-in admission check that applies a Pod Security Standard per namespace, set by namespace labels with enforce, warn and audit modes. Lesson 19.39
- Pod Security Standards
- Three fixed security levels for pods: privileged (anything), baseline (no known escalations), restricted (fully hardened). Lesson 19.39
- policy engine (Kyverno, OPA Gatekeeper, ValidatingAdmissionPolicy)
- An admission add-on that checks your own rules on every object, such as "images only from our registry". Lesson 19.39
- preemption (preempt, preempted, Preempted)
- The scheduler evicting lower-priority pods to make room for a higher-priority pod that does not fit anywhere. Lesson 19.18
- PriorityClass (priorityClassName)
- A cluster-wide object that names a priority number. Pods refer to it by name; higher priority means scheduled first and allowed to preempt lower pods. Lesson 19.18
- privileged
- A container with every capability and access to the node's devices - almost no isolation. Only node agents should use it. Lesson 19.37
- probe (probes, health check)
- A small health check (an HTTP request, a TCP connect or a command) that the kubelet runs against a container every few seconds. Lesson 19.20
- progressDeadlineSeconds (ProgressDeadlineExceeded)
- How long a rollout may make no progress before the Deployment reports Progressing=False with reason ProgressDeadlineExceeded. It does not roll back by itself. Lesson 19.24
- projected volume (projected)
- A volume that combines several sources (a token, a ConfigMap, Downward API fields) into one directory in the pod. Lesson 19.33
- QoS class (QoS, quality of service, qosClass)
- A label Kubernetes computes for every pod from its requests and limits: Guaranteed, Burstable or BestEffort. It decides how safe the pod is when a node runs out of memory. Lesson 19.3
- RBAC (Role-Based Access Control)
- Role-Based Access Control: the Kubernetes permission system. Roles list allowed actions; bindings give roles to users, groups or ServiceAccounts. Lesson 19.30
- readiness probe (readinessProbe, readiness)
- A probe that asks "should this pod get traffic now?". Failing removes the pod from its Service endpoints; it never restarts anything. Lesson 19.20
- readOnlyRootFilesystem
- Makes the container's own filesystem read-only; anything the app must write goes to a volume such as an emptyDir. Lesson 19.37
- Recreate
- A Deployment strategy that stops all old pods before starting new ones - downtime on purpose, for apps that must never run two versions at once. Lesson 19.24
- request (requests, resource request, resources.requests)
- The amount of CPU or memory a container asks to have reserved. The scheduler adds up requests to decide whether a pod fits on a node. Lesson 19.1
- resourceNames
- An RBAC rule field that limits the rule to named objects. Works for get, update, patch and delete, not for list, watch or create. Lesson 19.30
- ResourceQuota
- A namespaced object that caps the total requests, limits and object counts of a namespace. Once it counts a resource, every new pod must declare it. Lesson 19.9
- restart storm
- Many pods being restarted over and over by their own health checks, typically because a liveness probe depends on something outside the pod. Lesson 19.22
- revision (rollout history, revisions)
- One version of a Deployment's pod template, kept as an old ReplicaSet. kubectl rollout history lists them; kubectl rollout undo --to-revision=N goes back to one. Lesson 19.24
- revoke
- Cancelling a certificate before it expires. Kubernetes does not check revocation for client certificates, so a leaked one stays valid until expiry. Lesson 19.43
- Role
- A namespaced list of RBAC rules (verbs on resources). It grants nothing until a binding gives it to someone. Lesson 19.30
- RoleBinding
- Gives a Role or ClusterRole to subjects inside one namespace only. Lesson 19.30
- roleRef
- The field of a binding that says which Role or ClusterRole it grants. It cannot be changed; delete and recreate the binding instead. Lesson 19.30
- rolling update (RollingUpdate)
- The default way a Deployment replaces pods: a few new ones are started, then old ones removed, step by step, so the service stays up. Lesson 19.24
- runAsNonRoot (runAsUser, runAsGroup)
- securityContext fields: runAsUser/runAsGroup set the uid/gid; runAsNonRoot makes the kubelet refuse to start a container that would run as uid 0. Lesson 19.37
- scale subresource
- The small part of the API that changes only an object's replica count. kubectl scale and the HPA both use it. Lesson 19.28
- secrets manager (vault, HashiCorp Vault)
- A dedicated service for storing secrets with access control, audit logs and rotation, outside the cluster. Lesson 19.41
- Secrets Store CSI driver (External Secrets Operator)
- Add-ons that bring secrets from an external secrets manager into pods, as mounted files or as copied Kubernetes Secrets. Lesson 19.41
- securityContext
- The part of a pod or container spec that sets the user it runs as and the privileges it keeps (non-root, read-only filesystem, capabilities, seccomp). Lesson 19.37
- SelfSubjectAccessReview
- The API object behind kubectl auth can-i: a "may I do this?" question the apiserver answers. Lesson 19.35
- ServiceAccount (SA, ServiceAccounts)
- A namespaced identity for programs running in pods. Its RBAC user name is system:serviceaccount:NAMESPACE:NAME. Lesson 19.33
- signerName (signer, kube-apiserver-client)
- The field of a CertificateSigningRequest that says who should sign it; kubernetes.io/kube-apiserver-client issues client certificates the apiserver accepts. Lesson 19.43
- SignerValidationFailure
- The CSR condition reason when the signer refuses an approved request, for example because it asks for a usage (server auth) the signer does not allow.
- singleton
- A program that must only ever run as one copy at a time, for example because it holds a lock. Lesson 19.24
- stabilization window (stabilizationWindowSeconds, ScaleDownStabilized)
- The HPA uses the highest recommendation from this recent window (default 5 min for scale-down), so replicas stay up for a while after load drops. Lesson 19.28
- startup probe (startupProbe)
- A probe that gives a slow-starting app time to boot. Until it succeeds, liveness and readiness do not run; if it runs out of attempts, the container is restarted. Lesson 19.20
- subject (subjects)
- Whoever receives permissions in RBAC: a User, a Group or a ServiceAccount. Lesson 19.30
- subresource (subresources, pods/log, pods/exec)
- A separate part of an object with its own permission, such as pods/log (read logs) or pods/exec (run commands). Lesson 19.30
- taint (taints)
- A "keep out" mark on a node (key=value:Effect). Pods are kept away unless they carry a matching toleration. Lesson 19.13
- throttling (throttled, CPU throttling)
- The kernel pausing a container until the next 100 ms CFS period because it used up its CPU quota. Shows as latency spikes, never as restarts. Lesson 19.6
- toleration (tolerations)
- A pod field that allows the pod onto nodes with a matching taint. It gives permission; it does not send the pod there. Lesson 19.13
- tolerationSeconds
- How long a pod may stay on a node after a NoExecute taint it tolerates appears. Every pod gets 300s for the not-ready and unreachable taints. Lesson 19.13
- Tomcat
- The web server that is built into a typical Spring Boot application and listens on its port (often 8080). Lesson 19.22
- topology spread constraint (topologySpreadConstraints, topology spread)
- A pod rule that keeps matching pods evenly spread over domains, never more than maxSkew apart. Unlike anti-affinity it still runs any number of replicas. Lesson 19.15
- topology.kubernetes.io/zone (availability zone)
- The node label that names the zone (one data-centre building of a cloud region) a node is in. Used to spread pods so one building failing does not take them all. Lesson 19.11
- topologyKey (topology domain)
- The node label that groups nodes into domains for affinity and spread rules: kubernetes.io/hostname makes each node a domain, topology.kubernetes.io/zone each zone. Lesson 19.15
- Unhealthy
- The event reason the kubelet uses when a probe fails. The message says which probe and why: connection refused, a bad status code, or a timeout. Lesson 19.20
- utilization (averageUtilization, CPU utilization)
- For an HPA: usage as a percentage of the pods' requests. 100m used with a 200m request is 50%. No request means no utilization. Lesson 19.28
- verb (verbs)
- The action in an API request: get, list, watch, create, update, patch, delete. RBAC rules list which verbs are allowed. Lesson 19.30
- voluntary disruption (involuntary disruption, voluntary disruptions)
- A pod taken down on purpose (drain, upgrade, autoscaler) as opposed to by accident (node crash, OOM kill). PDBs only limit the voluntary kind. Lesson 19.26
- VPA (VerticalPodAutoscaler)
- VerticalPodAutoscaler: an add-on that recommends or sets a workload's requests (bigger pods) instead of changing the replica count. Lesson 19.28
- x509 (X.509)
- The standard format of TLS certificates. A client certificate proves who the client is, the way a server certificate proves who the server is. Lesson 19.43