Kubernetes Cluster Setup On Ubuntu 2204: A Step-by-Step Guide

by Team 62 views
Kubernetes Cluster Setup on Ubuntu 2204: A Step-by-Step Guide

Setting up a Kubernetes cluster on Ubuntu 2204 can seem daunting, but with a step-by-step guide, it becomes a manageable and even enjoyable process. Kubernetes, often abbreviated as K8s, is an open-source container orchestration system for automating application deployment, scaling, and management. This guide will walk you through each stage, from preparing your Ubuntu servers to deploying your first application. Whether you're a seasoned developer or just starting, this comprehensive tutorial will help you get your Kubernetes cluster up and running smoothly on Ubuntu 2204.

Prerequisites

Before diving into the Kubernetes cluster setup, it's essential to ensure you have the necessary prerequisites in place. This preparation is crucial for a smooth and successful deployment. Here’s what you need:

  • Ubuntu 2204 Servers: You'll need at least two Ubuntu 2204 servers. One will serve as the master node, and the others will be worker nodes. Ensure each server has a unique hostname and a static IP address.
  • User with Sudo Privileges: Create a user with sudo privileges on each server. This allows you to execute administrative commands.
  • Internet Connectivity: All servers must have internet connectivity to download the necessary packages.
  • Basic Linux Knowledge: Familiarity with basic Linux commands will be helpful for navigating the setup process.
  • Containerization Concepts: A basic understanding of containerization concepts, particularly Docker, is beneficial.

Detailed Explanation of Prerequisites

Let's dive deeper into why each prerequisite is important. The Ubuntu 2204 servers are the foundation of your Kubernetes cluster. The master node is the control plane, managing the cluster's state and scheduling applications. Worker nodes, on the other hand, are where your applications will actually run. Having a static IP address for each server is crucial because Kubernetes relies on consistent network addresses to communicate between nodes. Dynamic IP addresses can change, leading to connectivity issues and cluster instability. Ensuring each server has a unique hostname makes it easier to identify and manage them within the cluster. The user with sudo privileges is necessary for performing administrative tasks such as installing packages, configuring system settings, and starting services. Sudo privileges allow you to run commands as the root user, which is required for many of the setup steps. However, it's best practice to use a non-root user with sudo privileges rather than logging in as the root user directly, as this enhances security. Internet connectivity is essential because you'll need to download various packages and container images from the internet. Kubernetes relies on container images to deploy applications, and these images are typically stored in online registries such as Docker Hub. Without internet connectivity, you won't be able to download these images or update your system. Basic Linux knowledge is beneficial because you'll be working with the command line to configure your servers. Familiarity with commands like apt, systemctl, and journalctl will make the setup process much smoother. You should also be comfortable navigating the file system and editing configuration files. Finally, a basic understanding of containerization concepts is helpful because Kubernetes is designed to manage containerized applications. Knowing how containers work, how they are built, and how they are deployed will give you a better understanding of how Kubernetes orchestrates them. Docker is the most popular containerization platform, so familiarity with Docker concepts is particularly useful. With these prerequisites in place, you'll be well-prepared to start setting up your Kubernetes cluster on Ubuntu 2204. Remember to double-check each item to avoid potential issues later on.

Step 1: Install Container Runtime (Docker)

Kubernetes requires a container runtime to run containers. Docker is a popular choice, and this step involves installing Docker on all your Ubuntu servers (both master and worker nodes). First, update the package index:

sudo apt update

Next, install Docker:

sudo apt install docker.io -y

Start and enable Docker:

sudo systemctl start docker
sudo systemctl enable docker

Verify Docker installation:

docker --version

Detailed Explanation of Docker Installation

Let's break down why each of these Docker installation commands is crucial. Updating the package index with sudo apt update ensures that your system has the latest information about available packages. This is important because you want to install the most recent version of Docker that is compatible with Ubuntu 2204. Without updating the package index, you might end up installing an older version of Docker or encountering dependency issues. The command sudo apt install docker.io -y installs the Docker package. The -y flag automatically answers "yes" to any prompts during the installation process, making it non-interactive. This is useful when you are running the command on multiple servers or when you want to automate the installation process. Docker is installed using the docker.io package name, which is the standard package name for Docker in Ubuntu repositories. Starting and enabling Docker ensures that Docker is running and will automatically start after a reboot. The sudo systemctl start docker command starts the Docker service immediately. The sudo systemctl enable docker command configures Docker to start automatically when the server boots up. This is important because you want your Kubernetes cluster to be resilient to server restarts. If Docker is not configured to start automatically, your containers will not be running after a reboot, and your applications will be unavailable. Verifying the Docker installation with docker --version confirms that Docker is installed correctly and that the Docker command-line interface (CLI) is working. This command displays the version of Docker that is installed on your system, which can be useful for troubleshooting compatibility issues. If the command returns an error, it indicates that Docker is not installed correctly or that the Docker CLI is not in your system's PATH. In that case, you should review the installation steps and ensure that you have followed them correctly. Docker is the cornerstone of running containers in Kubernetes. A properly installed and configured Docker runtime is essential for the rest of the Kubernetes setup process. By following these steps carefully, you can ensure that Docker is ready to support your Kubernetes cluster on Ubuntu 2204.

Step 2: Install Kubernetes Components

Next, install the Kubernetes components: kubeadm, kubelet, and kubectl on all servers. These tools are essential for managing and running your Kubernetes cluster. Start by updating the apt package index and installing the necessary packages using apt:

sudo apt update
sudo apt install -y apt-transport-https ca-certificates curl

Download the Google Cloud public signing key:

sudo curl -fsSL https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo gpg --dearmor -o /usr/share/keyrings/kubernetes-archive-keyring.gpg

Add the Kubernetes apt repository:

echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

Update the apt package index again:

sudo apt update

Install kubelet, kubeadm, and kubectl:

sudo apt install -y kubelet kubeadm kubectl

Hold the package versions to prevent automatic updates:

sudo apt-mark hold kubelet kubeadm kubectl

Detailed Explanation of Kubernetes Components Installation

Installing the Kubernetes components correctly is vital for the functionality of your cluster. Let's break down each step. First, updating the apt package index and installing necessary packages ensures that your system has the latest package information and the required dependencies. The command sudo apt update updates the package index, while sudo apt install -y apt-transport-https ca-certificates curl installs the apt-transport-https, ca-certificates, and curl packages. apt-transport-https allows apt to access repositories over HTTPS, ca-certificates provides SSL certificates for verifying the authenticity of HTTPS connections, and curl is a command-line tool for transferring data with URLs. These packages are essential for securely accessing the Kubernetes apt repository. Downloading the Google Cloud public signing key ensures that the packages you download from the Kubernetes apt repository are authentic and have not been tampered with. The command sudo curl -fsSL https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo gpg --dearmor -o /usr/share/keyrings/kubernetes-archive-keyring.gpg downloads the key and saves it to /usr/share/keyrings/kubernetes-archive-keyring.gpg. The -fsSL flags for curl ensure that the download is secure and that redirects are followed. The gpg --dearmor command converts the key from ASCII armored format to binary format. Adding the Kubernetes apt repository tells apt where to find the Kubernetes packages. The command echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list adds the repository to the /etc/apt/sources.list.d/kubernetes.list file. The signed-by option specifies the key that should be used to verify the packages from this repository. Updating the apt package index again after adding the Kubernetes repository ensures that apt is aware of the new packages available from the repository. The command sudo apt update updates the package index. Installing kubelet, kubeadm, and kubectl installs the core Kubernetes components. The command sudo apt install -y kubelet kubeadm kubectl installs these packages. kubelet is the agent that runs on each node in the cluster and communicates with the control plane. kubeadm is a tool for bootstrapping Kubernetes clusters. kubectl is the command-line tool for interacting with the Kubernetes API. Holding the package versions prevents automatic updates of the Kubernetes components, which can cause compatibility issues. The command sudo apt-mark hold kubelet kubeadm kubectl tells apt not to update these packages. This is important because Kubernetes components are often tightly coupled, and updating one component without updating the others can lead to problems. By following these steps carefully, you can ensure that the Kubernetes components are installed correctly and that your cluster is ready for initialization.

Step 3: Initialize the Kubernetes Cluster (Master Node)

Now, initialize the Kubernetes cluster on the master node. This process sets up the control plane components. Before initializing, you may need to disable swap. Check if swap is enabled:

swapon -s

If swap is enabled, disable it:

sudo swapoff -a

To make this permanent, comment out the swap line in /etc/fstab:

sudo nano /etc/fstab

Comment out the line that contains "swap" by adding a # at the beginning of the line. Save and exit the file. Now, initialize the Kubernetes cluster using kubeadm:

sudo kubeadm init --pod-network-cidr=10.244.0.0/16

After the initialization is complete, you'll see a kubeadm join command. Save this command for later use when joining worker nodes to the cluster. Configure kubectl to work as a non-root user:

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

Detailed Explanation of Kubernetes Cluster Initialization

Initializing the Kubernetes cluster is a crucial step that sets up the foundation for your entire deployment. Let's walk through each command in detail. Disabling swap is necessary because Kubernetes performs best when swap is disabled. Swap is a space on the disk that the operating system uses as virtual memory when the physical memory (RAM) is full. However, using swap can significantly slow down the performance of applications. Kubernetes relies on predictable performance, so it's recommended to disable swap. The swapon -s command checks if swap is enabled by displaying the swap usage summary. If swap is enabled, the sudo swapoff -a command disables it temporarily. To disable swap permanently, you need to comment out the swap line in /etc/fstab. The /etc/fstab file contains information about the file systems that are mounted at boot time. By commenting out the line that contains "swap", you prevent the system from enabling swap automatically after a reboot. The sudo nano /etc/fstab command opens the /etc/fstab file in the nano text editor. You can comment out the swap line by adding a # character at the beginning of the line. Save the file and exit the editor. Initializing the Kubernetes cluster using kubeadm sets up the control plane components. The sudo kubeadm init --pod-network-cidr=10.244.0.0/16 command initializes the cluster. The --pod-network-cidr option specifies the network range that will be used for pod IP addresses. This range should not overlap with any existing networks in your environment. The initialization process can take several minutes to complete. After the initialization is complete, kubeadm will display a kubeadm join command. This command is used to join worker nodes to the cluster. It includes a token and the IP address of the master node. Save this command in a safe place, as you will need it later. Configuring kubectl to work as a non-root user allows you to interact with the Kubernetes API without using sudo. This is a security best practice. The mkdir -p $HOME/.kube command creates a .kube directory in your home directory if it doesn't already exist. The sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config command copies the Kubernetes configuration file from /etc/kubernetes/admin.conf to $HOME/.kube/config. This configuration file contains the credentials and settings that kubectl uses to connect to the Kubernetes API. The sudo chown $(id -u):$(id -g) $HOME/.kube/config command changes the ownership of the configuration file to your user. This allows you to read and write the file without using sudo. By following these steps carefully, you can ensure that the Kubernetes cluster is initialized correctly and that you are able to interact with it using kubectl.

Step 4: Install a Pod Network Add-on

Kubernetes requires a pod network add-on to enable communication between pods. Calico is a popular choice. Install Calico with the following command:

kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml

Verify that the pods are running:

kubectl get pods -n kube-system

Detailed Explanation of Pod Network Add-on Installation

A pod network add-on is essential for enabling communication between pods in your Kubernetes cluster. Without a pod network add-on, pods will not be able to communicate with each other, and your applications will not function correctly. Calico is a popular choice for a pod network add-on because it provides a flexible and scalable networking solution. It supports a variety of networking policies and can be used in a wide range of environments. The command kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml installs Calico. This command downloads the Calico manifest file from the specified URL and applies it to your Kubernetes cluster. The manifest file contains the definitions for the Calico components, such as the Calico controllers, the Calico nodes, and the Calico network policies. Applying the manifest file creates these components in your cluster. After applying the manifest file, it can take several minutes for the Calico components to be fully deployed and running. You can verify that the pods are running by using the kubectl get pods -n kube-system command. This command lists all of the pods in the kube-system namespace. The kube-system namespace is where Kubernetes stores its own components, including the Calico components. You should see several Calico pods in the list, such as the calico-node pods and the calico-kube-controllers pod. If the pods are in the Running state, it indicates that Calico has been installed successfully. If the pods are in the Pending or Error state, it indicates that there may be a problem with the installation. You can check the logs of the pods to troubleshoot the issue. Installing a pod network add-on is a critical step in setting up a Kubernetes cluster. Calico is a reliable and widely used option that provides the necessary networking capabilities for your pods to communicate with each other. By following these steps, you can ensure that Calico is installed correctly and that your Kubernetes cluster is ready to run applications.

Step 5: Join Worker Nodes to the Cluster

On each worker node, run the kubeadm join command that was outputted during the master node initialization. It should look something like this:

sudo kubeadm join <master-ip>:<master-port> --token <token> --discovery-token-ca-cert-hash sha256:<hash>

Detailed Explanation of Joining Worker Nodes

Joining worker nodes to the Kubernetes cluster is the final step in setting up your basic cluster infrastructure. This process adds the worker nodes to the cluster, allowing them to run your applications. The kubeadm join command is used to join worker nodes to the cluster. This command was outputted during the master node initialization and contains the information necessary for the worker nodes to connect to the master node. The command includes the IP address and port of the master node, a token for authentication, and a hash of the CA certificate for verifying the identity of the master node. You must run this command on each worker node that you want to add to the cluster. The command should be run with sudo privileges. After running the command, the worker node will attempt to connect to the master node and join the cluster. This process can take several minutes to complete. Once the worker node has successfully joined the cluster, it will be able to run pods and participate in the Kubernetes workload. On the master node, you can verify that the worker nodes have joined the cluster by running the kubectl get nodes command. This command lists all of the nodes in the cluster, including the master node and the worker nodes. You should see the worker nodes in the list, with a status of Ready. If the worker nodes are not in the Ready state, it indicates that there may be a problem with the joining process. You can check the logs of the kubelet service on the worker nodes to troubleshoot the issue. Joining worker nodes to the cluster is a straightforward process, but it's important to use the correct kubeadm join command and to verify that the nodes have joined successfully. With the worker nodes joined, your Kubernetes cluster is now ready to deploy and run applications.

Step 6: Deploy a Sample Application

To verify that your cluster is working correctly, deploy a sample application. Create a deployment and a service using kubectl. Here’s an example deployment file (nginx-deployment.yaml):

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80

And a corresponding service file (nginx-service.yaml):

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: LoadBalancer

Apply these files using kubectl:

kubectl apply -f nginx-deployment.yaml
kubectl apply -f nginx-service.yaml

Check the status of the deployment and service:

kubectl get deployments
kubectl get services

Detailed Explanation of Deploying a Sample Application

Deploying a sample application is a great way to ensure that your Kubernetes cluster is functioning as expected after the initial setup. It allows you to test the deployment process, verify networking, and confirm that pods can be scheduled and run correctly. The first step is to create a deployment file. A deployment file defines how your application should be deployed, including the number of replicas, the container image to use, and the ports to expose. In this example, we're deploying the nginx:latest image, which is a popular web server. The replicas field specifies that we want two instances of the application to be running. The service file defines how your application can be accessed from outside the cluster. In this example, we're creating a LoadBalancer service, which will provision a load balancer in your cloud provider to distribute traffic to the pods. The selector field specifies which pods the service should route traffic to, based on the app: nginx label. After creating the deployment and service files, you can apply them using kubectl. The kubectl apply -f nginx-deployment.yaml command creates the deployment, and the kubectl apply -f nginx-service.yaml command creates the service. Kubernetes will then start the deployment process, which involves pulling the container image, creating pods, and scheduling them on the worker nodes. You can check the status of the deployment and service using the kubectl get deployments and kubectl get services commands. These commands will show you the current state of the deployment and service, including the number of replicas that are running, the IP address of the service, and any errors that have occurred. If the deployment and service are running correctly, you should be able to access the application by visiting the IP address of the service in your web browser. This will confirm that your Kubernetes cluster is working as expected and that you are ready to deploy your own applications. Deploying a sample application is a simple but effective way to validate your Kubernetes setup and ensure that you have a solid foundation for your future deployments.

Conclusion

Congratulations! You've successfully set up a Kubernetes cluster on Ubuntu 2204. This guide has walked you through the essential steps, from installing Docker and Kubernetes components to deploying a sample application. With this foundation, you can now explore more advanced Kubernetes features and deploy your own applications with confidence. Remember to consult the official Kubernetes documentation for further details and best practices. Happy clustering!