Kubernetes Unveiled: The Hidden Secrets of Master and Nodes

Kubernetes has revolutionized the way we deploy, scale, and manage containerized applications. To effectively use Kubernetes, it’s crucial to understand its architecture. In this article, we’ll dive deep into the Kubernetes architecture, focusing on the Master and Node components.

Photo by Growtika on Unsplash

Follow https://medium.com/itversity publication for articles on Full Stack, Data Engineering, DevOps, Cloud, etc.

✅ Save the List: SRE on Medium

Do SUBSCRIBE 📩 Vamsi Penmetsa for daily DevOps dose

🫵 **Click** to read it for FREE

INDEX

1. Kubernetes Architecture Overview
2. Master Node (Control Plane)
3. API Server
4. etcd
5. Scheduler
6. Controller Manager
7. Worker Nodes
8. Kubelet
9. Container Runtime
10. Kube Proxy
11. Practical Scenario: Deploying a Simple Web Application
12. Step 1: Create a Deployment
13. Service YAML Explanation
14. kubectl Commands Explanation
15. Kubernetes Architecture Diagram
16. Conclusion
17. Next Steps for Further Learning

Kubernetes Architecture Overview

Kubernetes follows a master-worker architecture, consisting of two main components:

1. Master Node (Control Plane)
2. Worker Nodes

Let’s explore each of these components in detail.

Master Node (Control Plane)

The Master Node, also known as the Control Plane, is responsible for managing the overall Kubernetes cluster. It makes global decisions about the cluster and handles events.

Key components of the Master Node include:

1. API Server
2. etcd
3. Scheduler
4. Controller Manager

API Server

The API Server is the central management entity that receives RESTful requests for modifications (to pods, services, replication controllers, etc.), serves as a gateway to the cluster, and handles internal and external requests.

etcd

etcd is a distributed key-value store that stores the cluster’s configuration data, representing the overall state of the cluster at any given point in time.

Scheduler

The Scheduler is responsible for distributing work or containers across multiple nodes. It looks for newly created containers and assigns them to nodes.

Controller Manager

The Controller Manager runs controller processes to regulate the state of the cluster. Controllers include:

• Node Controller
• Replication Controller
• Endpoints Controller
• Service Account & Token Controllers

Worker Nodes

Worker Nodes are the machines where containers are deployed. Each node is managed by the master and contains the services necessary to run pods.

Key components of a Worker Node include:

1. Kubelet
2. Container Runtime
3. Kube Proxy

Kubelet

Kubelet is an agent that runs on each node in the cluster. It ensures that containers are running in a pod.

Container Runtime

The Container Runtime is the software responsible for running containers. Kubernetes supports several container runtimes, including Docker, containerd, and CRI-O.

Kube Proxy

Kube Proxy maintains network rules on nodes. These network rules allow network communication to your Pods from network sessions inside or outside of your cluster.

Kubernetes basic architecture

Practical Scenario: Deploying a Simple Web Application

Let’s walk through a practical scenario of deploying a simple web application using Kubernetes.

Step 1: Create a Deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
    spec:
      containers:
      - name: web-app
        image: nginx:latest
        ports:
        - containerPort: 80

• apiVersion: apps/v1: Specifies the API version for Deployments.
• kind: Deployment: Indicates that this is a Deployment resource.
• metadata: Contains metadata about the Deployment, including its name.
• spec: Defines the desired state for the Deployment.
• replicas: 3: Specifies that we want 3 replicas of our application.
• selector: Defines how the Deployment finds which Pods to manage.
• template: Describes the pod that will be created.
• metadata: Labels for the pod.
• spec: The pod specification.
• containers: List of containers in the pod.
• name: Name of the container.
• image: Docker image to use (nginx in this case).
• ports: Specifies that the container listens on port 80.

Service YAML Explanation

apiVersion: v1
kind: Service
metadata:
  name: web-app-service
spec:
  selector:
    app: web-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: LoadBalancer

• apiVersion: v1: Specifies the API version for Services.
• kind: Service: Indicates that this is a Service resource.
• metadata: Contains metadata about the Service, including its name.
• spec: Defines the desired state for the Service.
• selector: Specifies which pods the Service should route traffic to.
• ports: Defines the port configuration.
• protocol: Specifies TCP as the protocol.
• port: The port the Service listens on.
• targetPort: The port to forward to on the pod.
• type: LoadBalancer: Specifies that this Service should be exposed through a cloud provider's load balancer.

kubectl Commands Explanation

kubectl apply -f web-app-deployment.yaml
kubectl apply -f web-app-service.yaml

These commands apply the configuration files to the Kubernetes cluster:

• kubectl apply: Command to create or update resources.
• -f: Specifies that we're using a file.
• web-app-deployment.yaml and web-app-service.yaml: The filenames of our YAML configurations.

kubectl get deployments
kubectl get pods
kubectl get services

These commands retrieve information about resources in the cluster:

• kubectl get: Command to list resources.
• deployments: Lists all Deployments in the current namespace.
• pods: Lists all Pods in the current namespace.
• services: Lists all Services in the current namespace.

These commands help you verify that your resources have been created successfully and are running as expected.

Kubernetes Architecture Diagram

Here’s a simplified diagram of the Kubernetes architecture:

Kubernetes detailed architecture diagram.

Conclusion

Understanding the Kubernetes architecture is crucial for effectively managing and deploying applications in a Kubernetes cluster. The Master Node (Control Plane) manages the overall cluster, while Worker Nodes run the actual containerized applications. By leveraging this architecture, Kubernetes provides a powerful platform for container orchestration, enabling scalable and resilient application deployments.

As you continue your Kubernetes journey, delve deeper into each component and explore advanced topics like custom resource definitions, operators, and multi-cluster management to fully harness the power of Kubernetes.

Next Steps for Further Learning

• Kubernetes Official Documentation
• Introduction to Kubernetes by Google Cloud

If you liked this post:

🔔 Follow Vamsi Penmetsa ♻ Repost to help others find it 💾 Save this post for future reference