Kubernetes Glossary

An annotation is a key-value tag you can add to any Kubernetes object. It stores extra information that tools or systems might need but isn’t used to identify the object itself. Unlike labels, annotations can hold longer text and special characters.

An API group organizes related paths in the Kubernetes API. You can turn them on or off through the API server’s settings. Each group helps extend the API by keeping different versions and types of resources organized.

The API server is the central point of contact in a Kubernetes cluster. It takes requests, updates cluster state, and talks to other components. You can scale it out by running multiple instances. Its main job is to provide the Kubernetes API.

In Kubernetes, this term refers to the actual containerized software running on the platform. These can be web services, APIs, databases, or any other kind of software, packaged into containers and managed by Kubernetes.

cgroups are a Linux feature used in Kubernetes to manage how much CPU, memory, and other resources a group of processes can use. They help keep apps from using too much and affecting others.

A cluster is a group of machines (nodes) that run your containers. It has at least one worker node and a control plane that manages the system. Clusters help apps stay available and resilient, even if some nodes fail.

A container is a small, portable package that holds an app and everything it needs to run. It makes moving apps between systems easier and ensures they work the same way everywhere.

These are name=value pairs passed into containers. They give useful details like file paths or service locations. Apps inside the container can use them to find what they need to work correctly.

The container runtime is the part of Kubernetes that starts and runs containers. It makes sure containers launch and stay healthy. Kubernetes works with runtimes like containerd and CRI-O. 

The CRI is a standard way for Kubernetes to talk to container runtimes. It allows kubelet, which runs on each node, to manage containers without being tied to one specific runtime.

The control plane is the brain of your Kubernetes cluster. It makes decisions, tracks what’s happening, and keeps everything running as expected. It includes several parts like the API server, scheduler, and controller manager.

A controller watches your cluster and makes sure things match your desired setup. If something changes, the controller reacts to fix it. For example, if a Pod crashes, a controller can restart it.

CRDs let you create your own types of resources in Kubernetes. If the built-in types don’t fit your needs, you can define a custom one to add new features without changing the core system.

A DaemonSet ensures that a copy of a specific Pod runs on each (or selected) node. It’s commonly used for background tools like logging or monitoring agents that need to be on every machine.

The data plane provides the computing power and storage needed to run containers. It includes nodes and the network that connects them, and it’s where the actual work happens.

A Deployment manages how many copies of a Pod run in your cluster. It handles updates and ensures the right number of Pods are always up. It’s good for stateless apps that don’t need to keep data.

Device plugins let Pods use special hardware, like GPUs or network cards. They help Kubernetes know which node has which resources and allow Pods to access them safely.

A disruption happens when one or more Pods stop running. It can be planned (like maintenance) or unplanned (like a node crash). Kubernetes tries to keep your apps stable during these events.

Docker is a popular tool that creates and runs containers. It uses Linux features to keep apps separate from each other, so you can run many containers on the same machine without conflict.

Dockershim was a part of Kubernetes that let it work with Docker as a container runtime. It was removed starting in version 1.24, as Kubernetes now uses other runtimes that follow the CRI standard.

Draining a node means safely moving Pods off it before doing maintenance or removing it. Kubernetes makes sure the Pods are rescheduled elsewhere without breaking your app.

A duration is a way to tell Kubernetes how long something should last. It’s written using time units like “s” for seconds or “m” for minutes, for example, 1m30s means 1 minute and 30 seconds.

These are temporary containers added to a running Pod for tasks like debugging. They don’t run with the app by default and aren’t used for regular workloads.

An event is a message about something that happened in your cluster—like a Pod starting or failing. Events help you track changes and troubleshoot problems.

Extensions are add-ons that enhance Kubernetes by adding support for new hardware or features. They are often pre-installed in managed clusters and rarely need manual setup.

Feature gates are switches that turn certain Kubernetes features on or off. You can use them to test new features before they become default or to disable features you don’t need.

A finalizer is a setting that stops Kubernetes from deleting a resource right away. It waits until some cleanup steps are finished, then removes the object fully.

Garbage collection in Kubernetes is the automatic cleanup of unused resources, like old Pods or images. It keeps your cluster clean and efficient.

The Horizontal Pod Autoscaler automatically adjusts the number of Pods in a deployment or replica set based on real-time metrics like CPU or memory usage. This helps keep applications responsive and efficient by scaling up during high demand and scaling down when traffic is low.

A container image holds all the files and code needed to run an app. Kubernetes pulls these images from a registry and runs them inside containers.

Init containers are special containers that run before the main containers in a Pod. They do setup tasks like loading configs or waiting for services, and must finish before the app starts.

A Job runs a task once or a set number of times until it finishes successfully. It’s ideal for batch work or one-time operations like data processing or backup.

KEDA is a Kubernetes component that lets you scale applications based on events, not just CPU or memory. It works with tools like Prometheus, Kafka, or Azure Queue to trigger scaling based on real-time activity, making it ideal for serverless and event-driven workloads.  https://keda.sh/

This component runs all the built-in Kubernetes controllers. Though each controller is its own process logically, they’re bundled together and run as a single program.

Kubernetes is an open-source platform that automates the deployment, scaling, and management of containerized applications. It helps developers run software reliably across clusters of machines, whether in the cloud or on-premises.

kube-proxy handles network traffic inside your cluster. It creates rules to route requests to the right Pod, helping Services work smoothly across nodes.

kubectl is the main command-line tool for interacting with Kubernetes. It lets you create, inspect, and manage cluster resources by talking to the API server.

Kubelet runs on each node and ensures that the containers described in a PodSpec are running and healthy. It only manages containers started by Kubernetes itself.

This API is how users and tools communicate with the Kubernetes system. It exposes REST endpoints that control the desired state and configuration of all cluster resources.

Labels are simple key-value pairs used to tag Kubernetes objects. They help you organize and select items like Pods or Services based on shared attributes.

LimitRange sets upper and lower limits on how much CPU or memory a Pod or container can use. It helps manage resource usage within a specific namespace.

Logging captures output from your apps or system components. These logs help you track behavior, find bugs, and understand what’s happening inside your cluster.

A manifest is a configuration file written in YAML or JSON. It tells Kubernetes what you want—like which Pods to run or how Services should behave—and helps keep the system in your desired state.

“Master” is an older term for the machine(s) that run Kubernetes control plane components. Today, it’s often replaced with “control plane node” to reflect modern best practices.

Minikube is a tool for running a Kubernetes cluster locally on your machine. It’s great for learning, testing, or developing apps in a lightweight environment.

A mirror Pod is created by the kubelet to represent a static Pod in the Kubernetes API. It shows up in the system, but you can’t manage it through the API like regular Pods.

In Kubernetes, a name is a unique string that identifies a resource like a Pod or Service within a namespace. Once deleted, that name can be reused for a new object.

A namespace divides cluster resources into logical groups. It helps organize your workloads and control access, especially when multiple teams share the same cluster.

A node is a machine—virtual or physical—that runs Pods. Each node has a container runtime, kubelet, and kube-proxy to support workloads managed by the control plane.

A Node Pool is a group of worker nodes within a Kubernetes cluster that share the same configuration, such as instance type or region. You can use multiple node pools to run different types of workloads—for example, separating general apps from those that need GPUs or more memory.

Objects in Kubernetes are the building blocks of your cluster. They define your desired state—for example, running a Pod or exposing an app—and Kubernetes works to match that state.

A Pod is the smallest deployable unit in Kubernetes. It typically runs one main container and may include sidecars. All containers in a Pod share storage and network settings.

A Pod Disruption Budget is a Kubernetes setting that controls how many Pods can be unavailable during voluntary disruptions, such as node maintenance or updates. It helps maintain application availability by ensuring that a minimum number of replicas stay running, even when changes are made to the cluster.

The Pod lifecycle describes how a Pod moves through phases like Pending, Running, Succeeded, or Failed. It shows the status of the Pod during its lifetime.

Pod Security Policies were used to control security settings for Pods, like allowed users or volume types. They were removed in Kubernetes v1.25 and replaced by newer tools like Pod Security Admission.

Kubernetes uses Quality of Service (QoS) classes to rank Pods based on their resource needs. These classes—Guaranteed, Burstable, and BestEffort—help the system make decisions about scheduling and eviction.

Quantities in Kubernetes let you express numbers with units, like CPU and memory. You can use SI suffixes such as m (milli), Gi (gibibyte), or k (kilo) to describe both small and large values.

RBAC controls who can do what in a cluster. It uses Roles and ClusterRoles to define permissions, and bindings to assign them to users or service accounts at namespace or cluster level.

A replica is one instance of a Pod. Having multiple replicas helps your app stay online, balance traffic, and recover from failures quickly.

A ReplicaSet keeps a specific number of Pods running at all times. If one fails, it starts another. Deployments use ReplicaSets behind the scenes to manage your app’s scaling.

Resource quotas let you cap how much CPU, memory, or how many objects a namespace can use. This prevents any team or app from taking up too much space in a shared cluster.

A selector lets you find resources based on labels. It’s used to match things like Pods to a Service or filter objects when querying the API.

A Service gives network access to one or more Pods. It keeps track of which Pods match its label selector, and routes traffic to the right ones, even as Pods come and go.

A ServiceAccount gives Pods an identity when they talk to the Kubernetes API. If you don’t set one, the default account for the namespace is used automatically.

Shuffle-sharding is a technique for spreading requests across multiple queues. It reduces the risk of one high-traffic user overwhelming others by randomly assigning each request to a small, unique group of queues.

A sidecar container runs alongside your main container in the same Pod. It provides support features like logging, syncing, or proxying without being part of the main app logic.

The spec is the part of a Kubernetes object that defines what you want. It tells Kubernetes the desired setup, like how many replicas or which image to use for your Pods or Services.

StatefulSets manage Pods that need stable names or persistent storage. Unlike Deployments, each Pod keeps its identity and storage even after restarts.

A static Pod is created and managed directly by the kubelet on a node, not by the control plane. It doesn’t support some features like ephemeral containers.

A taint is a setting on a node that blocks Pods from being scheduled there unless they have a matching toleration. It’s a way to protect special-purpose nodes.

A toleration allows a Pod to run on a node that has a taint. It doesn’t force scheduling, but it gives permission to match that node if needed.

UID is a unique ID that Kubernetes gives to each object. It helps track resources over time, even if names are reused or objects are recreated.

A volume is a storage space that containers in a Pod can use. It keeps data even if a container restarts, and can be backed by local disks, cloud storage, or network systems.

A watch lets you monitor changes to Kubernetes objects in real time. Instead of constantly asking for updates, a watch sends events when something changes.