Components of Kubernetes in Master Node & Working Node


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 ControllerResponsible for noticing and responding when nodes go down.
        · Replication ControllerResponsible 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

Comments