Kubernetes On Ubuntu 24.04: A Quick Deployment Guide

by Jhon Lennon 53 views

Alright, folks! Let's dive into deploying a Kubernetes cluster on Ubuntu 24.04. This guide will walk you through the process, ensuring you have a fully functional and robust cluster. Whether you're a seasoned DevOps engineer or just starting with Kubernetes, this article will provide you with clear, step-by-step instructions.

Prerequisites

Before we get our hands dirty, let's ensure we have everything we need. First off, you'll need a few Ubuntu 24.04 servers. These can be physical machines or virtual machines—whatever floats your boat! Each server should have at least 2 GB of RAM and 2 CPUs to run smoothly. Also, ensure each machine has a unique hostname and static IP address, so they can communicate reliably. You'll also want to make sure that you have ssh access to all the servers, and sudo privileges enabled for your user. A stable internet connection goes without saying, as we'll be pulling down various packages and container images.

Networking is Key: Make sure your network allows communication between these servers on all ports, or at least the ports Kubernetes uses. Firewalls can be a pain, so configuring them correctly from the start is crucial. A misconfigured firewall is one of the most common issues when deploying Kubernetes, so double-check those rules!

Container Runtime: Kubernetes needs a container runtime to run containers, and we're going to use containerd. It's lightweight, efficient, and plays nicely with Kubernetes. We will install and configure this later. For those unfamiliar, a container runtime is the software responsible for running containers. Think of it as the engine that powers your containerized applications.

kubectl: This is the command-line tool to interact with your Kubernetes cluster. You’ll install kubectl on your local machine or a management server to manage the cluster. You can think of kubectl as your remote control for Kubernetes.

Understanding Kubernetes Components

Before we jump into the commands, let's get a high-level overview of the core components of a Kubernetes cluster.

  • Control Plane: This is the brain of the cluster. It includes components like the API server, scheduler, controller manager, and etcd.
    • API Server: This is the front-end for the Kubernetes control plane. All interactions go through the API server.
    • Scheduler: This component decides which node a pod should run on based on resource availability and other constraints.
    • Controller Manager: This manages various controllers that regulate the state of the cluster.
    • etcd: This is a distributed key-value store that stores the cluster's configuration data.
  • Nodes: These are the worker machines that run your applications. Each node runs a kubelet and a container runtime (like containerd).
    • kubelet: An agent that runs on each node and communicates with the control plane.
    • kube-proxy: A network proxy that runs on each node and manages network traffic to the pods.

Understanding these components will make troubleshooting much easier down the line.

Step-by-Step Deployment

Now, let's get to the exciting part – deploying our Kubernetes cluster! We’ll break this down into several steps:

Step 1: Update and Upgrade Packages

First, let's ensure our Ubuntu servers are up to date. Log into each of your servers and run the following commands:

sudo apt update
sudo apt upgrade -y

These commands update the package lists and upgrade the installed packages to their latest versions. Always a good practice before installing anything new.

Step 2: Install Containerd

Next, we'll install containerd. First, we need to install some dependencies:

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

Then, add the Docker GPG key:

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

Add the Docker repository to 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

Update the package list again:

sudo apt update

Now, install containerd:

sudo apt install -y containerd.io

Configure containerd by creating a default configuration file:

sudo mkdir -p /etc/containerd
sudo containerd config default | sudo tee /etc/containerd/config.toml

Edit the /etc/containerd/config.toml file to set SystemdCgroup = true under the [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc.options] section. This ensures that containerd uses systemd for cgroup management, which is required by Kubernetes.

[plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc.options]
  SystemdCgroup = true

Restart containerd to apply the changes:

sudo systemctl restart containerd

Enable containerd to start on boot:

sudo systemctl enable containerd

Step 3: Install Kubernetes Components

Now, let's install the Kubernetes components: kubelet, kubeadm, and kubectl. Add the Kubernetes GPG key:

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

Add the Kubernetes repository to APT sources:

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

Update the package list:

sudo apt update

Install kubelet, kubeadm, and kubectl:

sudo apt install -y kubelet kubeadm kubectl

Hold the package versions to prevent accidental upgrades:

sudo apt-mark hold kubelet kubeadm kubectl

Step 4: Initialize the Kubernetes Cluster

Now, designate one of your servers as the control plane node. On this server, initialize the Kubernetes cluster using kubeadm:

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

The --pod-network-cidr specifies the IP address range for the pod network. This example uses 10.244.0.0/16, which is the default for Calico, a popular networking solution. Make sure this range doesn't conflict with your existing network.

After the kubeadm init command completes, it will output a kubeadm join command. Save this command, as you'll need it to join the worker nodes to the cluster.

Configure kubectl to connect to the cluster. Run the following commands as your regular user (not as root):

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

Step 5: Install a Pod Network Add-on

Kubernetes requires a pod network add-on to enable communication between pods. We'll use Calico in this example. Apply the Calico manifest:

kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.26.1/manifests/calico.yaml

This command applies the Calico manifest to your cluster, setting up the necessary network policies and components.

Step 6: Join Worker Nodes to the Cluster

Now, log into each of your worker nodes and run the kubeadm join command that was output by the kubeadm init command on the control plane node. It should look something like this:

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

Replace <control-plane-ip>, <port>, <token>, and <hash> with the values from the output of kubeadm init. This command joins the worker node to the Kubernetes cluster.

Step 7: Verify the Cluster

Back on the control plane node, verify that the nodes have joined the cluster:

kubectl get nodes

You should see all your nodes listed, with their status as Ready. You can also check the status of the pods:

kubectl get pods --all-namespaces

This command lists all the pods in all namespaces. Ensure that all the core Kubernetes components are running and healthy.

Deploying Your First Application

Now that you have a working Kubernetes cluster, let's deploy a simple application. We'll deploy a basic Nginx web server.

Create a deployment:

kubectl create deployment nginx --image=nginx

Expose the deployment as a service:

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

Get the service information:

kubectl get service nginx

Find the NodePort that was assigned to the service. Then, you can access the Nginx web server by navigating to http://<node-ip>:<nodeport> in your web browser.

Troubleshooting

If you run into any issues, here are a few troubleshooting tips:

  • Check the logs: Use kubectl logs <pod-name> -n <namespace> to check the logs of a specific pod.
  • Describe the resources: Use kubectl describe pod <pod-name> -n <namespace> to get detailed information about a pod.
  • Check the kubelet status: Use sudo systemctl status kubelet on the nodes to check the status of the kubelet.
  • Firewall issues: Ensure that the necessary ports are open between the nodes. Kubernetes uses various ports for communication, so make sure they are not blocked.
  • CNI issues: If pods are not getting IP addresses, there might be an issue with the CNI (Container Network Interface) plugin. Check the logs of the CNI pods.

Conclusion

And there you have it! You've successfully deployed a Kubernetes cluster on Ubuntu 24.04. This guide should give you a solid foundation for deploying and managing your containerized applications on Kubernetes. Remember to keep your cluster updated and monitor its performance to ensure a smooth and reliable experience. Happy Kubernetes-ing, folks! I hope you find this helpful, and happy deploying, guys!