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

Nov 3, 2025 by Team 64 views

Creating a Kubernetes cluster on Ubuntu 24.04 can seem daunting, but with the right guidance, it becomes a manageable task. This article provides a comprehensive, step-by-step guide to help you set up your own Kubernetes cluster. Whether you're a seasoned developer or just starting with container orchestration, this guide will walk you through each stage of the process, ensuring you have a robust and functional cluster ready for your applications. So, let's dive in and get your Kubernetes cluster up and running on Ubuntu 24.04!

Prerequisites

Before we begin, there are a few prerequisites that you need to have in place. These include:

Ubuntu 24.04 Servers: You'll need at least two Ubuntu 24.04 servers. One will act as the master node, and the others will be worker nodes. Ensure these servers have network connectivity between them.
SSH Access: Make sure you have SSH access to all the servers. This will allow you to remotely configure them.
Root or Sudo Privileges: You'll need root or sudo privileges on all the servers to install and configure the necessary software.
Basic Linux Knowledge: A basic understanding of Linux commands and concepts will be helpful.
Internet Connection: All servers should have access to the internet to download packages.

Having these prerequisites in place will ensure a smooth setup process. Without them, you might encounter issues that could prevent you from successfully creating your Kubernetes cluster.

Step 1: Install Container Runtime (Docker)

First, you need to install a container runtime on all your nodes. Docker is a popular choice. To install Docker, follow these steps:

Update Package Index: Start by updating the package index on all your servers.
```
sudo apt update
```
Install Required Packages: Install packages that 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 the Docker 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

Add Docker Repository: Add the Docker repository to your system's 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

Update Package Index Again: Update the package index again to include the new Docker repository.
```
sudo apt update
```

Install Docker: Finally, install Docker.

sudo apt install docker-ce docker-ce-cli containerd.io

Verify Docker Installation: Verify that Docker is installed correctly by checking its version.
```
docker --version
```
Start and Enable Docker: Start the Docker service and enable it to start on boot.
```
sudo systemctl start docker
sudo systemctl enable docker
```

Installing Docker correctly is crucial because Kubernetes uses it to run containerized applications. Without a properly installed container runtime, Kubernetes won't be able to manage your containers.

Step 2: Install Kubectl, Kubeadm, and Kubelet

Next, you need to install the Kubernetes command-line tool (kubectl), the Kubernetes node agent (kubelet), and the Kubernetes cluster bootstrapping tool (kubeadm) on all your nodes. These tools are essential for managing and deploying Kubernetes. Here’s how to install them:

Add Kubernetes GPG Key: Add the Kubernetes GPG key.

curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

Add Kubernetes Repository: Add the Kubernetes repository to your system's sources.

echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

Update Package Index: Update the package index.
```
sudo apt update
```
Install Kubectl, Kubeadm, and Kubelet: Install the necessary Kubernetes tools. Make sure to hold the version to prevent automatic updates.
```
sudo apt install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl
```
Verify Installation: Verify that the tools are installed correctly by checking their versions.
```
kubectl version --client
kubeadm version
kubelet --version
```

Kubeadm is used to bootstrap the Kubernetes cluster, kubelet runs on each node and manages the containers, and kubectl is the command-line tool to interact with the cluster. Ensuring these tools are correctly installed and configured is vital for the proper functioning of your Kubernetes cluster.

Step 3: Initialize the Kubernetes Cluster (Master Node)

Now, you need to initialize the Kubernetes cluster on your master node. This process sets up the control plane components. Here's how to do it:

Initialize Kubernetes: Use kubeadm to initialize the cluster. Replace --apiserver-advertise-address with the IP address of your master node and --pod-network-cidr with a suitable CIDR block for your pod network. Choose a CIDR block that doesn't overlap with your existing network.
```
sudo kubeadm init --apiserver-advertise-address=<MASTER_NODE_IP> --pod-network-cidr=10.244.0.0/16
```
Configure Kubectl: Configure kubectl to connect to the cluster. Follow the instructions provided in the output of the kubeadm init command. Typically, this involves running the following commands:
```
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
```
Deploy a Pod Network: Deploy a pod network. We'll use Calico in this example. Apply the Calico manifest.
```
kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml
```
Note: Different pod networks have different installation procedures. Make sure to follow the instructions specific to your chosen network.

Initializing the Kubernetes cluster correctly is paramount. The kubeadm init command sets up the control plane, which manages the entire cluster. Without a properly initialized control plane and a functioning pod network, your cluster will not operate correctly, and you won't be able to deploy applications.

Step 4: Join Worker Nodes to the Cluster

Next, you need to join your worker nodes to the cluster. This process involves running a kubeadm join command on each worker node. The command is provided in the output of the kubeadm init command on the master node.

Get the Join Command: If you don't have the kubeadm join command, you can regenerate it on the master node.
```
kubeadm token create --print-join-command
```
Run the Join Command: Run the kubeadm join command on each worker node. It should look something like this:
```
sudo kubeadm join <MASTER_NODE_IP>:6443 --token <TOKEN> --discovery-token-ca-cert-hash sha256:<HASH>
```
Verify Node Status: On the master node, verify that the worker nodes have joined the cluster.
```
kubectl get nodes
```
Note: It might take a few minutes for the nodes to become ready.

Joining the worker nodes to the cluster is crucial because these nodes are where your applications will run. Without properly joined worker nodes, your cluster will not have the resources to deploy and manage your applications.

Step 5: Deploy a Sample Application

Now that your cluster is up and running, let's deploy a sample application to test it. We'll deploy a simple Nginx deployment.

Create a Deployment: Create an Nginx deployment using kubectl. Save the following content to a file named nginx-deployment.yaml.

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

Apply the Deployment: Apply the deployment using kubectl.
```
kubectl apply -f nginx-deployment.yaml
```

Create a Service: Create a service to expose the Nginx deployment. Save the following content to a file named 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 the Service: Apply the service using kubectl.
```
kubectl apply -f nginx-service.yaml
```
Check the Status: Check the status of the deployment and service.
```
kubectl get deployments
kubectl get services
```
Access the Application: Access the application using the external IP address provided by the service. Open a web browser and navigate to that IP address.

Deploying a sample application is essential to verify that your Kubernetes cluster is functioning correctly. If the application deploys successfully and you can access it, then your cluster is ready for more complex workloads.

Step 6: Monitoring and Maintenance

Once your Kubernetes cluster is up and running, monitoring and maintenance are crucial for ensuring its long-term health and stability. Here are some key areas to focus on:

Resource Monitoring: Monitor CPU, memory, and disk usage on your nodes. Tools like Prometheus and Grafana can help you visualize these metrics.
Log Aggregation: Collect and analyze logs from your applications and Kubernetes components. Tools like Elasticsearch, Fluentd, and Kibana (EFK stack) can be used for this purpose.
Alerting: Set up alerts for critical events, such as node failures or high resource usage. Prometheus Alertmanager can be used to manage alerts.
Regular Updates: Keep your Kubernetes components and operating system up to date with the latest security patches and bug fixes.
Backup and Restore: Implement a backup and restore strategy for your cluster's etcd data. This will allow you to recover from failures.

Regular monitoring and maintenance are vital for keeping your Kubernetes cluster running smoothly and reliably. Ignoring these tasks can lead to performance issues, security vulnerabilities, and potential downtime.

Conclusion

Congratulations! You've successfully created a Kubernetes cluster on Ubuntu 24.04. This guide has walked you through the essential steps, from installing the necessary tools to deploying a sample application. Remember to monitor and maintain your cluster regularly to ensure its long-term health and stability. Kubernetes is a powerful tool for container orchestration, and with a properly configured cluster, you'll be able to deploy and manage your applications with ease. Guys, keep exploring and experimenting with Kubernetes to unlock its full potential!