Kubernetes has become the de facto standard for container orchestration, enabling scalable and resilient application deployments. However, understanding its inner workings requires more than just using pre-configured tools. This article explores the manual setup of a Kubernetes cluster from scratch, emphasizing the core components and their interactions without relying on automation scripts or third-party tools. The process, known as Kubernetes the Hard Way, is designed for educational purposes, offering insights into the architecture and operational nuances of Kubernetes. While this approach is not suitable for production environments due to its complexity and lack of redundancy, it serves as a foundational learning experience for developers and DevOps engineers.
Kubernetes is an open-source system for automating deployment, scaling, and management of containerized applications. At its core, a Kubernetes cluster consists of a control plane and worker nodes. The control plane manages the cluster’s state, while worker nodes run the applications. This manual setup focuses on the following key components:
The API Server acts as the central hub for all communication within the cluster. It processes API requests, validates them against the Kubernetes API schema, and interacts with ETCD to store and retrieve cluster state. Unlike other components, the API Server does not store data itself, relying on ETCD for persistence. It supports both HTTP and gRPC protocols, enabling interaction with client tools like kubectl and internal components.
ETCD is a distributed key-value store that stores the cluster’s configuration and state. It ensures global consistency across all nodes and provides a reliable source of truth for the cluster. While ETCD is critical for maintaining cluster integrity, its limited scalability makes it more suitable for smaller clusters. In this setup, ETCD is configured to listen on port 2379 and must be manually secured with TLS certificates.
The Controller Manager runs critical controllers, such as the Deployment Controller, which ensures that the actual state of the cluster matches the desired state. It communicates with the API Server to monitor and adjust resources, maintaining the cluster’s stability and consistency.
The Scheduler assigns Pods to worker nodes based on resource availability and constraints. It interacts with the API Server to determine the optimal node for each Pod, ensuring efficient utilization of cluster resources.
Kubelet is the agent that runs on each worker node. It executes Pods, manages containers, and interacts with the container runtime (e.g., containerd). Kubelet must be configured with the API Server’s address and authentication credentials to communicate securely. It also exposes metrics and health checks via its API endpoint (e.g., port 10250).
Kube-proxy manages network rules for Services, enabling traffic routing between Pods and external clients. It supports various Service types, including ClusterIP, NodePort, and LoadBalancer. In this setup, Kube-proxy is configured to work with the API Server and relies on iptables for IP table rules.
The manual setup process involves the following steps:
Bootstrap the Control Plane: Start ETCD and API Server manually, ensuring TLS certificates are configured for secure communication. Verify the API Server’s connection to ETCD by checking its status and logs.
Deploy Worker Nodes: Install Kubelet and Kube-proxy on a separate node, configuring them to connect to the API Server. Ensure the container runtime (e.g., containerd) is properly set up with the correct endpoints and authentication.
Initialize Cluster Components: Start the Controller Manager and Scheduler, configuring them to connect to the API Server. Validate their operation by checking their status and ensuring they communicate with the control plane.
Verify Cluster Health: Use kubectl cluster-info to confirm the cluster’s status, including the API Server’s address, ETCD endpoint, and Pod status. Ensure all components are running and reachable.
Test Pod Scheduling: Deploy a sample Pod and verify that it is scheduled to a worker node. Check the Pod’s status using kubectl get pods and ensure it is in the Running state.
This manual Kubernetes setup demonstrates the foundational mechanics of the platform, emphasizing the roles of its core components and their interdependencies. While not suitable for production, it serves as an invaluable learning tool for understanding Kubernetes’ inner workings. For real-world deployments, leveraging managed Kubernetes services or tools like K3s can simplify operations while maintaining the benefits of a robust orchestration system. Mastery of these concepts is essential for anyone aiming to design, manage, or troubleshoot Kubernetes clusters effectively.