Kubernetes

etcd

• Distributed key-value store - Stores all cluster state
• Consistency - Ensures data consistency across control plane
• Durability - Persists cluster configuration and state
• Watch notifications - Notifies API server of state changes

Controller Manager (kube-controller-manager)

• Runs controllers - Replication, endpoints, namespace, service accounts
• Reconciliation loop - Continuously compares desired vs current state
• Resource lifecycle - Manages creation, updates, and deletion
• Leader election - Ensures only one active controller in HA setups

Scheduler (kube-scheduler)

• Pod placement - Selects appropriate nodes for pod deployment
• Resource optimization - Considers resource requirements and constraints
• Scheduling policies - Applies affinity, taints, and tolerations
• Node selection - Evaluates nodes based on filters and priorities

kubelet (Node Component)

• Pod execution - Runs containers on nodes as instructed
• Health reporting - Reports pod and node status to API server
• Current state reporting - Updates API server with actual state
• API server communication - Receives pod specifications and reports status

Reconciliation Loop Process

The reconciliation loop is the core mechanism that ensures desired state matches actual state:

1. Desired State Creation: User creates resources via kubectl (pods, deployments, services)
2. State Persistence: API server stores desired state in etcd
3. Watch Trigger: Controllers and scheduler watch for relevant changes
4. Current State Assessment: Components assess current cluster state
5. Gap Analysis: Compare desired vs current state
6. Action Execution: Take actions to align current state with desired state
7. Status Update: Report new state back to API server
8. Loop Continuation: Repeat continuously to maintain consistency

Component Collaboration Flow

User Action → API Server → etcd (Store Desired State)
      ↓
Scheduler Watches → Finds Suitable Node → Updates Pod Spec
      ↓
Kubelet Watches → Receives Pod Assignment → Starts Containers
      ↓
Controller Watches → Monitors Actual State → Adjusts as Needed
      ↓
Status Updates → API Server → etcd (Store Current State)

Example: Pod Creation Reconciliation

1. kubectl create -f pod.yaml → API Server receives pod specification
2. API Server saves → Pod object stored in etcd with nodeName=""
3. Scheduler watches → Detects unscheduled pod, selects node
4. Scheduler updates → Pod object in etcd with nodeName="node-1"
5. Kubelet watches → Detects pod assigned to its node
6. Kubelet executes → Starts container using container runtime
7. Kubelet reports → Updates pod status to Running
8. API Server syncs → Updates etcd with new status

When to Use This Skill

Use this skill when you need to:

1. Deploy containerized applications to Kubernetes clusters
2. Scale applications horizontally with Horizontal Pod Autoscaling
3. Configure resource limits and requests for optimal performance
4. Implement health checks and readiness probes
5. Apply security best practices and Pod Security Standards
6. Set up network policies and RBAC controls
7. Configure Ingress for external access
8. Implement production-ready deployment patterns
9. Understand and troubleshoot reconciliation loop behavior
10. Optimize control plane component configurations

Prerequisites Validation

Before using this skill, verify your Kubernetes setup:

# Check kubectl version
kubectl version --client

# Verify cluster access
kubectl cluster-info

# Check available nodes
kubectl get nodes

# Test basic functionality
kubectl run test-pod --image=nginx --dry-run=client -o yaml

Quick Start

Basic Deployment Configuration

For a simple application deployment:

apiVersion: apps/v1