☸️ Kubernetes Architecture - Complete Guide

# Get resources
kubectl get pods
kubectl get nodes
kubectl get services
kubectl get deployments

# Describe (detailed info)
kubectl describe pod my-pod
kubectl describe node node-1

# Create resources
kubectl create -f deployment.yaml
kubectl apply -f service.yaml

# Update resources
kubectl edit deployment my-app
kubectl scale deployment my-app --replicas=5

# Delete resources
kubectl delete pod my-pod
kubectl delete -f deployment.yaml

# Logs and debugging
kubectl logs my-pod
kubectl logs -f my-pod  # follow
kubectl exec -it my-pod -- /bin/bash

# Port forwarding
kubectl port-forward pod/my-pod 8080:80

# Labels and selectors
kubectl get pods -l app=nginx
kubectl label pods my-pod env=prod
        

Service Examples

ClusterIP Service

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  type: ClusterIP  # default
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80        # Service port
    targetPort: 8080 # Container port
        

LoadBalancer Service

apiVersion: v1
kind: Service
metadata:
  name: my-lb-service
spec:
  type: LoadBalancer
  selector:
    app: web
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080
  # Cloud provider provisions external LB
        

Headless Service (for StatefulSet)

apiVersion: v1
kind: Service
metadata:
  name: mysql
spec:
  clusterIP: None  # Headless!
  selector:
    app: mysql
  ports:
  - port: 3306
# Provides DNS for each Pod: mysql-0.mysql, mysql-1.mysql, etc.
        

Node Labels

Key-value pairs attached to nodes for organization and scheduling.

# Label a node
kubectl label nodes node-1 disktype=ssd
kubectl label nodes node-2 environment=production

# View labels
kubectl get nodes --show-labels
        

Node Selector (Simple)

Schedule Pods only on nodes with specific labels.

apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
  containers:
  - name: nginx
    image: nginx
  nodeSelector:
    disktype: ssd  # Only schedule on nodes with this label
        

Node Affinity (Advanced)

More expressive than nodeSelector, with soft/hard requirements.

apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: disktype
            operator: In
            values:
            - ssd
            - nvme
      preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 1
        preference:
          matchExpressions:
          - key: environment
            operator: In
            values:
            - production
  containers:
  - name: nginx
    image: nginx
        

Taints and Tolerations

Prevent Pods from scheduling on nodes unless they tolerate the taint.

# Taint a node (repel Pods)
kubectl taint nodes node-1 key=value:NoSchedule

# Pod with toleration (allows scheduling on tainted node)
apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
  tolerations:
  - key: "key"
    operator: "Equal"
    value: "value"
    effect: "NoSchedule"
  containers:
  - name: nginx
    image: nginx
        

How does Kubernetes achieve high availability?

• Control plane: Multiple API servers, schedulers, controllers (leader election)
• etcd: Clustered (3 or 5 instances) with Raft consensus
• Worker nodes: Multiple nodes, Pods distributed across nodes
• Self-healing: Controllers restart failed Pods, reschedule from failed nodes

How does a Pod get created? (End-to-end flow)

1. User runs kubectl create -f pod.yaml
2. kubectl sends request to API server
3. API server validates, authenticates, authorizes
4. API server writes Pod spec to etcd
5. Scheduler watches for unassigned Pods
6. Scheduler selects a node and binds Pod to it (updates etcd)
7. kubelet on that node watches for new Pod assignments
8. kubelet tells container runtime to pull image and start containers
9. Container runtime starts containers
10. kubelet reports Pod status to API server
11. kube-proxy updates network rules for Service discovery

How does Service discovery work?

• DNS: CoreDNS provides DNS resolution (my-service.namespace.svc.cluster.local)
• Environment variables: K8s injects Service IPs as env vars
• ClusterIP: Virtual IP for Services, load balanced by kube-proxy

Deployment vs StatefulSet vs DaemonSet

Rolling Update Process

1. User updates Deployment (new image version)
2. Deployment controller creates new ReplicaSet
3. New ReplicaSet scales up (creates new Pods)
4. Old ReplicaSet scales down (terminates old Pods)
5. Process continues until all Pods are new version
6. Old ReplicaSet kept for rollback (history)

Parameters: maxSurge (extra Pods during update), maxUnavailable (Pods down during update)