Kubernetes Cluster On Ubuntu 22.04: A Step-by-Step Guide

Nov 3, 2025 by Team 57 views

Hey guys! Today, we're diving deep into creating a Kubernetes cluster on Ubuntu 22.04. Setting up a Kubernetes cluster might sound intimidating, but trust me, with this guide, you'll have it up and running in no time. Let’s break it down into manageable steps. Whether you're a seasoned developer or just starting with container orchestration, this tutorial will provide you with a solid foundation.

Prerequisites

Before we get started, ensure you have the following prerequisites in place:

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, it’s recommended to have at least three master nodes for high availability.
SSH Access: Make sure you have SSH access to all the servers. This will allow you to execute commands remotely.
Basic Linux Knowledge: Familiarity with basic Linux commands will be helpful.
Internet Connection: All servers should have an active internet connection to download packages.
Unique Hostnames and Static IPs: Assign unique hostnames and static IP addresses to each server to ensure stable communication within the cluster. This is crucial for maintaining a consistent environment.

Step 1: Install Container Runtime (Docker)

Okay, first things first, let's install Docker, which will serve as our container runtime. Kubernetes needs a container runtime to run your applications in containers. Docker is a popular choice, and here’s how to get it installed:

Update Package Index:
```
sudo apt update
```
Keeping your package index up-to-date ensures you have the latest versions of available packages. This is always a good practice before installing any new software.
Install Docker:
```
sudo apt install docker.io -y
```
This command installs the Docker engine along with necessary dependencies. The -y flag automatically confirms the installation, so you don't have to manually accept it.
Start and Enable Docker:
```
sudo systemctl start docker
sudo systemctl enable docker
```
Starting Docker ensures that the Docker daemon is running immediately. Enabling Docker makes sure that it starts automatically on boot, so you don't have to manually start it every time your server restarts.
Verify Docker Installation:
```
docker --version
```
This command displays the installed Docker version, confirming that Docker has been successfully installed and is running correctly. If you see the version number, you’re good to go!

Step 2: Install Kubectl, Kubeadm, and Kubelet

Next up, we need to install the Kubernetes tools: kubectl, kubeadm, and kubelet. These are essential for managing and running your Kubernetes cluster.

Update Package Index:
```
sudo apt update
```
Just like with Docker, updating the package index ensures you get the latest versions of the Kubernetes components.
Install Required Packages:
```
sudo apt install apt-transport-https ca-certificates curl -y
```
These packages are required to securely access the Kubernetes repository over HTTPS.

Add 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 ```

This adds the official Kubernetes repository to your system's list of software sources. This allows you to install Kubernetes components using `apt`.

Update Package Index Again:
```
sudo apt update
```
Updating the package index again ensures that the newly added Kubernetes repository is included in the list of available packages.
Install Kubectl, Kubeadm, and Kubelet:
```
sudo apt install kubelet kubeadm kubectl -y
sudo apt-mark hold kubelet kubeadm kubectl
```
This command installs the Kubernetes tools. kubelet is the agent that runs on each node, kubeadm is used to bootstrap the cluster, and kubectl is the command-line tool for managing the cluster. The apt-mark hold command prevents these packages from being automatically updated, which can cause compatibility issues.
Verify Installation:
```
kubectl version --client
kubeadm version
kubelet --version
```
These commands display the versions of the installed Kubernetes tools, confirming that they have been successfully installed. Make sure you see the version numbers for each.

Step 3: Initialize the Kubernetes Cluster (Master Node)

Now, let’s initialize the Kubernetes cluster on the master node. This involves setting up the control plane, which manages the cluster.

Initialize the Kubernetes Cluster:
```
sudo kubeadm init --pod-network-cidr=10.244.0.0/16
```
This command initializes the Kubernetes cluster. The --pod-network-cidr flag specifies the IP address range for the pod network. 10.244.0.0/16 is a common choice for Flannel, which we'll install later. Make sure to note the kubeadm join command that is outputted after initialization; you will need this for joining worker nodes. The initialization process may take a few minutes, so be patient.
Configure Kubectl:
```
mkdir -p $HOME/.kube
```

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

These commands configure `kubectl` to communicate with the Kubernetes cluster. They create a `.kube` directory in your home directory, copy the cluster configuration file, and set the appropriate ownership so you can use `kubectl` without `sudo`.

Step 4: Install a Pod Network (Calico)

Next, we need to install a pod network. A pod network allows containers to communicate with each other across the cluster. We'll use Calico, which is a popular and flexible networking solution. There are other options available, such as Flannel, but Calico offers more advanced features and scalability.

Apply Calico Manifest:
```
kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.26.1/manifests/calico.yaml
```
This command applies the Calico manifest, which sets up the Calico pod network in your cluster. It may take a few minutes for all the Calico pods to become ready. Verify calico pods deployed correctly.
Verify Calico Pods:
```
kubectl get pods -n kube-system
```
This command lists all the pods in the kube-system namespace. Check that all Calico pods are running and have a status of Running. If any pods are in a different state, wait a few minutes and try again. Sometimes it takes a bit for everything to stabilize.

Step 5: Join Worker Nodes to the Cluster

Now, let's add the worker nodes to the cluster. Worker nodes are where your applications will run. You'll need the kubeadm join command that was outputted during the kubeadm init step.

Join Worker Nodes:
```
sudo kubeadm join <your_master_ip>:<port> --token <token> --discovery-token-ca-cert-hash sha256:<hash>
```
Replace <your_master_ip>, <port>, <token>, and <hash> with the values from the kubeadm join command that was outputted when you initialized the cluster. This command joins the worker node to the Kubernetes cluster.
Check Node Status (Master Node):
```
kubectl get nodes
```
Run this command on the master node to check the status of all nodes in the cluster. You should see the worker nodes listed with a status of Ready. If the nodes are not showing as Ready, it might take a few minutes for them to join the cluster and become fully operational.

Step 6: Deploy a Sample Application

Alright, let's deploy a sample application to test our cluster. We'll deploy a simple Nginx deployment.

Create Deployment:
```
kubectl create deployment nginx --image=nginx
```
This command creates an Nginx deployment. The --image=nginx flag specifies the Docker image to use for the deployment. This will pull the latest Nginx image from Docker Hub.
Expose Deployment:
```
kubectl expose deployment nginx --port=80 --type=NodePort
```
This command exposes the Nginx deployment as a service. The --port=80 flag specifies the port to expose, and the --type=NodePort flag creates a NodePort service, which makes the application accessible from outside the cluster.
Get Service Information:
```
kubectl get service nginx
```
This command displays information about the Nginx service. Look for the NodePort value, which is the port you'll use to access the application.
Access the Application:

Open a web browser and navigate to http://<worker_node_ip>:<node_port>. Replace <worker_node_ip> with the IP address of one of your worker nodes, and <node_port> with the NodePort value you obtained in the previous step. You should see the default Nginx welcome page. If you do, congratulations! Your Kubernetes cluster is working.

Step 7: Troubleshooting Tips

Sometimes things don't go as planned. Here are some troubleshooting tips to help you out:

Check Logs:

Use kubectl logs <pod_name> -n <namespace> to check the logs of a specific pod. This can help you identify issues with your application.
Check Pod Status:

Use kubectl get pods -n <namespace> to check the status of all pods in a namespace. Look for pods that are not in a Running state.
Describe Pod:

Use kubectl describe pod <pod_name> -n <namespace> to get detailed information about a pod, including events and any issues that may have occurred.
Check Kubelet Status:

On each node, use sudo systemctl status kubelet to check the status of the kubelet service. If the kubelet is not running, try restarting it with sudo systemctl restart kubelet.
Firewall Issues:

Ensure that your firewall is not blocking traffic between the nodes. You may need to open specific ports to allow communication between the master and worker nodes.

Conclusion

And there you have it! You've successfully created a Kubernetes cluster on Ubuntu 22.04. This is just the beginning, though. Kubernetes is a powerful tool with many features to explore. From here, you can start deploying more complex applications, setting up persistent storage, and exploring advanced networking options. Keep experimenting, and don't be afraid to dive deeper into the world of Kubernetes! Happy clustering!