Kubernetes Cluster Setup On Ubuntu 22.04 LTS

by Team 45 views
Kubernetes 1.30.2 Cluster Setup on Ubuntu 22.04 LTS

Setting up a Kubernetes (K8s) cluster can seem daunting, but with a step-by-step guide, it becomes a manageable task. This article walks you through deploying a Kubernetes 1.30.2 cluster on Ubuntu 22.04 LTS. We'll cover everything from preparing your Ubuntu servers to initializing the cluster and deploying your first application. So, buckle up and let's get started!

Prerequisites

Before diving into the setup, let’s ensure you have everything you need:

  • Ubuntu 22.04 LTS Servers: You'll need at least three Ubuntu servers. One will act as the master node, and the others will be worker nodes. Ensure each server has a unique hostname and a static IP address.
  • Sudo Privileges: Make sure you have sudo privileges on all the servers to execute administrative commands.
  • Internet Connection: All servers should have access to the internet to download necessary packages.
  • Basic Linux Knowledge: Familiarity with Linux command-line operations is essential.
  • Containerization Concepts: A basic understanding of containerization concepts, especially Docker, will be helpful.

Hardware Requirements

For a basic setup, the following hardware specifications are recommended:

  • Master Node: 2 vCPUs, 4GB RAM, 20GB Storage
  • Worker Nodes: 1 vCPU, 2GB RAM, 20GB Storage

These are minimum requirements, and you might need more resources depending on the applications you plan to deploy on your cluster. Alright guys, let's make sure we have all of these prepared before we begin the Kubernetes adventure. Having the right foundation is key to a smooth and successful deployment. Trust me, spending a little extra time now to ensure everything is in place will save you headaches later. We want our Kubernetes cluster to be robust and ready to handle whatever we throw at it, so let's double-check those specs and prerequisites! Once we're all set, we can move on to the exciting part – the actual setup. You'll be amazed at how quickly you can get a fully functional Kubernetes cluster up and running. So, let's get to it and build something awesome together!

Step 1: Preparing the Ubuntu Servers

First, update and upgrade your Ubuntu servers. This ensures you have the latest packages and security updates. Run the following commands on all servers:

sudo apt update && sudo apt upgrade -y

Next, disable swap. Kubernetes requires swap to be disabled for proper functioning. Run these commands:

sudo swapoff -a
sudo sed -i '/ swap / s/^/#/' /etc/fstab

To ensure the changes persist after a reboot, comment out the swap line in /etc/fstab. Next, configure the hostname for each server. This will help you identify each node easily. For the master node, set the hostname to k8s-master:

sudo hostnamectl set-hostname k8s-master

For the worker nodes, set hostnames like k8s-worker-1 and k8s-worker-2:

sudo hostnamectl set-hostname k8s-worker-1
sudo hostnamectl set-hostname k8s-worker-2

Modify the /etc/hosts file on all servers to include the IP addresses and hostnames of all nodes. This ensures proper name resolution within the cluster. Add the following lines, replacing the IPs with your actual server IPs:

192.168.1.10 k8s-master
192.168.1.11 k8s-worker-1
192.168.1.12 k8s-worker-2

Run these commands to add the entries to the /etc/hosts file:

sudo echo "192.168.1.10 k8s-master" >> /etc/hosts
sudo echo "192.168.1.11 k8s-worker-1" >> /etc/hosts
sudo echo "192.168.1.12 k8s-worker-2" >> /etc/hosts

Don't forget to replace the IP addresses with your actual server IPs. After completing these steps, reboot all servers to apply the changes. By preparing our Ubuntu servers meticulously, we're laying a solid foundation for our Kubernetes cluster. Remember, a well-prepared environment can prevent a lot of headaches down the road. So, take your time, double-check your configurations, and ensure that everything is set up correctly. This initial groundwork is crucial for a smooth and successful Kubernetes deployment, so let's get it right from the start! You've got this!

Step 2: Installing Container Runtime (Docker)

Kubernetes requires a container runtime to run containers. Docker is a popular choice. To install Docker, first, update the package index:

sudo apt update

Then, install the necessary packages to allow apt to use a repository over HTTPS:

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

Add Docker’s official GPG key:

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

Set up the stable repository:

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 index again:

sudo apt update

Finally, install Docker Engine:

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

Verify that Docker is installed correctly by running:

sudo docker run hello-world

Enable and start the Docker service:

sudo systemctl enable docker
sudo systemctl start docker

By installing and configuring Docker, we're equipping our Kubernetes cluster with the ability to run containerized applications. Docker provides the runtime environment that Kubernetes needs to manage and orchestrate containers effectively. Ensure that Docker is running smoothly on all nodes, as this is crucial for the overall health and performance of your cluster. A properly installed and configured Docker runtime is the backbone of your Kubernetes deployment, so let's make sure it's rock-solid before moving on. You're doing great!

Step 3: Installing Kubectl, Kubeadm, and Kubelet

Next, install kubectl, kubeadm, and kubelet on all servers. These are essential components for managing and running a Kubernetes cluster. Add the Kubernetes apt repository:

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

Add the Kubernetes package source:

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

Update the package index:

sudo apt update

Install kubectl, kubeadm, and kubelet:

sudo apt install -y kubelet=1.30.2-00 kubeadm=1.30.2-00 kubectl=1.30.2-00

Hold the package versions to prevent accidental upgrades:

sudo apt-mark hold kubelet kubeadm kubectl

With kubectl, kubeadm, and kubelet installed, we're one step closer to having a fully functional Kubernetes cluster. These tools are the building blocks that enable us to manage and control our cluster effectively. kubeadm helps us initialize the cluster, kubelet runs on each node and manages the containers, and kubectl allows us to interact with the cluster from the command line. Ensuring that these components are installed correctly and held at the desired versions is crucial for maintaining the stability and consistency of our Kubernetes environment. You're doing an awesome job; keep it up!

Step 4: Initializing the Kubernetes Cluster

Now, initialize the Kubernetes cluster on the master node. Use the kubeadm init command with the --pod-network-cidr option to specify the network range for pods. Choose a CIDR block that does not overlap with your existing network. For example:

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

After the command completes, it will output a kubeadm join command. Save this command; 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:

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

Deploy a pod network. Calico is a popular choice for pod networking. Apply the Calico manifest:

kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml

Verify that all pods are running:

kubectl get pods --all-namespaces

By initializing the Kubernetes cluster, we're essentially setting up the control plane that manages our entire environment. The kubeadm init command bootstraps the master node, creating the necessary components and configurations for the cluster to function. Deploying a pod network like Calico ensures that our pods can communicate with each other, enabling the applications running within them to work seamlessly. Verifying that all pods are running confirms that our cluster is healthy and ready to accept workloads. Keep up the fantastic work, you're almost there!

Step 5: Joining Worker Nodes to the Cluster

Join the worker nodes to the cluster using the kubeadm join command that was outputted during the initialization of the master node. The command should look something like this:

sudo kubeadm join <master-ip>:6443 --token <token> --discovery-token-ca-cert-hash sha256:<hash>

Run this command on each worker node. After running the command on the worker nodes, check the status of the nodes on the master node:

kubectl get nodes

You should see all worker nodes listed in the output. Joining the worker nodes to the cluster expands our Kubernetes environment, adding more resources and capacity for running applications. The kubeadm join command securely connects the worker nodes to the master node, allowing them to participate in the cluster's workload. Checking the status of the nodes ensures that all worker nodes have successfully joined the cluster and are ready to receive instructions. You're doing a stellar job; keep pushing forward!

Step 6: Deploying a Sample Application

To test your Kubernetes cluster, deploy a sample application. Create a deployment and a service using kubectl. First, create a deployment file named nginx-deployment.yaml:

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

Apply the deployment:

kubectl apply -f nginx-deployment.yaml

Next, create a service 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:

kubectl apply -f nginx-service.yaml

Check the status of the deployment and service:

kubectl get deployments
kubectl get services

Access the application using the external IP address provided by the service. Deploying a sample application is the ultimate test of our Kubernetes cluster. It validates that our cluster can successfully run and manage containerized workloads. Creating a deployment and service allows us to expose our application to the outside world, making it accessible to users. Checking the status of the deployment and service confirms that our application is running as expected. You've reached the finish line; congratulations!

Conclusion

Congratulations! You’ve successfully set up a Kubernetes 1.30.2 cluster on Ubuntu 22.04 LTS. This guide covered everything from preparing your servers to deploying a sample application. With your own K8s cluster, you can now deploy and manage containerized applications with ease. Remember to regularly update your cluster and monitor its performance to ensure optimal operation. Well done, and happy deploying!