⎈ k8s knowledge compiler

Docs

The full compiled knowledge graph, indexed by node. Each page is a static, server-rendered knowledge card with its synthesized body, provenance, and typed relationships (rendered as links to the other static pages). No runtime LLM is involved in serving this content.

Search the graph →

Glossary terms (163)

  • Add-ons — Resources that extend the functionality of Kubernetes.
  • Admission Controller — A piece of code that intercepts requests to the Kubernetes API server prior to persistence of the object.
  • Affinity — Rules used by the scheduler to determine where to place pods
  • Aggregation Layer — The aggregation layer lets you install additional Kubernetes-style APIs in your cluster.
  • Annotation — A key-value pair that is used to attach arbitrary non-identifying metadata to objects.
  • API Group — A set of related paths in the Kubernetes API.
  • API resource — A Kubernetes entity, representing an endpoint on the Kubernetes API server.
  • API server — Control plane component that serves the Kubernetes API.
  • API-initiated eviction — API-initiated eviction is the process by which you use the Eviction API to create an Eviction object that triggers graceful pod termination.
  • App Container — A container used to run part of a workload. Compare with init container.
  • Application Architect — A person responsible for the high-level design of an application.
  • Application Developer — A person who writes an application that runs in a Kubernetes cluster.
  • Applications — The layer where various containerized applications run.
  • Approver — A person who can review and approve Kubernetes code contributions.
  • cAdvisor — Tool that provides understanding of the resource usage and performance characteristics for containers
  • Certificate — A cryptographically secure file used to validate access to the Kubernetes cluster.
  • cgroup (control group) — A group of Linux processes with optional resource isolation, accounting and limits.
  • CIDR — CIDR is a notation for describing blocks of IP addresses and is used heavily in various networking configurations.
  • CLA (Contributor License Agreement) — Terms under which a contributor grants a license to an open source project for their contributions.
  • Cloud Controller Manager — Control plane component that integrates Kubernetes with third-party cloud providers.
  • Cloud Native Computing Foundation (CNCF) — The Cloud Native Computing Foundation is an organization that promotes and supports the development of cloud-native technologies.
  • Cloud Provider — An organization that offers a cloud computing platform.
  • Cluster — A set of worker machines, called nodes, that run containerized applications. Every cluster has at least one worker node.
  • Cluster Architect — A person who designs infrastructure that involves one or more Kubernetes clusters.
  • Cluster Infrastructure — The infrastructure layer provides and maintains VMs, networking, security groups and others.
  • Cluster Operations — The work involved in managing a Kubernetes cluster.
  • Cluster Operator — A person who configures, controls, and monitors clusters.
  • Code Contributor — A person who develops and contributes code to the Kubernetes open source codebase.
  • Common Expression Language — An expression language that's designed to be safe for executing user code.
  • Condition — A condition represents the current state of a Kubernetes resource, providing information about whether certain aspects of the resource are true.
  • ConfigMap — An API object used to store non-confidential data in key-value pairs. Can be consumed as environment variables, command-line arguments, or configuration files in a volume.
  • Container — A lightweight and portable executable image that contains software and all of its dependencies.
  • Container Device Interface (CDI) — A CNCF specification for describing device configuration that container runtimes apply when creating containers.
  • Container Environment Variables — Container environment variables are name=value pairs that provide useful information into containers running in a Pod.
  • Container Lifecycle Hooks — The lifecycle hooks expose events in the container management lifecycle and let the user run code when the events occur.
  • Container network interface (CNI) — Container network interface (CNI) plugins are a type of Network plugin that adheres to the appc/CNI specification.
  • Container Runtime — The container runtime is the software that is responsible for running containers.
  • Container Runtime Interface (CRI) — Protocol for communication between the kubelet and the local container runtime.
  • Container Storage Interface (CSI) — The Container Storage Interface (CSI) defines a standard interface to expose storage systems to containers.
  • containerd — A container runtime with an emphasis on simplicity, robustness and portability
  • Contributor — Someone who donates code, documentation, or their time to help the Kubernetes project or community.
  • Control Plane — The container orchestration layer that exposes the API and interfaces to define, deploy, and manage the lifecycle of containers.
  • Controller — A control loop that watches the shared state of the cluster through the apiserver and makes changes attempting to move the current state towards the desired state.
  • CRI-O — A lightweight container runtime specifically for Kubernetes
  • CronJob — A repeating task (a Job) that runs on a regular schedule.
  • CustomResourceDefinition — Custom code that defines a resource to add to your Kubernetes API server without building a complete custom server.
  • DaemonSet — Ensures a copy of a Pod is running across a set of nodes in a cluster.
  • Data Plane — The layer that provides capacity such as CPU, memory, network, and storage so that the containers can run and connect to a network.
  • Deployment — Manages a replicated application on your cluster.
  • Developer (disambiguation) — May refer to: Application Developer, Code Contributor, or Platform Developer.
  • Device — Any resource that's directly or indirectly attached your cluster's nodes, like GPUs or circuit boards.
  • Device Plugin — Software extensions to let Pods access devices that need vendor-specific initialization or setup
  • DeviceClass — A category of devices in the cluster. Users can claim specific devices in a DeviceClass.
  • Disruption — An event that leads to Pod(s) going out of service
  • Docker — Docker is a software technology providing operating-system-level virtualization also known as containers.
  • Dockershim — A component of Kubernetes v1.23 and earlier, which allows Kubernetes system components to communicate with Docker Engine.
  • Downstream (disambiguation) — May refer to: code in the Kubernetes ecosystem that depends upon the core Kubernetes codebase or a forked repo.
  • Downward API — A mechanism to expose Pod and container field values to code running in a container.
  • Drain — Safely evicts Pods from a Node to prepare for maintenance or removal.
  • Duration — A string value representing an amount of time.
  • Dynamic Resource Allocation — A Kubernetes feature for requesting and sharing resources, like hardware accelerators, among Pods.
  • Dynamic Volume Provisioning — Allows users to request automatic creation of storage Volumes.
  • Endpoints — (Deprecated) API representing endpoints of a Service
  • EndpointSlice — EndpointSlices track the IP addresses of Pods for Services.
  • Ephemeral Container — A type of container type that you can temporarily run inside a Pod
  • etcd — Consistent and highly-available key value store used as backing store of Kubernetes for all cluster data.
  • Event — Kubernetes objects that describe some state change in the cluster.
  • Eviction — Process of terminating one or more Pods on Nodes
  • Extensions — Extensions are software components that extend and deeply integrate with Kubernetes to support new types of hardware.
  • Feature gate — A way to control whether or not a particular Kubernetes feature is enabled.
  • Finalizer — A namespaced key that tells Kubernetes to wait until specific conditions are met before it fully deletes an object marked for deletion.
  • FlexVolume — FlexVolume is a deprecated interface for creating out-of-tree volume plugins. The {{< glossary_tooltip text="Container Storage Interface" term_id="csi" >}} is a newer interface that addresses several problems with FlexVolume.
  • Garbage Collection — A collective term for the various mechanisms Kubernetes uses to clean up cluster resources.
  • Gateway API — An API for modeling service networking in Kubernetes.
  • Glossary — A centralized repository of terms and definitions used within a project or organization.
  • Group Version Resource — The API group, API version and name of a Kubernetes API.
  • Helm Chart — A package of pre-configured Kubernetes configurations that can be managed with the Helm tool.
  • Horizontal Pod Autoscaler — Object that automatically scales the number of pod replicas based on targeted resource utilization or custom metric targets.
  • HostAliases — A HostAliases is a mapping between the IP address and hostname to be injected into a Pod's hosts file.
  • Image — Stored instance of a container that holds a set of software needed to run an application.
  • Immutable Infrastructure — Immutable Infrastructure refers to computer infrastructure (virtual machines, containers, network appliances) that cannot be changed once deployed
  • Ingress — An API object that manages external access to the services in a cluster, typically HTTP.
  • Init Container — One or more initialization containers that must run to completion before any app containers run.
  • Istio — An open platform (not Kubernetes-specific) that provides a uniform way to integrate microservices, manage traffic flow, enforce policies, and aggregate telemetry data.
  • Job — A finite or batch task that runs to completion.
  • JSON Web Token (JWT) — A means of representing claims to be transferred between two parties.
  • kOps (Kubernetes Operations) — kOps will not only help you create, destroy, upgrade and maintain production-grade, highly available, Kubernetes cluster, but it will also provision the necessary cloud infrastructure.
  • kube-controller-manager — Control Plane component that runs controller processes.
  • kube-proxy — `kube-proxy` is a network proxy that runs on each node in the cluster.
  • kube-scheduler — Control plane component that watches for newly created pods with no assigned node, and selects a node for them to run on.
  • Kubeadm — A tool for quickly installing Kubernetes and setting up a secure cluster.
  • Kubectl — A command line tool for communicating with a Kubernetes cluster.
  • Kubelet — An agent that runs on each node in the cluster. It makes sure that containers are running in a pod.
  • Kubernetes API — The application that serves Kubernetes functionality through a RESTful interface and stores the state of the cluster.
  • Label — Tags objects with identifying attributes that are meaningful and relevant to users.
  • LimitRange — Provides constraints to limit resource consumption per Containers or Pods in a namespace.
  • Logging — Logs are the list of events that are logged by cluster or application.
  • Managed Service — A software offering maintained by a third-party provider.
  • Manifest — A serialized specification of one or more Kubernetes API objects.
  • Master — Legacy term, used as synonym for nodes running the control plane.
  • Member — A continuously active contributor in the K8s community.
  • Minikube — A tool for running Kubernetes locally.
  • Mirror Pod — An object in the API server that tracks a static pod on a kubelet.
  • Mixed Version Proxy (MVP) — Feature that lets a kube-apiserver proxy a resource request to a different peer API server.
  • Name — A client-provided string that refers to an object in a resource URL, such as `/api/v1/pods/some-name`.
  • Namespace — An abstraction used by Kubernetes to support isolation of groups of resources within a single cluster.
  • Network Policy — A specification of how groups of Pods are allowed to communicate with each other and with other network endpoints.
  • Node — A node is a worker machine in Kubernetes.
  • Node-pressure eviction — Node-pressure eviction is the process by which the kubelet proactively fails pods to reclaim resources on nodes.
  • Object — An entity in the Kubernetes system, representing part of the state of your cluster.
  • Operator pattern — A specialized controller used to manage a custom resource
  • Persistent Volume — API object that represents a piece of storage in the cluster.
  • Persistent Volume Claim — Claims storage resources defined in a PersistentVolume so that it can be mounted as a volume in a container.
  • Platform Developer — A person who customizes the Kubernetes platform to fit the needs of their project.
  • Pod — A Pod represents a set of running containers in your cluster.
  • Pod Disruption — The process by which Pods on Nodes are terminated either voluntarily or involuntarily.
  • Pod Disruption Budget — An object that limits the number of Pods of a replicated application that are down simultaneously from voluntary disruptions.
  • Pod Lifecycle — The sequence of states through which a Pod passes during its lifetime.
  • Pod Priority — Pod Priority indicates the importance of a Pod relative to other Pods.
  • Pod Security Policy — Removed API that enforced Pod security restrictions.
  • PodGroup — A PodGroup represents a set of Pods with common scheduling policy and constraints.
  • PodTemplate — A template for creating Pods.
  • Preemption — Preemption logic in Kubernetes helps a pending Pod to find a suitable Node by evicting low priority Pods existing on that Node.
  • PriorityClass — A mapping from a class name to the scheduling priority that a Pod should have.
  • Probe — A check performed periodically by the kubelet on a container in a Pod.
  • Proxy — An application acting as an intermediary between clients and servers
  • QoS Class — QoS Class (Quality of Service Class) provides a way for Kubernetes to classify pods within the cluster into several classes and make decisions about scheduling and eviction.
  • Quantity — A whole-number representation of small or large numbers using SI suffixes.
  • RBAC (Role-Based Access Control) — Manages authorization decisions, allowing admins to dynamically configure access policies through the Kubernetes API.
  • Replica — Replicas are copies of pods, ensuring availability, scalability, and fault tolerance by maintaining identical instances.
  • ReplicaSet — ReplicaSet ensures that a specified number of Pod replicas are running at one time
  • ReplicationController — A (deprecated) API object that manages a replicated application.
  • Resource (infrastructure) — A defined amount of infrastructure available for consumption (CPU, memory, etc).
  • ResourceClaim — Describes the resources that a workload needs, such as devices. ResourceClaims can request devices from DeviceClasses.
  • ResourceClaimTemplate — Defines a template for Kubernetes to create ResourceClaims. Used to provide per-Pod or per-PodGroup access to separate, similar resources.
  • ResourceQuota — Provides constraints that limit aggregate resource consumption per namespace.
  • ResourceSlice — Represents one or more infrastructure resources, like devices, in a pool of similar resources.
  • Reviewer — A person who reviews code for quality and correctness on some part of the project.
  • Secret — Stores sensitive information, such as passwords, OAuth tokens, and ssh keys.
  • Security Context — The securityContext field defines privilege and access control settings for a Pod or container.
  • Selector — Allows users to filter a list of resources based on labels.
  • Service — A way to expose an application running on a set of Pods as a network service.
  • Service Catalog — A former extension API that enabled applications running in Kubernetes clusters to easily use external managed software offerings, such as a datastore service offered by a cloud provider.
  • ServiceAccount — Provides an identity for processes that run in a Pod.
  • Shuffle-sharding — A technique for assigning requests to queues that provides better isolation than hashing modulo the number of queues.
  • Sidecar Container — An auxilliary container that stays running throughout the lifecycle of a Pod.
  • SIG (special interest group) — Community members who collectively manage an ongoing piece or aspect of the larger Kubernetes open source project.
  • Spec — Field in Kubernetes manifests that defines the desired state or configuration.
  • StatefulSet — A StatefulSet manages deployment and scaling of a set of Pods, with durable storage and persistent identifiers for each Pod.
  • Static Pod — A pod managed directly by the kubelet daemon on a specific node.
  • Storage Class — A StorageClass provides a way for administrators to describe different available storage types.
  • Subject Alternative Name — An X.509 certificate extension to identify what hostname or IP address the certificate applies to.
  • sysctl — An interface for getting and setting Unix kernel parameters
  • Taint — A core object consisting of three required properties: key, value, and effect. Taints prevent the scheduling of pods on nodes or node groups.
  • Toleration — A core object consisting of three required properties: key, value, and effect. Tolerations enable the scheduling of pods on nodes or node groups that have a matching taint.
  • UID — A Kubernetes systems-generated string to uniquely identify objects.
  • Upstream (disambiguation) — May refer to: core Kubernetes or the source repo from which a repo was forked.
  • user namespace — A Linux kernel feature to emulate superuser privilege for unprivileged users.
  • Volume — A directory containing data, accessible to the containers in a pod.
  • Volume Plugin — A Volume Plugin enables integration of storage within a Pod.
  • Watch — A verb that is used to track changes to an object in Kubernetes as a stream.
  • WG (working group) — Facilitates the discussion and/or implementation of a short-lived, narrow, or decoupled project for a committee, SIG, or cross-SIG effort.
  • Workload — A workload is an application running on Kubernetes.

Documentation pages (1469)

Concepts (4800)