Setting Up a Kubernetes Cluster on Ubuntu 22.04: A Detailed Guide

Hey guys! Today, we’re diving deep into setting up a Kubernetes (k8s) cluster on Ubuntu 22.04. Kubernetes has become the go-to platform for orchestrating containerized applications, and Ubuntu 22.04 provides a solid foundation for this. Whether you’re a seasoned DevOps engineer or just starting your journey, this guide will walk you through each step to get your cluster up and running smoothly. So, buckle up and let’s get started!

Prerequisites

Before we jump into the nitty-gritty, let’s make sure we have everything we need. Here’s a checklist:

• Ubuntu 22.04 Servers: You’ll need at least two Ubuntu 22.04 servers. One will act as the master node, and the others will be worker nodes. For a production environment, consider having at least three master nodes for high availability.
• User with Sudo Privileges: Make sure you have a user account with sudo privileges on all servers. This allows you to run commands with administrative rights.
• Internet Connection: All servers should have a stable internet connection to download packages and dependencies.
• Basic Linux Knowledge: Familiarity with basic Linux commands will be helpful.

Hardware Requirements

When it comes to hardware, Kubernetes can be resource-intensive, especially for the master node. Here are some recommendations:

• Master Node:
  • CPU: 2 cores or more
  • Memory: 4GB RAM or more
  • Storage: 20GB or more
• Worker Nodes:
  • CPU: 1 core or more
  • Memory: 2GB RAM or more
  • Storage: 20GB or more

Keep in mind that these are minimum recommendations. Depending on the size and complexity of your applications, you might need more resources. Always monitor your cluster’s performance and adjust resources accordingly. Remember, under-provisioning can lead to performance bottlenecks, while over-provisioning can waste resources. Finding the right balance is key!

Step-by-Step Guide

Step 1: Update and Upgrade Packages

First things first, let’s update and upgrade our packages on all servers. This ensures we have the latest versions and security patches.

sudo apt update && sudo apt upgrade -y

This command updates the package lists and then upgrades all installed packages to their latest versions. The -y flag automatically answers “yes” to any prompts, making the process non-interactive. Always a good practice to keep your system up-to-date!

Step 2: Install Container Runtime (Docker)

Kubernetes needs a container runtime to run containers. Docker is a popular choice, so let’s install it.

sudo apt install docker.io -y

Once Docker is installed, let’s start and enable it to ensure it runs on boot.

sudo systemctl start docker
sudo systemctl enable docker

To verify that Docker is running correctly, you can check its status:

sudo systemctl status docker

This command will show you whether Docker is active and running without any errors. A healthy Docker installation is crucial for Kubernetes to function properly.

Step 3: Install Kubernetes Components (kubeadm, kubelet, kubectl)

Now, let’s install the Kubernetes components: kubeadm , kubelet , and kubectl .

• kubeadm : A tool for bootstrapping Kubernetes clusters.
• kubelet : An agent that runs on each node in the cluster and ensures that containers are running in a Pod.
• kubectl : A command-line tool for interacting with the Kubernetes API server.

First, we need to add the Kubernetes apt repository:

curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

Then, update the package lists again and install the Kubernetes components:

sudo apt update
sudo apt install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

The apt-mark hold command prevents these packages from being accidentally updated, which could cause compatibility issues. It’s a good practice to hold these packages to maintain stability in your Kubernetes cluster.

Step 4: Initialize the Kubernetes Cluster (Master Node)

On the master node, initialize the Kubernetes cluster using kubeadm :

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

The --pod-network-cidr flag specifies the IP address range for the pod network. We’re using 10.244.0.0/16 , which is the default for Calico, a popular network plugin. After the initialization is complete, you’ll see a message with instructions on how to configure kubectl and join worker nodes.

Follow the instructions to configure kubectl :

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

This copies the Kubernetes configuration file to your user’s .kube directory and sets the correct permissions. Now, you can use kubectl to interact with your cluster. Verify that kubectl is working by running:

kubectl get nodes

You should see the master node in the output, but it will be in the NotReady state because we haven’t installed a network plugin yet.

Step 5: Install a Network Plugin (Calico)

A network plugin is required for pod-to-pod communication. Calico is a popular and powerful choice. Let’s install it:

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

This command applies the Calico manifest, which sets up the necessary components for network policy and pod networking. After a few minutes, check the status of the nodes again:

kubectl get nodes

The master node should now be in the Ready state. If it’s still NotReady , give it a few more minutes and check the logs of the Calico pods using kubectl get pods -n kube-system to troubleshoot any issues.

Step 6: Join Worker Nodes to the Cluster

Now, let’s join the worker nodes to the cluster. On each worker node, run the kubeadm join command that was provided in the output of the kubeadm init command on the master node. It should look something like this:

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

Replace <master-ip> , <master-port> , <token> , and <hash> with the values from the kubeadm init output. After running this command on each worker node, they will join the cluster.

On the master node, verify that the worker nodes have joined the cluster:

kubectl get nodes

You should see all the worker nodes in the output, and they should all be in the Ready state. If a node is not joining, check the kubelet logs on that node using journalctl -u kubelet for any errors.

Step 7: Deploy a Sample Application

Now that our cluster is up and running, let’s deploy a sample application to make sure everything is working correctly. We’ll deploy a simple Nginx deployment.

Create a deployment file named nginx-deployment.yaml :

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

Apply the deployment:

kubectl apply -f nginx-deployment.yaml

Check the status of the deployment:

kubectl get deployments
kubectl get pods

You should see the nginx-deployment in the output, and the pods should be in the Running state. To access the Nginx application, you can create a service:

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

Apply the service:

kubectl apply -f nginx-service.yaml

Get the external IP of the service:

kubectl get service nginx-service

You can now access the Nginx application in your browser using the external IP. If you’re running this on a cloud provider like AWS, Azure, or GCP, the LoadBalancer will provision a load balancer and provide an external IP. If you’re running this on-premises, you might need to use a different service type like NodePort or implement your own load balancing solution.

Conclusion

And there you have it! You’ve successfully set up a Kubernetes cluster on Ubuntu 22.04. This guide covered everything from installing the necessary components to deploying a sample application. Kubernetes can be complex, but with a solid foundation, you can start orchestrating your containerized applications with confidence. Keep exploring, experimenting, and learning. The world of Kubernetes is vast and ever-evolving, but the journey is well worth it!

Remember, setting up a production-ready Kubernetes cluster involves more considerations, such as security, monitoring, and high availability. But this guide should give you a great starting point. Happy clustering!