Install Kubernetes Cluster On Ubuntu Easily

Oct 23, 2025 by Jhon Lennon 44 views

What's up, tech enthusiasts! Today, we're diving deep into something super cool: installing a Kubernetes cluster on Ubuntu. If you're looking to get your hands dirty with container orchestration, you've come to the right place, guys. Kubernetes, or K8s as we cool kids call it, is the undisputed champion when it comes to managing containerized applications at scale. It's like the ultimate conductor for your microservices orchestra, ensuring everything runs smoothly, scales effortlessly, and heals itself when things go wrong. Ubuntu, on the other hand, is a rock-solid, user-friendly Linux distribution that many of us love. Combining the two? Pure magic! This guide is designed to walk you through the entire process, from setting up your nodes to getting your first pod running. We'll break down complex steps into digestible chunks, making sure that even if you're new to Kubernetes, you'll be able to follow along. We'll cover the prerequisites, the installation of necessary tools like kubeadm, kubelet, and kubectl, and then the actual cluster creation. Get ready to level up your DevOps game because by the end of this, you'll have a functional Kubernetes cluster humming on your Ubuntu machines. So, grab your favorite beverage, settle in, and let's get this cluster built!

Prerequisites for Your Kubernetes Cluster

Alright team, before we jump into the actual installation of a Kubernetes cluster on Ubuntu, let's make sure we've got all our ducks in a row. Having the right prerequisites sorted out will save you a ton of headaches down the line. Think of this as building a strong foundation for your brand-new K8s empire. First off, you'll need at least two Ubuntu machines. One will act as your control-plane node (the brain of the operation), and the others will be your worker nodes (the muscle that runs your applications). These machines can be physical servers, virtual machines (like those you'd run on VirtualBox or VMware), or even cloud instances. The key is that they need to be able to communicate with each other over a network. For any serious Kubernetes deployment, a minimum of 2GB RAM and 2 CPU cores per node is highly recommended. While you can get away with less, performance might suffer, especially as your cluster grows. Also, make sure you've got decent network connectivity between all your nodes. Static IP addresses for your nodes are a big plus, as it simplifies network configuration and avoids potential issues. Ensure that SWAP is disabled on all nodes. Kubernetes doesn't play well with SWAP, as it can lead to performance issues and unpredictable behavior. You can disable SWAP temporarily with sudo swapoff -a and permanently by commenting out the swap line in /etc/fstab. You'll also need sudo privileges on all nodes, as we'll be installing system-level packages and configuring network settings. Finally, ensure that your Ubuntu version is supported by kubeadm – generally, the latest LTS (Long Term Support) versions like Ubuntu 20.04 LTS or 22.04 LTS are excellent choices. Don't forget to update your system packages on all nodes by running sudo apt update && sudo apt upgrade -y. This ensures you're starting with the latest security patches and software versions. Having SSH access between your nodes is also crucial for easy management and deployment. So, double-check that you can SSH from your control-plane node to your worker nodes and vice-versa without any password prompts (using SSH keys is the best way to go here).

Installing Kubeadm, Kubelet, and Kubectl

Now that our groundwork is laid, let's get to the exciting part: installing the core Kubernetes components on Ubuntu. These are the essential tools that will allow us to build and manage our cluster. We're talking about kubeadm, kubelet, and kubectl. kubeadm is the official Kubernetes tool for bootstrapping a cluster. It handles the complex setup and initialization process. kubelet is the agent that runs on each node in your cluster and ensures that containers are running in a Pod. kubectl is the command-line tool you'll use to interact with your Kubernetes cluster – it's your main interface for sending commands and getting information. We need to install these on all nodes (both control-plane and worker nodes). First, we'll set up the Kubernetes package repositories. Since these packages aren't in the default Ubuntu repositories, we need to add them manually.

On each node (yes, you read that right, do this on all your machines), run the following commands:

# Update package index and install packages transport-https, mk-dir, ca-certificates, curl, gnupg
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl gpg gnupg

# Add Google Cloud public signing key
curl -fsSL https://pkgs.k8s.io/core-/stable/v1.28/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

# Add Kubernetes apt repository
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core-/stable/v1.28/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

# Update package index again to include the new repository
sudo apt-get update

# Install kubelet, kubeadm, and kubectl
sudo apt-get install -y kubelet kubeadm kubectl

# Hold the packages to prevent accidental upgrades
sudo apt-mark hold kubelet kubeadm kubectl

This sequence of commands ensures that your system can securely fetch the Kubernetes packages and then installs kubelet, kubeadm, and kubectl. The apt-mark hold command is crucial because it prevents these packages from being automatically upgraded by apt upgrade, which could potentially break your cluster if the new versions are not compatible. We want control over when our Kubernetes components are updated, right? You'll notice we're installing specific versions here. While you can omit the version number to get the latest, it's often best practice in production environments to pin to specific versions to ensure stability and predictability. We're using v1.28 here, but you can adjust this to the latest stable version you prefer. After running these commands, you should have the necessary tools installed on all your machines, ready for the next step: creating the actual cluster!

Initializing the Control-Plane Node

Alright folks, we've got the tools, now it's time to initialize the Kubernetes control-plane node on Ubuntu. This is where the magic really begins! The control-plane node is the brain of your Kubernetes cluster. It runs critical components like the API server, scheduler, and controller manager. When you initialize this node using kubeadm, it sets up all these essential services and prepares it to manage your worker nodes. Make sure you're performing these steps on the machine designated as your control-plane node. First, we need to pull the necessary container images that Kubernetes will use. kubeadm init does this automatically, but it's good to know what's happening. Let's run the initialization command:

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

This command is the heart of our cluster setup. The --pod-network-cidr=10.244.0.0/16 flag is important. It tells Kubernetes the IP address range that will be used for Pods. We're using 10.244.0.0/16 here, which is a common choice for the Flannel CNI (Container Network Interface) plugin that we'll likely install later. If you plan to use a different CNI, you might need to adjust this CIDR accordingly. Once kubeadm init completes, it will output some crucial information. Pay close attention to the post-installation instructions it provides. It will tell you how to configure kubectl to communicate with your new cluster, and importantly, it will give you a kubeadm join command. This join command contains a token and a discovery hash, and it's what you'll use to connect your worker nodes to this control-plane. Keep that join command handy – you'll need it in a moment!

To configure kubectl so that your regular user can interact with the cluster, run these commands right after kubeadm init succeeds:

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

Now, try running kubectl get nodes. You should see your control-plane node listed, but it will likely be in a NotReady state. That's perfectly normal at this stage because we haven't installed a pod network yet. The control-plane node is up and running, ready to receive instructions, but your pods won't be able to communicate with each other until a CNI plugin is in place. So, congratulations, you've just bootstrapped the control plane of your Kubernetes cluster on Ubuntu!

Setting Up the Pod Network

Okay, so our control-plane node is initialized, and we've got kubectl configured. However, as we saw, our nodes are still in a NotReady state. Why? Because Kubernetes needs a pod network to allow communication between pods, even if they are running on different nodes. Think of it like giving your containers a phone line so they can talk to each other. Without it, they're isolated and can't function correctly as a distributed system. This is where a Container Network Interface (CNI) plugin comes in. There are several CNI plugins available, such as Flannel, Calico, Weave Net, and Cilium. For simplicity and ease of use, especially when you're just starting out, Flannel is a fantastic choice. It's lightweight, easy to install, and works great for most use cases. We'll be using Flannel for our setup here, and it's why we specified the --pod-network-cidr=10.244.0.0/16 during the kubeadm init step.

To install Flannel, you'll typically apply a YAML manifest file provided by the Flannel project. You can usually find the latest manifest on their GitHub repository. Here's how you can apply it:

kubectl apply -f https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml

This command downloads the Flannel configuration file directly from GitHub and applies it to your cluster. Kubernetes will then create the necessary pods (usually running as a DaemonSet) on each node to manage the pod networking. It might take a minute or two for the Flannel pods to start up and for the network to become fully functional. Once the Flannel pods are running, you should see your nodes transition from the NotReady state to Ready. You can check the status of your nodes again using kubectl get nodes. You should now see all your nodes listed as Ready.

It's also a good idea to check the status of the Flannel pods themselves. You can do this with kubectl get pods -n kube-system | grep flannel. You should see pods running for each node, indicating that the network is active. If you encounter any issues, check the logs of the Flannel pods for troubleshooting clues. The installation of the pod network is a critical step, as it enables the fundamental communication layer that Kubernetes relies on. Without a functioning pod network, your cluster is essentially crippled. So, getting Flannel up and running means you've successfully enabled inter-node pod communication, a key feature of any distributed container orchestration system. This step is vital for any Kubernetes deployment, whether it's for development, testing, or production workloads. Remember, a properly configured network is the backbone of a healthy Kubernetes cluster!

Joining Worker Nodes to the Cluster

We've done the heavy lifting on the control-plane, and we've got our network up and running. Now it's time to bring our worker nodes into the Kubernetes cluster on Ubuntu. Worker nodes are where your actual application containers will run. They receive instructions from the control-plane and execute the pods. You'll need to perform this step on each of your worker machines. Remember that kubeadm join command we saved from the kubeadm init output? Now's the time to use it! If, for some reason, you lost that command or it expired (tokens are valid for 24 hours by default), you can generate a new one on the control-plane node with:

sudo kubeadm token create --print-join-command

This will output a new kubeadm join command. Copy the entire command.

Now, head over to each of your worker nodes and paste that kubeadm join command into your terminal and run it with sudo:

sudo <paste_the_kubeadm_join_command_here>

For example, it might look something like this:

sudo kubeadm join <control-plane-ip>:6443 --token <some-token-hash> \
    --discovery-token-ca-cert-hash sha256:<some-ca-hash>

When you run this command on a worker node, it contacts the control-plane, presents its token for authentication, and registers itself as a new node in the cluster. It will then start downloading necessary components and configure itself to become a functioning part of your Kubernetes cluster. You'll see output indicating that the node has joined successfully.

To verify that your worker nodes have joined the cluster, head back to your control-plane node and run kubectl get nodes again:

kubectl get nodes

You should now see all your nodes listed, including the newly joined worker nodes, and they should all be in the Ready state. If a worker node shows up as NotReady, double-check network connectivity between the nodes, ensure kubelet is running on the worker (sudo systemctl status kubelet), and verify that the kubeadm join command was executed correctly. You might also want to check the kubelet logs on the worker node for any errors.

Adding worker nodes is a straightforward process once the control-plane is up and running. It's this ability to easily scale your cluster by adding more worker nodes that makes Kubernetes so powerful. You can add as many worker nodes as your infrastructure and workload demands. Congratulations, guys! You've successfully expanded your Kubernetes cluster by joining worker nodes. Now your cluster is ready to start deploying applications!

Deploying Your First Application

Awesome work, everyone! We've successfully set up a Kubernetes cluster on Ubuntu, initialized the control-plane, configured networking, and joined our worker nodes. Now for the most exciting part: deploying your first application on Kubernetes. This is where you see all your hard work pay off as you bring your containerized app to life within the cluster. Let's keep it simple for our first deployment. We'll deploy a basic Nginx web server. Nginx is a popular, high-performance web server and reverse proxy, and it's perfect for a test run.

We'll use kubectl to create a Deployment. A Deployment is a Kubernetes object that manages a set of identical Pods. It ensures that a specified number of replicas of your application are running and can handle updates and rollbacks. To create a Deployment for Nginx, run the following command:

kubectl create deployment nginx-deployment --image=nginx --replicas=2

Let's break this down:

kubectl create deployment: This is the command to create a new Deployment object.
nginx-deployment: This is the name we're giving to our deployment. You can choose any name you like.
--image=nginx: This specifies the Docker image to use for our application. We're using the official nginx image from Docker Hub.
--replicas=2: This tells Kubernetes that we want to run two instances (replicas) of our Nginx application. This ensures high availability – if one pod fails, another one is ready to take over.

After running this command, Kubernetes will schedule these pods onto your worker nodes and pull the Nginx image if it's not already present. You can check the status of your deployment and pods with these commands:

kubectl get deployments
kubectl get pods

You should see nginx-deployment listed with 2/2 replicas available. And you should see two Nginx pods running, each with a unique name. Now, to actually access our Nginx server from outside the cluster, we need to expose it. We do this by creating a Service. A Service provides a stable IP address and DNS name for a set of Pods, acting as a load balancer. We'll create a NodePort service, which makes the application accessible on a static port on each node's IP address.

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

kubectl expose deployment nginx-deployment: This command creates a Service that targets the nginx-deployment.
--type=NodePort: This specifies the type of Service. NodePort exposes the Service on each Node's IP at a static port (the NodePort).
--port=80: This is the port the Service will expose internally, matching the port Nginx listens on.

After creating the Service, you can find out which NodePort was assigned using:

kubectl get services

Look for the nginx-deployment service. You'll see a port mapping like 80:3xxxx/TCP. The 3xxxx is the NodePort. Now, you can access your Nginx server by opening a web browser and navigating to http://<your-node-ip>:<nodeport>. Replace <your-node-ip> with the IP address of any of your Kubernetes nodes (control-plane or worker) and <nodeport> with the dynamically assigned port number (e.g., 30080 if that's what kubectl get services shows). You should see the default Nginx welcome page! Congratulations, guys, you've just deployed and exposed your first application on your very own Kubernetes cluster on Ubuntu. This is just the tip of the iceberg of what you can do with Kubernetes, but it's a massive achievement!

Conclusion: Your Kubernetes Journey Begins!

And there you have it, folks! You've successfully navigated the process of installing a Kubernetes cluster on Ubuntu. From setting up the prerequisites and installing essential tools like kubeadm, kubelet, and kubectl, to initializing the control-plane, configuring the pod network with Flannel, joining your worker nodes, and finally deploying your first application – you've accomplished a significant feat. You now have a fully functional, albeit small, Kubernetes cluster ready to host your containerized applications. This is a huge step forward in mastering container orchestration and unlocking the power of Kubernetes. Remember, this guide is just the starting point. Kubernetes is a vast ecosystem with countless features and configurations to explore. You can dive deeper into Deployments, explore different Service types like LoadBalancer and ClusterIP, learn about StatefulSets for persistent data, implement advanced networking with Ingress controllers, secure your cluster with RBAC, and so much more. Don't be afraid to experiment! The best way to learn is by doing. Try deploying different applications, explore different configuration options, and don't hesitate to consult the official Kubernetes documentation or community forums when you hit a roadblock. Building and managing Kubernetes clusters takes practice, but the skills you gain are invaluable in today's cloud-native world. Keep learning, keep building, and enjoy your journey into the exciting world of Kubernetes on Ubuntu! You guys rock!