2663 terms covering AIOps, DevOps, MLOps, FinOps, observability and cloud-native operations.
Written by AI. Published under human oversight.
Admission Controller
An Admission Controller intercepts API server requests before persistence, enforcing policies or mutating resources. It plays a key role in governance, compliance, and security enforcement within clusters.
Admission Controllers
Plugins that govern and manage how requests to create, update, or delete resources are processed in a Kubernetes cluster, enabling policy enforcement during resource operations.
Affinity and Anti-Affinity
Rules that influence pod scheduling based on node or pod attributes. They enable co-location or separation of workloads for performance, resilience, or compliance reasons.
Affinity and Taint Toleration
Kubernetes pod scheduling mechanisms providing fine-grained node placement control through pod affinity rules, node affinity selectors, and node taints with pod tolerations. These primitives enable workload segregation, high-availability architectures, and dedicated node pools.
API Aggregation Layer
The API Aggregation Layer enables Kubernetes to extend its API by integrating additional API servers. This allows external services to appear as native Kubernetes APIs.
API Server
The front-end component of the Kubernetes control plane that handles all REST commands, serving as the gateway for all the interactions with the cluster.
Cluster
A Kubernetes Cluster is a set of Nodes that run containerized applications managed by Kubernetes. Clusters provide high availability and scalability for applications.
Cluster API (CAPI)
A Kubernetes-native API for declaratively managing cluster lifecycle, infrastructure provisioning, and cluster upgrades across diverse cloud and on-premises environments. CAPI enables infrastructure-as-code patterns for Kubernetes cluster management.
Cluster Autoscaler
Cluster Autoscaler adjusts the number of nodes in a Kubernetes cluster based on pending pods and resource utilization. It integrates with cloud providers to add or remove nodes dynamically.
CNI (Container Network Interface)
CNI is a standard for configuring network interfaces in Linux containers. Kubernetes relies on CNI plugins to provide pod networking, IP assignment, and network policy enforcement.
CNI Plugin (Container Network Interface)
A standardized interface for Kubernetes networking that enables pluggable network implementations such as Calico, Flannel, or Weave. CNI plugins handle pod-to-pod networking, network policies, and overlay network management.
Confidential Containers
Confidential Containers use hardware-based trusted execution environments to protect container workloads and sensitive data during runtime. This emerging Kubernetes security approach enhances isolation against infrastructure-level threats.
ConfigMap
A ConfigMap is a Kubernetes object that provides a way to inject configuration data into Pods, allowing for dynamic configuration changes without modifying container images.
ConfigMap and Secret
Kubernetes objects storing configuration data and sensitive information separately from application code. ConfigMaps hold non-confidential configuration while Secrets store sensitive data like credentials with optional encryption at rest.
Container Image Registry
A centralized repository storing and distributing container images used by Kubernetes nodes for pod deployment. Registry management involves image versioning, vulnerability scanning, and access control policies in production environments.
Container Network Interface (CNI)
Container Network Interface is a specification and set of plugins that configure networking for containers in Kubernetes. CNI plugins handle IP address management, routing, and network policy enforcement.
Container Runtime Interface (CRI)
The Container Runtime Interface defines how Kubernetes communicates with container runtimes like containerd or CRI-O. It enables pluggable runtime implementations without modifying core Kubernetes components.
Container Storage Interface (CSI)
Container Storage Interface is a standard for exposing storage systems to Kubernetes. CSI drivers allow dynamic provisioning, attachment, and management of persistent volumes across different storage providers.
Controller Manager
A core control plane component running multiple controllers that monitor cluster state and drive the current state toward desired state. The controller manager manages Deployments, StatefulSets, DaemonSets, and handles node lifecycle events.
Control Plane
The Control Plane is the component of Kubernetes responsible for the overall management of the cluster, including scheduling, monitoring, and responding to cluster events.
CronJob
A CronJob is a Kubernetes resource that schedules Jobs to run at specified times or intervals, similar to the Unix cron service, enabling automated task execution.
CSI (Container Storage Interface)
CSI is a standardized interface that enables Kubernetes to integrate with external storage systems. It allows dynamic provisioning, attachment, and management of persistent volumes.
Custom Resource Definition (CRD)
A Custom Resource Definition extends the Kubernetes API by allowing users to create custom resource types. CRDs enable platform teams to build Kubernetes-native extensions and operators tailored to specific workloads.
CustomResourceDefinition (CRD)
A Kubernetes API extension mechanism that allows operators to define custom resources beyond the standard built-in resource types. CRDs enable domain-specific abstractions and declarative management of application-specific entities within the cluster.
Custom Resource Definitions (CRD)
Custom Resource Definitions enable users to extend Kubernetes functionality by creating new resource types, allowing for the integration of unique workloads into the Kubernetes lifecycle.
DaemonSet
A DaemonSet is a Kubernetes resource that ensures all or specific Nodes run a copy of a Pod, often utilized for logging, monitoring, or other background tasks.
Deployment
A Deployment is a Kubernetes resource that provides declarative updates for Pods and ReplicaSets, allowing users to define the desired state of an application and manage its scaling and updating process.
eBPF-based Observability
Advanced kernel-level instrumentation using extended Berkeley Packet Filter (eBPF) programs to capture Kubernetes workload behavior, system calls, and network traffic without application or container modifications. eBPF provides deep visibility with minimal overhead.
Ephemeral Containers
Ephemeral Containers are temporary containers added to running pods for debugging and troubleshooting. They do not restart automatically and are not part of the pod's desired state.
etcd
etcd is a distributed key-value store used by Kubernetes to persist cluster state and configuration. It provides strong consistency and high availability for control plane data.
Gateway API
Gateway API is an evolving Kubernetes networking specification that provides more expressive and role-oriented traffic routing than Ingress. It supports advanced routing, multi-tenant configurations, and extensibility.
GitOps for Kubernetes
GitOps is a deployment methodology where Git repositories serve as the source of truth for cluster configuration. Automated controllers reconcile cluster state with declared configurations.
Helm
Helm is a package manager for Kubernetes that simplifies the deployment and management of applications by allowing users to define, install, and upgrade complex resources as charts.
Helm Chart
A Helm Chart is a packaged collection of Kubernetes resource definitions used to deploy applications. Helm simplifies application installation, upgrades, and version management.
Horizontal Pod Autoscaler
Horizontal Pod Autoscaler automatically scales the number of Pod replicas based on observed CPU utilization or other select metrics, helping maintain application performance and availability.
Horizontal Pod Autoscaler (HPA)
HPA automatically scales the number of pod replicas based on observed CPU, memory, or custom metrics. It ensures applications handle fluctuating workloads efficiently.
HorizontalPodAutoscaler (HPA)
A Kubernetes controller that automatically scales the number of pod replicas based on observed metrics like CPU utilization or custom metrics. HPA enables responsive capacity management and cost optimization in dynamic workloads.
Ingress
Ingress is a Kubernetes resource used to manage external access to services within a cluster, facilitating URL routing and SSL termination for improved application exposure.
Ingress Controller
An Ingress Controller implements the rules defined in Ingress resources. It configures load balancers or proxies such as NGINX or HAProxy to route external traffic.
Init Container
An Init Container runs before the main application containers in a pod. It is used for setup tasks such as configuration, dependency checks, or data initialization.
Job
A Job in Kubernetes manages the execution of Pods that run to completion, ensuring a certain number of successful executions for tasks that need to run temporarily.
kubeadm
A tool for easily deploying and managing Kubernetes clusters. It provides a simple way to create Kubernetes control plane and worker nodes using best practices.
kube-apiserver
The central control plane component in Kubernetes that exposes the API server, validates requests, and persists cluster state to etcd. The API server is the core interface through which all cluster operations are performed.
Kubeconfig
Kubeconfig is a configuration file used by kubectl, the command-line tool for interacting with Kubernetes clusters. It contains information about clusters, users, and settings necessary to manage and administer Kubernetes resources.
Kubectl
Kubectl is the command-line tool for interacting with Kubernetes clusters, facilitating operations such as deploying applications, inspecting resources, and viewing logs.
Kubelet
Kubelet is an agent that runs on each Node in a Kubernetes cluster, responsible for managing the lifecycle of Pods, ensuring they are running and healthy according to their specifications.
Kube-Proxy
Kube-Proxy manages network rules on each node to enable service discovery and load balancing. It routes traffic to the appropriate backend pods based on service definitions.
Kubernetes API Server
The Kubernetes API Server is the central management entity that receives and processes REST requests, acting as the main interface for communication between clients and the Kubernetes cluster.
Kubernetes Dashboard
The Kubernetes Dashboard is a web-based user interface for managing Kubernetes clusters, providing visualization and management of resources and applications.
Kubernetes Event-driven Autoscaling (KEDA)
An extension that enables pod autoscaling based on external event sources (message queues, databases, webhooks) beyond standard metrics, supporting event-driven architecture patterns. KEDA connects Kubernetes scaling to business event streams and asynchronous workloads.
Kubernetes Federation (KubeFed)
Kubernetes Federation enables management of multiple clusters from a single control plane. It supports workload distribution and failover across regions. Federation is useful for multi-cluster and hybrid deployments.
Kubernetes Ingress
Ingress manages external HTTP and HTTPS access to services within a cluster. It provides routing, SSL termination, and load balancing through Ingress controllers.
Kubernetes Operator Pattern
The Operator pattern automates application lifecycle management using custom controllers and CRDs. Operators encode operational knowledge into software to manage complex stateful applications within Kubernetes.
Kubernetes Scheduler
The Kubernetes Scheduler assigns pods to nodes based on resource requirements, constraints, and policies. It considers factors such as affinity rules, taints, and resource availability.
Kubernetes Scheduling Framework
An extensible architecture within the Kubernetes scheduler that allows custom plugins to influence pod placement decisions through filter, score, and bind stages. The scheduling framework enables organization-specific scheduling logic for specialized workload requirements.
Kustomize
Kustomize is a configuration management tool that customizes Kubernetes YAML manifests without templating. It supports overlays for environment-specific deployments.
Kyverno
A policy engine for Kubernetes that validates, mutates, and generates resources through policies written in YAML or JSON, providing an alternative to traditional admission controllers. Kyverno simplifies policy implementation for compliance, security, and operational governance.
LimitRange
LimitRange enforces minimum and maximum resource constraints for Pods and containers in a Namespace. It can also set default resource requests and limits. This ensures consistent resource governance.
Multi-Cluster Federation
An approach for managing and coordinating multiple Kubernetes clusters as a unified system. It supports workload distribution, failover, and global service discovery.
Mutating Webhook
A Mutating Webhook is a dynamic admission controller that modifies Kubernetes objects during creation or update. It is commonly used for injecting sidecars, enforcing defaults, or applying security policies.
Namespace
A Namespace in Kubernetes provides a way to partition resources within a cluster, allowing multiple virtual clusters to exist within the same physical cluster and providing access control and resource management.
Namespace Isolation
Namespace Isolation separates workloads and resources within a Kubernetes cluster for organizational or security purposes. It allows teams to apply policies, quotas, and access controls independently.
Networking Policies
Networking Policies in Kubernetes define how Pods communicate with each other and other network endpoints, allowing for fine-grained control over traffic flow and security.
Network Policies
Kubernetes resources that control the traffic flow between Pods based on rules defined by the user. Network Policies enhance security by limiting communication among Pods.
Network Policy
A Network Policy defines how pods communicate with each other and external endpoints. It enhances cluster security by enforcing traffic segmentation rules.
NetworkPolicy
A Kubernetes resource that defines fine-grained ingress and egress traffic rules between pods and external endpoints, implementing microsegmentation and zero-trust networking. NetworkPolicies are critical for security enforcement and compliance.
Node
A Node is a physical or virtual machine that runs Kubernetes workloads. Each Node contains the necessary services to run Pods and is managed by the Kubernetes control plane.
Node Affinity
Node Affinity defines rules that influence pod scheduling based on node labels. It enables both soft and hard constraints for workload placement.
Node Affinity and Pod Affinity
Kubernetes scheduling constraints that influence pod placement based on node labels or pod co-location requirements, enabling workload optimization and resource utilization patterns. Affinity rules support performance tuning, compliance, and high-availability architectures.
Open Policy Agent (OPA)
Open Policy Agent is a policy engine used to enforce governance and compliance rules within Kubernetes environments. It evaluates policies declaratively and integrates with admission controllers and service meshes.
Operator Pattern
The Operator Pattern is a method of packaging, deploying, and managing complex applications on Kubernetes using custom controllers. Operators encode operational knowledge into software to automate lifecycle tasks such as upgrades, backups, and scaling.
Operators
An extension of the Kubernetes API that manages complex stateful applications through custom resources, helping automate the deployment and lifecycle management of applications.
Persistent Volume Claim (PVC)
A Persistent Volume Claim is a request for storage resources within Kubernetes. It abstracts underlying storage systems and allows pods to consume persistent storage dynamically.
Persistent Volume (PV)
A Persistent Volume (PV) is a storage resource in Kubernetes that provides a way to manage storage independently of the lifecycle of a Pod. PVs enable the use of external storage systems such as cloud storage, ensuring data persistence beyond Pod deletions.
Persistent Volume (PV) and Persistent Volume Claim (PVC)
Kubernetes abstractions decoupling storage provisioning from consumption; PVs represent physical storage resources while PVCs are requests for storage by pods. This separation enables dynamic provisioning, multi-tenancy, and independent storage lifecycle management.
PersistentVolume (PV) and PersistentVolumeClaim (PVC)
Kubernetes abstractions that decouple storage provisioning from consumption, allowing pods to request storage without knowing underlying infrastructure details. PV/PVC patterns enable portable, declarative storage management across diverse backends.
Pod
A Pod is the smallest deployable unit in Kubernetes, encapsulating one or more containers that share network and storage resources. It serves as the basic building block for deploying applications.
Pod Disruption Budget (PDB)
A Pod Disruption Budget defines the minimum number or percentage of pods that must remain available during voluntary disruptions such as maintenance or upgrades. It helps maintain application availability during cluster operations.
Pod Security Admission (PSA)
A built-in admission controller that enforces pod security standards at the namespace level. It replaces Pod Security Policies with predefined security profiles.
Pod Security Standards (PSS)
Pod Security Standards define security best practices for pod configurations, such as privilege escalation and host access restrictions. They help enforce consistent security controls across namespaces.
RBAC (Role-Based Access Control)
A Kubernetes authorization model using Roles, ClusterRoles, RoleBindings, and ClusterRoleBindings to enforce fine-grained permission policies. RBAC defines which users or service accounts can perform specific actions on cluster resources.
ReplicaSet
A ReplicaSet is a Kubernetes object that ensures a specified number of Pod replicas are running at any given time, providing high availability and load balancing.
Resource Limits
Resource Limits in Kubernetes define the maximum resources (CPU and memory) that a container can consume within a Pod. Setting these limits helps in effective resource management and ensures fair distribution among applications.
Resource Quota
A Resource Quota limits the total resource consumption within a Namespace. It controls usage of CPU, memory, storage, and object counts. Quotas help prevent resource exhaustion in multi-tenant clusters.
Resource Quotas
Resource Quotas in Kubernetes manage the allocation of resources (CPU and memory) for Namespaces, allowing administrators to limit resource consumption by teams or applications.
Resource Requests and Limits
Kubernetes pod specifications defining CPU and memory resource guarantees (requests) and upper bounds (limits) for containers. Proper resource declaration enables scheduler optimization, prevents node oversubscription, and supports Quality of Service tiers.
Role-Based Access Control (RBAC)
RBAC regulates access to Kubernetes resources based on roles assigned to users or service accounts. It ensures secure and granular authorization within clusters.
RuntimeClass
RuntimeClass allows administrators to select different container runtimes for pods within a cluster. It supports use cases such as sandboxed containers or specialized runtime environments.
Scheduler
The Kubernetes control plane component responsible for assigning pods to nodes based on resource requirements, affinity rules, and constraints. The scheduler optimizes cluster utilization and ensures workloads respect specified placement policies.
Secret
A Secret is a Kubernetes resource designed to store sensitive data, such as passwords and tokens, in a secure manner. Secrets are base64 encoded and can be used by Pods without exposing the data in environment variables.
Secrets
Secrets in Kubernetes are used to store and manage sensitive information, such as passwords or API keys, providing a secure way to supply credentials to Pods without hardcoding them.
Service
A Service is an abstraction in Kubernetes that defines a logical set of Pods and a policy for accessing them, enabling load balancing and stable network identities for application components.
ServiceAccount
A ServiceAccount is a special type of Kubernetes account used by Pods to interact with the Kubernetes API. It provides a way to manage permissions and security for different application components.
Service Discovery
Service Discovery in Kubernetes refers to the mechanisms that allow applications to discover and connect to service endpoints dynamically. It simplifies the communication between microservices within a cluster.
Sidecar Container
A Sidecar Container runs alongside the main container within the same pod to provide supporting functionality. Common use cases include logging, proxying, and service mesh integration.
StatefulSet
A StatefulSet is a Kubernetes controller designed to manage the deployment of stateful applications, providing guaranteed ordering and uniqueness for each instance.
Taint and Toleration
Taints are applied to nodes to repel certain pods, while tolerations allow specific pods to be scheduled on those nodes. This mechanism supports workload isolation and specialized node usage.
Taint and Tolerations
Taints and Tolerations are mechanisms in Kubernetes used to control which Pods can be scheduled on specific nodes. Taints prevent Pods from being scheduled on nodes, while tolerations allow Pods to tolerate those taints.
Taints and Tolerations
Taints are applied to nodes to repel certain pods, while tolerations allow pods to be scheduled on tainted nodes. Together, they provide fine-grained workload placement control.
Tiller
Tiller was the server-side component of Helm, a package manager for Kubernetes that provided a way to install and manage Kubernetes applications. Though Tiller has been deprecated in Helm 3, its concept was pivotal in managing complex Kubernetes applications.