Kubernetes On Ubuntu: Step-by-Step Installation Guide

by Team 54 views
Kubernetes on Ubuntu: Step-by-Step Installation Guide

Are you looking to dive into the world of container orchestration and deploy Kubernetes on Ubuntu? You've come to the right place! This comprehensive guide provides a step-by-step walkthrough to help you set up a Kubernetes cluster on Ubuntu. Whether you're a seasoned DevOps engineer or a curious developer, this article will equip you with the knowledge and practical steps to get your cluster up and running.

Prerequisites

Before we begin, let's make sure you have everything you need:

  • Ubuntu Servers: You'll need at least two Ubuntu servers (version 18.04 or later). One will act as the master node, and the other(s) will be worker nodes. Ensure each server has a static IP address.
  • SSH Access: Make sure you can SSH into each of your Ubuntu servers.
  • Root or Sudo Privileges: You'll need root or sudo privileges to install and configure the necessary software.
  • Internet Connection: An internet connection is required to download packages.
  • Basic Linux Knowledge: Familiarity with basic Linux commands will be helpful.

Step 1: Update Package Lists and Install Dependencies

First things first, let's update the package lists and install the necessary dependencies on all your Ubuntu servers. Connect to each server via SSH and run the following commands:

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

apt update refreshes the package lists, ensuring you have the latest information about available packages. The apt install command installs several crucial packages:

  • apt-transport-https: Allows apt to access repositories over HTTPS.
  • ca-certificates: Contains trusted root certificates, enabling secure connections.
  • curl: A command-line tool for transferring data with URLs.
  • software-properties-common: Provides scripts for managing software repositories.

This step sets the foundation for a smooth installation process, making sure your system is ready to receive and manage the required software components. Without these packages, you might run into issues with repository access, package verification, and overall system stability during the Kubernetes installation. So, take your time and ensure everything is installed correctly.

Step 2: Install Docker

Kubernetes uses a container runtime to run applications. Docker is a popular choice, so let's install it. On all servers, execute these commands:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io

Let's break down these commands:

  • The first line adds the Docker GPG key to your system, allowing you to verify the authenticity of the Docker packages.
  • The second line adds the Docker repository to your system's list of software sources.
  • Then, we update the package lists again to include the Docker repository.
  • Finally, we install docker-ce (the Docker Community Edition), docker-ce-cli (the Docker command-line interface), and containerd.io (a container runtime).

After the installation, start and enable the Docker service:

sudo systemctl start docker
sudo systemctl enable docker

To verify that Docker is installed correctly, run:

sudo docker run hello-world

This command downloads and runs a simple "hello-world" container image. If everything is set up correctly, you should see a message confirming that Docker is working.

Installing Docker is a critical step because it provides the underlying infrastructure for running your containerized applications within the Kubernetes cluster. Without Docker, Kubernetes wouldn't be able to manage and orchestrate your containers effectively. Ensuring that Docker is properly installed and configured is paramount for a successful Kubernetes deployment. Pay close attention to each command and verify that Docker is running correctly before proceeding to the next step.

Step 3: Add the Kubernetes Repository

Now, let's add the Kubernetes repository to your Ubuntu servers. Run these commands on all servers:

curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
sudo add-apt-repository "deb https://apt.kubernetes.io/ kubernetes-xenial main"
sudo apt update

Similar to the Docker installation, we're adding a GPG key and a repository to your system. This allows you to download and install Kubernetes packages from Google's official repository. Remember to update the package lists after adding the repository.

Adding the Kubernetes repository is crucial because it provides access to the specific Kubernetes packages you need for installation. Without this repository, you wouldn't be able to download and install the core Kubernetes components, such as kubeadm, kubelet, and kubectl. This step ensures that you're getting the official and verified Kubernetes packages, which is essential for maintaining the security and stability of your cluster. Double-check that you've added the correct repository URL and that the package lists have been updated successfully.

Step 4: Install Kubernetes Components

Time to install the core Kubernetes components: kubeadm, kubelet, and kubectl. Run the following commands on all servers:

sudo apt install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

kubeadm is a tool for bootstrapping Kubernetes clusters. kubelet is the agent that runs on each node and communicates with the control plane. kubectl is the command-line tool for interacting with the Kubernetes cluster.

The apt-mark hold command prevents these packages from being accidentally updated, which could lead to compatibility issues. It's a good practice to hold these packages to ensure your Kubernetes cluster remains stable.

Installing these core components is the heart of setting up your Kubernetes cluster. kubeadm will be used to initialize the master node and join the worker nodes. kubelet is the workhorse that manages the containers on each node, ensuring they're running as expected. kubectl is your window into the cluster, allowing you to deploy applications, manage resources, and monitor the overall health of your environment. Make sure these packages are installed correctly and held to prevent unintended updates.

Step 5: Initialize the Kubernetes Master Node

Now, let's initialize the Kubernetes master node. Choose one of your servers to be the master and run the following command:

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

The --pod-network-cidr flag specifies the IP address range for the pod network. This range should not overlap with any existing network ranges in your environment. It's important to save the kubeadm join command that is outputted, you'll need it to join the worker nodes to the cluster.

After the initialization is complete, you'll see a message with instructions on how to configure kubectl to connect to the cluster. Follow these instructions, which typically involve running the following commands:

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

These commands copy the Kubernetes configuration file to your home directory and set the correct ownership, allowing you to use kubectl as a regular user.

Initializing the master node is the first step in creating the Kubernetes control plane. This process sets up the core components that manage the cluster, including the API server, scheduler, and controller manager. The kubeadm init command automates much of this process, making it relatively easy to get a basic cluster up and running. However, it's crucial to pay attention to the output of the command and follow the instructions carefully to configure kubectl properly. Without a properly configured kubectl, you won't be able to interact with your cluster.

Step 6: Deploy a Pod Network

A pod network allows pods to communicate with each other. We'll use Calico, a popular choice, but feel free to explore other options. On the master node, run:

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

This command deploys the Calico pod network to your cluster. It may take a few minutes for the pods to become ready. You can check the status of the pods with the following command:

kubectl get pods -n kube-system

Look for pods with a status of "Running" or "Completed". Once all the Calico pods are running, your pod network is ready.

Deploying a pod network is essential for enabling communication between the different applications running in your Kubernetes cluster. Without a pod network, pods would be isolated from each other, making it impossible to build complex, distributed applications. Calico is a widely used and reliable pod network that provides a range of features, including network policy enforcement and IP address management. By deploying Calico, you're ensuring that your pods can communicate seamlessly and securely.

Step 7: Join the Worker Nodes

Now, let's join the worker nodes to the cluster. On each worker node, run the kubeadm join command that was outputted during the master node initialization. It should look something like this:

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

Replace <master-ip>, <port>, <token>, and <hash> with the actual values from the kubeadm init output.

After running this command on each worker node, the nodes will join the cluster and become available for running workloads. You can verify that the nodes have joined the cluster by running the following command on the master node:

kubectl get nodes

You should see a list of all the nodes in your cluster, including the master node and the worker nodes. The status of the nodes should be "Ready".

Joining the worker nodes to the cluster is the final step in building your Kubernetes infrastructure. This process connects the worker nodes to the control plane, allowing them to receive and execute instructions from the master node. The kubeadm join command automates this process, making it relatively easy to add nodes to the cluster. However, it's crucial to use the correct kubeadm join command, which includes the necessary information for the worker nodes to authenticate with the master node. Verify that all the worker nodes have joined the cluster successfully and that their status is "Ready" before deploying any applications.

Step 8: Deploy a Sample Application

To test your cluster, let's deploy a simple application. Create a file named deployment.yaml with the following content:

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

This file defines a deployment that runs two replicas of the Nginx web server. Deploy the application with the following command:

kubectl apply -f deployment.yaml

To expose the application, create a service:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: LoadBalancer

Save this as service.yaml and apply it:

kubectl apply -f service.yaml

After a few minutes, you can access the Nginx web server by navigating to the external IP address of the service in your web browser. You can find the external IP address with the following command:

kubectl get service nginx-service

Deploying a sample application is a great way to verify that your Kubernetes cluster is working correctly. This process involves creating deployment and service objects, which define how your application is run and exposed. By deploying Nginx, a simple and widely used web server, you can quickly confirm that your cluster is able to schedule pods, manage deployments, and expose services. If you can access the Nginx web server in your web browser, it means your Kubernetes cluster is up and running and ready to host your applications.

Conclusion

Congratulations! You've successfully set up a Kubernetes cluster on Ubuntu. You can now start deploying and managing your containerized applications with ease. Remember to explore the vast ecosystem of Kubernetes tools and resources to further enhance your cluster and streamline your development workflows. Keep practicing and experimenting, and you'll become a Kubernetes pro in no time!