Skip to content

Cluster Architecture

Kubernetes clusters are designed to abstract infrastructure complexity while enabling scalable, resilient application deployment. At their core, clusters consist of master nodes (control plane) and worker nodes (compute nodes), each with distinct responsibilities. Understanding their architecture and design patterns is critical for building production-ready systems.

Master Node Components

Master nodes manage the cluster's control plane. Key components include:
- API Server: The primary interface for interacting with the cluster. It processes REST requests and maintains the state of the cluster.
- etcd: A distributed key-value store that holds the cluster's configuration and state.
- Controller Manager: Runs control loops to ensure the actual state of the cluster matches the desired state (e.g., ReplicaSet reconciliation).
- Scheduler: Assigns pods to worker nodes based on resource availability and constraints.

Example:

kubectl get componentstatuses  # Check master node health
kubectl get etcd --kubeconfig=admin.kubeconfig  # Inspect etcd cluster status

For high availability (HA), these components are typically distributed across multiple master nodes. For example, etcd is deployed as a cluster of three nodes to avoid single points of failure.

Worker Node Components

Worker nodes run application workloads. They include:
- kubelet: Manages pod lifecycle and communicates with the API server.
- kube-proxy: Handles network rules (e.g., iptables) for service traffic.
- Container Runtime: Executes containers (e.g., Docker, containerd).

Example:

kubectl get nodes  # List worker nodes and their status
kubectl describe node <node-name>  # Inspect node details

Worker nodes are often grouped into node pools (e.g., for specific workloads) and scaled horizontally using Kubernetes' autoscaling features.

High Availability Design Patterns

  1. Control Plane HA:
  2. Deploy master components across multiple nodes.
  3. Use a load balancer for the API server to distribute traffic.

  4. Run etcd as a cluster of three nodes (e.g., using etcdctl for peer discovery).

  5. Multi-Zone Deployment:

  6. Spread master and worker nodes across different availability zones to mitigate regional outages.

  7. Stateful Applications:

  8. Use StatefulSets for databases (e.g., PostgreSQL) to ensure stable network identities and persistent storage.

Scalability Patterns

  1. Horizontal Pod Autoscaling (HPA):

  2. Automatically scale pods based on CPU/memory metrics.

    kubectl autoscale deployment <deployment-name> --min=2 --max=10 --cpu-percent=80

  3. Node Auto-Scaling:

  4. Use cloud provider tools (e.g., AWS Auto Scaling) to dynamically add/remove worker nodes.

  5. Service Mesh Integration:

  6. Deploy Istio or Linkerd to manage service-to-service communication, observability, and traffic routing.

Key takeaways

  • Master nodes manage the control plane (API server, etcd, scheduler, controller manager). Worker nodes run application pods.
  • HA is achieved through distributed etcd clusters, load-balanced API servers, and multi-zone deployments.
  • Scalability relies on HPA, node auto-scaling, and statefulset patterns for critical workloads.
  • Design patterns like service meshes and node pools enhance observability and resource efficiency.