Click on various components to see the related-information.
Kubernetes: A Kubernetes cluster consists of a set of worker machines, called
nodes, that run containerized applications. Every cluster has at least one
The worker node(s) host the Pods that are the components of the application workload.
The control plane manages the worker nodes and the Pods in the cluster. In
production environments, the control plane usually runs across multiple
computers and a cluster usually runs multiple nodes, providing fault-tolerance
and high availability.
Control Panel: The control planes components make global decisions about the
cluster (for example, scheduling), as well as detecting and responding to
cluster events (for example, starting up a new pod when a deployments replicas
field is unsatisfied).
Control plane components can be run on any machine in the cluster. However, for
simplicity, set up scripts typically start all control plane components on the
same machine, and do not run user containers on this machine. See Creating
Highly Available clusters with kubeadm for an example control plane setup that
runs across multiple VMs.
Kube Api Server: The API server is a component of the Kubernetes control plane
that exposes the Kubernetes API. The API server is the front end for the
Kubernetes control plane.
The main implementation of a Kubernetes API server is kube-apiserver.
kube-apiserver is designed to scale horizontally—that is, it scales by deploying
more instances. You can run several instances of kube-apiserver and balance
traffic between those instances.
etcd: Consistent and highly-available key value store used as Kubernetes backing
store for all cluster data.
If your Kubernetes cluster uses etcd as its backing store, make sure you have a
back up plan for those data.
Kube Controller Manager: Control plane component that runs controller processes.
Logically, each controller is a separate process, but to reduce complexity, they
are all compiled into a single binary and run in a single process.
Node controller: Responsible for noticing and responding when nodes go down.
Replication Controller: Watches for Job objects that represent one-off tasks, then creates Pods to run those tasks to completion.
Endpoints controller: Populates the Endpoints object (that is, joins Services & Pods).
Service Account & Token controllers: Create default accounts and API access tokens for new namespaces.
Cloud controller manager: A Kubernetes control plane component that embeds
cloud-specific control logic. The cloud controller manager lets you link your
cluster into your cloud providers API, and separates out the components that
interact with that cloud platform from components that only interact with
The cloud-controller-manager only runs controllers that are specific to your
cloud provider. If you are running Kubernetes on your own premises, or in a
learning environment inside your own PC, the cluster does not have a cloud
As with the kube-controller-manager, the cloud-controller-manager combines
several logically independent control loops into a single binary that you run
as a single process. You can scale horizontally (run more than one copy) to
improve performance or to help tolerate failures.
Node controller: For checking the cloud provider to determine if a node has been deleted in the cloud after it stops responding.
Route controller: For setting up routes in the underlying cloud infrastructure.
Service controller: For creating, updating and deleting cloud provider load balancers.
Node Components: Node components run on every node, maintaining running pods and providing the Kubernetes runtime environment.
Kubelet: An agent that runs on each node in the cluster. It makes sure that
containers are running in a Pod.
The kubelet takes a set of PodSpecs that are provided through various mechanisms
and ensures that the containers described in those PodSpecs are running and
healthy. The kubelet doesnt manage containers which were not created by
Kube-proxy: kube-proxy is a network proxy that runs on each node in your
cluster, implementing part of the Kubernetes Service concept.
kube-proxy maintains network rules on nodes. These network rules allow network
communication to your Pods from network sessions inside or outside of your
kube-proxy uses the operating system packet filtering layer if there is one and
its available. Otherwise, kube-proxy forwards the traffic itself.
Container runtime: The container runtime is the software that is responsible for
Kubernetes supports several container runtimes: Docker, containerd, CRI-O, and
any implementation of the Kubernetes CRI (Container Runtime Interface).