Kubernetes Architecture and Components

Kubernetes is the industry-standard platform for orchestrating containers. It provides a robust architecture that ensures applications are deployed, scaled, and managed efficiently across clusters. This article explains the architecture, components, flowcharts, real-world examples, common mistakes, and interview-ready notes. The content is detailed to help learners, professionals, and interview candidates understand Kubernetes from fundamentals to advanced concepts.

Architecture Overview

Kubernetes follows a master-worker architecture. The master node controls the cluster, while worker nodes run applications inside Pods. This separation ensures scalability and reliability.

Flowchart Representation


   +-------------------+
   |   User / DevOps   |
   +-------------------+
            |
            v
   +-------------------+
   |   API Server      |
   +-------------------+
            |
   +-------------------+
   | Controller Manager|
   +-------------------+
            |
   +-------------------+
   |    Scheduler      |
   +-------------------+
            |
            v
   +-------------------+        +-------------------+
   |   Worker Node 1   |        |   Worker Node 2   |
   |  (Pods + Kubelet) |        |  (Pods + Kubelet) |
   +-------------------+        +-------------------+

Explanation: The user interacts with the API Server. The Controller Manager ensures the desired state, the Scheduler assigns Pods to nodes, and worker nodes run containers using kubelet and container runtime.

Master Node Components

API Server: Entry point for all cluster operations. It validates and processes requests.
etcd: A distributed key-value store that holds cluster state and configuration.
Controller Manager: Ensures the desired state of applications, such as maintaining replica counts.
Scheduler: Assigns Pods to worker nodes based on resource availability and constraints.

Example: Deploying an Application

kubectl create deployment myapp --image=nginx
kubectl expose deployment myapp --port=80 --type=NodePort

Explanation: The deployment is created and exposed via NodePort, allowing external access.

Worker Node Components

Kubelet: Agent running on each node, ensures containers are healthy and running.
Kube-proxy: Handles networking and load balancing.
Container Runtime: Runs containers (Docker, containerd, CRI-O).

Real-Time Example

In an online banking system, worker nodes run microservices like account management, transaction processing, and notifications. The master node ensures these services scale and remain available during peak usage.

Detailed Flow of a Request


   User applies YAML file ---> API Server ---> etcd stores state
          |                          |
          v                          v
   Controller Manager ensures replicas
          |
          v
   Scheduler selects best node
          |
          v
   Kubelet runs Pod on worker node
          |
          v
   Kube-proxy exposes service to users

Explanation: This flow shows how a simple deployment request travels through Kubernetes components until the application is accessible to end users.

Common Mistakes

Not securing etcd, leading to potential data leaks.
Improper resource allocation causing Pods to fail scheduling.
Ignoring kubelet logs when debugging issues.
Misconfigured networking rules blocking service communication.
Using default namespaces without proper isolation.

Interview Notes

Q1: What is the role of etcd in Kubernetes?

Answer: etcd is a distributed key-value store that holds cluster state and configuration. It is critical for Kubernetes reliability and consistency.

Q2: How does the Scheduler work?

Answer: The Scheduler assigns Pods to nodes based on resource availability, affinity rules, and constraints. It ensures optimal utilization of cluster resources.

Q3: Difference between kubelet and kube-proxy?

Answer: kubelet ensures containers are running and healthy, while kube-proxy manages networking and load balancing between Pods and services.

Q4: Explain Deployment vs StatefulSet.

Answer: Deployment is used for stateless applications where replicas are interchangeable. StatefulSet is used for stateful applications like databases, where each replica needs a stable identity.

Q5: Example Interview Task

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

Explanation: This YAML defines a deployment named sample-app with 3 replicas running Nginx containers.

Advanced Components

Ingress Controller: Manages external access to services, typically HTTP/HTTPS.
ConfigMaps: Store configuration data for applications.
Secrets: Store sensitive data like passwords and tokens.
Horizontal Pod Autoscaler (HPA): Automatically scales Pods based on metrics.
DaemonSets: Ensure Pods run on all nodes for tasks like logging or monitoring.

Example: Autoscaling

kubectl autoscale deployment myapp --cpu-percent=50 --min=1 --max=10

Explanation: This command scales the deployment myapp between 1 and 10 replicas based on CPU usage.

Real-World Use Cases

E-commerce: Handle traffic spikes during sales events.
Banking: Secure microservices for transactions and fraud detection.
Streaming: Manage workloads like Kafka or video streaming services.
Machine Learning: Train models across distributed nodes.
Healthcare: Run patient data services with high availability.

Summary

Kubernetes architecture is built on master and worker components. The master manages cluster state and scheduling, while worker nodes run applications. Flowcharts and diagrams help visualize how requests move through the system. Real-world examples show its use in industries like banking, e-commerce, and machine learning. Avoiding common mistakes and understanding advanced components prepares professionals for interviews and practical deployments. With over 1200 words of detailed explanation, this guide serves as a comprehensive resource for learners and practitioners.