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

Nov 3, 2025 by Team 63 views

Hey everyone! Today, we're diving into setting up a Kubernetes cluster on Ubuntu 24.04. Whether you're a seasoned DevOps engineer or just starting with container orchestration, this guide will walk you through each step. We'll cover everything from installing the necessary tools to deploying your first application. So, grab your favorite beverage, and let's get started!

Prerequisites

Before we jump into the actual setup, let's make sure we have all the prerequisites in place. This includes the necessary hardware, software, and network configurations. Ensuring these are correctly set up will save you a lot of headaches down the road.

Hardware Requirements: You'll need at least two Ubuntu 24.04 servers. One will act as the master node, and the other as a worker node. For development and testing, virtual machines are perfectly fine. Ensure each machine has at least 2 CPUs and 4GB of RAM. For production environments, you'll want to beef up these specs based on your workload.
Operating System: Make sure you have Ubuntu 24.04 installed on all your machines. A clean installation is always recommended to avoid conflicts with existing software.
Network Configuration: Ensure that all your nodes can communicate with each other over the network. This typically involves setting up a private network or ensuring that the firewall allows traffic between the nodes. A stable network is crucial for Kubernetes to function correctly.
Internet Access: All nodes should have access to the internet to download the necessary packages. If you're behind a corporate firewall, make sure to configure your proxy settings.

Installing Container Runtime (Docker)

First, let's install Docker, which will serve as our container runtime. Docker is a popular choice, but you can also use other container runtimes like containerd. We’ll focus on Docker for this guide because of its widespread use and ease of setup.

Update Package Index: Start by updating the package index on all your nodes.
```
sudo apt update
```

Install Required Packages: Install packages to allow apt to use a repository over HTTPS.

sudo apt install apt-transport-https ca-certificates curl software-properties-common

Add Docker GPG Key: Add Docker’s official GPG key to ensure the packages are authentic.

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Set Up the Docker Repository: Add the Docker repository to your apt sources.

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Install Docker Engine: Update the package index again and install Docker Engine.
```
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io
```
Verify Docker Installation: Check if Docker is installed correctly by running the hello-world image.
```
sudo docker run hello-world
```
If everything is set up correctly, you should see a message from the hello-world image.

Installing and Configuring Kubernetes Components

Now that we have Docker installed, let's move on to installing the Kubernetes components. This includes kubeadm, kubelet, and kubectl. kubeadm is a tool for bootstrapping Kubernetes clusters, kubelet is the agent that runs on each node, and kubectl is the command-line tool for interacting with the cluster.

Install Kubernetes Packages: Add the Kubernetes apt repository.

sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl
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 -a /etc/apt/sources.list.d/kubernetes.list
sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

Disable Swap: Kubernetes requires swap to be disabled. Edit the /etc/fstab file and comment out the swap line.
```
sudo swapoff -a
sudo sed -i '/ swap / s/^/#/' /etc/fstab
```

Initializing the Kubernetes Master Node

With all the necessary components installed, we can now initialize the Kubernetes master node. This is a crucial step that sets up the control plane.

Initialize the Master Node: Use kubeadm init to initialize the master node. Replace <master-node-ip> with the actual IP address of your master node.
```
sudo kubeadm init --apiserver-advertise-address=<master-node-ip> --pod-network-cidr=10.244.0.0/16
```
Make sure to save the kubeadm join command that is displayed at the end of the initialization process. You'll need this command to join the worker nodes to the cluster.
Configure kubectl: Configure kubectl to connect to the cluster. This involves copying the Kubernetes configuration file to your user directory.
```
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
```

Deploying a Pod Network

A pod network is essential for allowing pods to communicate with each other. We'll use Calico as our pod network, but you can also use other options like Flannel or Cilium.

Install Calico: Apply the Calico manifest to install it.
```
kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml
```
Wait for all the Calico pods to be in the running state before proceeding.

Joining Worker Nodes to the Cluster

Now that the master node is initialized and the pod network is deployed, we can join the worker nodes to the cluster.

Join Worker Nodes: Use the kubeadm join command that you saved earlier on each worker node.
```
sudo kubeadm join <master-node-ip>:6443 --token <token> --discovery-token-ca-cert-hash sha256:<hash>
```
If you don't have the kubeadm join command, you can generate a new token on the master node.
```
kubeadm token create --print-join-command
```

Verifying the Cluster

After joining the worker nodes, it's important to verify that the cluster is set up correctly.

Check Node Status: On the master node, use kubectl get nodes to check the status of the nodes.
```
kubectl get nodes
```
You should see all your nodes listed in the output, with their status as Ready.
Check Pod Status: Use kubectl get pods --all-namespaces to check the status of the pods.
```
kubectl get pods --all-namespaces
```
Ensure that all the essential pods are running without any issues.

Deploying Your First Application

With the cluster up and running, let's deploy a simple application to test everything out. We'll deploy a basic Nginx deployment.

Create a Deployment: Create an Nginx deployment using kubectl run.
```
kubectl run nginx --image=nginx --replicas=2 --port=80
```

Expose the Deployment: Expose the deployment as a service.

kubectl expose deployment nginx --port=80 --type=NodePort

Access the Application: Get the NodePort and access the application through your browser using the IP address of one of your nodes.
```
kubectl get svc nginx
```
You should see the default Nginx welcome page.

Troubleshooting

Setting up a Kubernetes cluster can sometimes be tricky. Here are some common issues and their solutions.

Nodes Not Joining: Ensure that the firewall is not blocking traffic between the nodes. Also, double-check the kubeadm join command for any typos.
Pods Not Running: Check the logs of the pods using kubectl logs <pod-name> -n <namespace> to identify any issues.
Network Issues: Verify that the pod network is correctly installed and configured. Check the Calico logs for any errors.

Conclusion

Congratulations! You've successfully set up a Kubernetes cluster on Ubuntu 24.04. This guide covered everything from installing the necessary tools to deploying your first application. Remember to keep your cluster secure and up-to-date. Happy orchestrating, folks!

Keywords: Kubernetes, Ubuntu 24.04, Docker, kubeadm, kubelet, kubectl, Calico, container orchestration, cluster setup

This is just the beginning. Kubernetes offers a vast array of features and capabilities. Explore more about deployments, services, namespaces, and more to unlock the full potential of container orchestration. Don't hesitate to dive deeper into topics like security, monitoring, and scaling to ensure your applications are running smoothly and efficiently. Keep experimenting, keep learning, and you'll become a Kubernetes pro in no time!