- Get link
- X
- Other Apps
- Get link
- X
- Other Apps
Kubernetes
work as a Master and worker node architecture. In total Kubernetes has 7
components out of which 4 belongs to Master node and three belongs to the worker
node as described and shown below:
Master Node components:
1.
API Server
2.
Controller Manager
3.
ETCD
4.
Scheduler
Worker Node components:
1.
Kube-proxy
2.
Kubelet
3.
Runtime
Let’s
discuss these components one by one –
MASTER NODE
As the name suggests it is the master for the
cluster and entry point for all the administrative tasks which is responsible
for managing the Kubernetes cluster
There
are often one or quite one Master inside a cluster for fault tolerance &
high availability. Let’s check each component which is responsible to form a
node Master.
-API SERVER
This
is the front for the Kubernetes control plane. All API calls are sent to the
present server and server send commands to the opposite services.
No
component talks to every other direction, the API server is liable for all the
communication.
- Etcd
This
is the Key-Value store for the cluster. When an object is made, that object
state is stored here.
Etcd
acts because of the reference for the cluster state. If the cluster differs from
what's indicated in Etcd, the cluster would change to match the declared state. For
e.g 2 Pods alleged to run with certain image or task if any pods get deleted
it might automatically create another to match the state.
- Scheduler
When
a replacement pod is made scheduler determines which node should run it &
this decision is predicated on many factors including hardware, workloads,
affinity etc.
- Controller Manager
It
operates the cluster controllers –
· Node Controller
–Responsible for
noticing and responding when nodes go down.
· Replication Controller
–Responsible for
maintaining the right number of pods for each
replication
controller object within the system
· Endpoints
Controller –
Populates the endpoint objects i.e. joins services and pods
· Service Accounts & Token Controllers – creates default accounts and API
access tokens
for
brand spanking new namespaces
Below is the Architecture diagram and you can see each component and their communication flow
Worker Node (minions)
– It is a
physical server or VM which runs on the applications using Pods which is
controlled by the Master node.
“Pods
are the smallest working unit of Kubernetes just like that container of Docker”
or you can say that Kubernetes doesn’t
run containers instead it wraps one or more containers into a higher-level structure called POD. Pods are used as a unit of replication in Kubernetes.
Let
we check the components of Worker Nodes –
Kube-Proxy:
it runs on the nodes and provides network
connectivity for services on the nodes that connect to the pods.
- It serves as the network proxy and a load
balancer for a service on a single worker node and manages the network routing
for TCP and UDP packets.
- Kube-proxy runs on the each node to deal with
individual host sub-netting and ensure that the services are available to
external parties.
Kubelet:
- It is an agent that communicates with
the Master node and executes on nodes or the worker nodes. It gets the Pod
specifications through the API server and executes the containers associated
with the Pod and ensures that the containers described in those Pods are
running and healthy.
Container
Runtime:
- This is the container manager. It can be
any container runtime that is compliant with the Open Container initiative such
as Docker or to run and manage a container’s lifecycle, we need a container
runtime on the worker node.
- Sometimes, Docker is also referred to
as a container runtime, but to be precise, Docker is a platform that uses
containers as a container runtime.
For
More Information about Docker & Kubernetes
Online Training ClickHere
Ph
No: +91-9989971070, E-Mail ID: online@visualpath.in
Components of Kubernetes in Master Node & Working Node
Kubernetes
Kubernetes in Master Node
Working Node
- Get link
- X
- Other Apps
Comments
Post a Comment