Build A Kubernetes Cluster On Ubuntu: A Comprehensive Guide

Oct 30, 2025 by Team 60 views

Hey there, fellow tech enthusiasts! Ever wanted to dive into the world of container orchestration? Well, you're in luck! Today, we're going to build a Kubernetes cluster on Ubuntu. Kubernetes, or K8s as the cool kids call it, is like the conductor of your application orchestra, making sure everything runs smoothly. Ubuntu, on the other hand, is a popular Linux distribution known for its user-friendliness and robustness. So, let's get started and make your application deployments a breeze. This comprehensive guide will walk you through everything you need to know, from setting up your virtual machines to deploying your first application. We will begin with the basics, covering the necessary prerequisites and the core concepts of Kubernetes. Then, we will proceed to set up the infrastructure. Finally, we will configure the Kubernetes cluster and deploy a sample application. By the end of this guide, you will have a fully functional Kubernetes cluster running on Ubuntu, ready to manage your containerized applications. Let’s get our hands dirty!

Understanding the Basics: Kubernetes and Ubuntu

Alright, before we get our hands dirty with the technical stuff, let's take a quick look at what we're actually dealing with. Kubernetes is an open-source system for automating the deployment, scaling, and management of containerized applications. Think of it as a control panel for your containers, making sure they're always up and running, and easily scalable. Ubuntu, on the other hand, is a Linux distribution. It’s the operating system that will host our Kubernetes cluster. We will set up multiple Ubuntu machines to act as nodes in our cluster. Kubernetes allows us to manage containers efficiently across these nodes. It provides the necessary tools and infrastructure to deploy, scale, and manage containerized applications, making it an essential platform for modern software development and deployment. The beauty of Kubernetes lies in its ability to abstract away the underlying infrastructure, allowing developers to focus on their applications rather than the complexities of managing servers. It’s all about making your life easier! By the end of this journey, you'll not only have a running Kubernetes cluster on Ubuntu but also a solid understanding of the core concepts that power this amazing technology. Remember, this guide is designed to be beginner-friendly, so don't worry if you're new to this. We'll take it step by step, ensuring you grasp each concept before moving on.

Core Kubernetes Concepts

To make sure you're well-equipped, let’s quickly touch on some core Kubernetes concepts:

Pods: The smallest deployable units in Kubernetes. A pod can contain one or more containers, sharing storage and network resources.
Nodes: The worker machines in a Kubernetes cluster. These can be physical or virtual machines. Nodes host the pods.
Deployments: Used to manage the desired state of your application. Deployments ensure that the specified number of pods are running and automatically replace any that fail.
Services: An abstraction layer that defines a logical set of pods and a policy by which to access them. Services enable applications to communicate with each other within the cluster.
Namespaces: Provide a scope for names. Namespaces are used to divide cluster resources between multiple users or projects.

Ubuntu: The Foundation

Ubuntu will serve as the foundation of your Kubernetes cluster. Here's why it's a great choice:

User-Friendly: Ubuntu is known for its ease of use, making it ideal for both beginners and experienced users.
Stability: Ubuntu offers a stable and reliable platform for running your cluster.
Community Support: There's a massive community behind Ubuntu, meaning you'll find plenty of support and documentation.

Setting Up the Infrastructure: Ubuntu Machines

Okay, now that we've covered the basics, let's get down to the nitty-gritty. Before you can build your Kubernetes cluster, you need to set up the infrastructure. This means having Ubuntu machines ready to go. I will explain in detail the necessary steps to set up Ubuntu machines for our Kubernetes cluster. It’s like preparing the stage before the show begins. So, let’s get started and prepare our Ubuntu machines.

Virtual Machines or Physical Servers?

You have a couple of options here:

Virtual Machines (VMs): Using VMs is often the easiest way to get started. You can use tools like VirtualBox, VMware, or cloud providers like AWS, Google Cloud, or Azure to create your VMs. This approach offers flexibility and allows you to experiment without affecting your main system.
Physical Servers: If you have the hardware, you can use physical servers. This provides more resources and potentially better performance.

For this guide, we'll assume you're using VMs since that's the most accessible option for most people. However, the setup process is similar for physical servers.

Choosing Your Ubuntu Version

It's recommended to use a supported version of Ubuntu. As of the time of this guide, Ubuntu 22.04 LTS is a great choice because it provides long-term support and is known for its stability. Make sure you download the Ubuntu Server image. We want the server version because it's lightweight and doesn't include a graphical user interface (GUI), which we don't need for a Kubernetes cluster.

Installing Ubuntu on Your Machines

Download the Ubuntu Server ISO: You can find it on the official Ubuntu website. Go to ubuntu.com and download the latest Ubuntu Server LTS image.
Create VMs: If you're using VirtualBox, create new VMs for each node in your cluster. Give each VM sufficient RAM (at least 2GB is recommended, but more is better) and disk space (at least 20GB). Consider allocating more resources for better performance.
Boot from the ISO: Attach the Ubuntu Server ISO to each VM and boot them. The installation process will start.
Follow the Installation Wizard: During the installation, you'll be prompted to configure various settings, like network configuration, storage, and user accounts. Configure a static IP address for each VM. This is crucial for your Kubernetes cluster to work correctly. Create a user account with sudo privileges. Make sure to choose a strong password.
Install SSH Server: During the installation, you'll be asked which packages to install. Select the SSH server. This will allow you to connect to your VMs remotely.
Complete the Installation: Once the installation is complete, reboot each VM.

Configuring Network Settings

After installing Ubuntu on your VMs, you need to configure the network settings. Here's what you need to do:

Static IP Addresses: Assign a static IP address to each VM. This is essential for Kubernetes to communicate with the nodes. You can configure this during the Ubuntu installation process. If you didn't do it then, you will need to edit the network configuration files. You will need to know your network configuration for this. Here's how to configure a static IP address:
- Edit the network configuration file: sudo nano /etc/netplan/01-network-manager-all.yaml
- Configure your network settings. Here is an example: Replace the values with your network configuration:
```
network:
  version: 2
  renderer: networkd
  ethernets:
    ens33:
      dhcp4: no
      dhcp6: no
      addresses: [192.168.1.10/24 ] # Replace with your static IP and subnet
      gateway4: 192.168.1.1 # Replace with your gateway
      nameservers:
        addresses: [8.8.8.8, 8.8.4.4] # Replace with your DNS servers
```
- Apply the changes: sudo netplan apply
Hostname: Set a unique hostname for each VM. This will help you distinguish between the nodes in your cluster. Edit the /etc/hostname file and set the hostname. Then, edit the /etc/hosts file and map the hostname to the IP address. This helps the nodes find each other.
SSH Access: Make sure you can SSH into each VM from your host machine. This will allow you to manage your cluster remotely.

Setting Up the Kubernetes Cluster

Alright, now that we have our Ubuntu machines ready to go, it’s time to set up the Kubernetes cluster. This is where the magic really happens. We'll use kubeadm to initialize the control plane and join the worker nodes. We're going to use kubeadm because it simplifies the Kubernetes deployment process and makes it much easier to get up and running. This tool automates many of the complex configurations, enabling a smooth setup experience. Let's start and configure the Kubernetes cluster!

Installing Docker and Kubernetes Components

First, you need to install Docker and the necessary Kubernetes components on each Ubuntu machine. Follow these steps on all your VMs:

Update Package Index: Update the package index to ensure you have the latest package information: sudo apt update

Install Docker: Install Docker, which is the container runtime that Kubernetes will use:

sudo apt install docker.io -y
sudo systemctl enable docker
sudo systemctl start docker

Install Kubernetes Packages: Install the kubeadm, kubelet, and kubectl packages. These are the core components of Kubernetes:
```
sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl
```

Initializing the Control Plane

On one of your Ubuntu machines, which will be the control plane node, initialize the Kubernetes cluster using kubeadm. This will set up the master components:

Initialize the Cluster: Run the following command. Make sure to replace <YOUR_POD_NETWORK_CIDR> with your desired pod network CIDR. This determines the IP address range for your pods. A common choice is 10.244.0.0/16. It’s crucial to choose a CIDR that doesn’t conflict with your existing network.
```
sudo kubeadm init --pod-network-cidr=<YOUR_POD_NETWORK_CIDR>
```
- Note the output of this command, as it will provide you with the command to join worker nodes. It also gives you instructions on how to set up kubectl on your machine.

Set Up kubectl: Run the commands provided in the output of the kubeadm init command to 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

Install a Pod Network: Kubernetes requires a pod network add-on, like Calico, to be installed. This allows pods to communicate with each other. Choose a pod network and install it. Calico is a popular choice:
```
kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.26.1/manifests/calico.yaml
```
- You can verify the installation using kubectl get pods -n kube-system. The pods should be in the Running state.

Joining Worker Nodes

On each of your worker nodes (the other Ubuntu machines), join them to the cluster using the command from the kubeadm init output:

Join the Cluster: Run the kubeadm join command on each worker node. This command will look something like this. Replace <control-plane-ip:control-plane-port> with the IP address and port of your control plane node (e.g., 192.168.1.10:6443) and <token> and <hash> with the values from your kubeadm init output:
```
sudo kubeadm join <control-plane-ip:control-plane-port> --token <token> --discovery-token-ca-cert-hash sha256:<hash>
```
Verify the Nodes: Back on your control plane node, verify that all nodes have joined the cluster. Run the command: kubectl get nodes. You should see all your nodes listed, and their status should be Ready.

Deploying Your First Application: Hello World

Now that you have a fully functional Kubernetes cluster on Ubuntu, let's deploy a simple