Atlantic.Net Blog

How to Set Up a Three-Node Kubernetes Cluster on Ubuntu 20.04

Hitesh Jethva
by Atlantic.Net (468 posts) under Dedicated Server Hosting, Tutorials
0 Comments

Kubernetes is an open-source system originally designed by Google for deploying, managing, scaling, and automating containerized applications. The open-source platform works with various containers and creates a framework to run these containers in clusters with images built via Docker. Also known as K8s, the system handles application failovers, stores and manages sensitive information, supports load balancing, and more. Nowadays, many businesses are turning to Kubernetes to solve container orchestration needs.

At present, many services are delivered over the network using exposed APIs and distribution systems daily. Thus, the systems must be highly reliable, scalable, and must not face downtime. Kubernetes provides relevant services covering all these features to help deploy cloud-native applications anywhere. Kubernetes has become one of the best and fast-growing solutions for development.

Let‘s discuss some of the essential benefits of using container orchestration platforms like Kubernetes for deployment, management, and scaling.

Benefits of Kubernetes

Highly Portable and Flexible

No matter how complex your needs, whether you require local testing or running a global enterprise, Kubernetes’ flexible features help consistently deliver your applications. Also, Kubernetes can work virtually with any infrastructure, including the public cloud, a private cloud, hybrid, or an on-premises server. You can create portable deployments with Kubernetes and can run them consistently on different environments (development, staging, and production). Other orchestrators lack this feature. Kubernetes is a trusted open-source that helps effortlessly move workloads to your destined location.

Using Kubernetes Can Improve Developer Productivity

Proper implementation of Kubernetes into engineering workflows can be highly advantageous and lead to enhanced productivity. Kubernetes, with its huge ecosystem and ops friendly approach, allows developers to rely on tools and use them to reduce the negative impact and eliminate general complexity, as well as scale further and deploy faster (and at multiple times during a day). As a result, developers gain access to various solutions that cannot build themselves.

Also, developers can now run distributed databases on Kubernetes and scale stateful applications with its advanced versions.

Affordable Solution

When compared with other orchestrators, Kubernetes can at times be a more affordable solution. It automatically helps scale resources up or down based on the requirement of a specific application, traffic, and load. As a result, when there is less demand for an application, the company or organization pays less.

Self-Healing Service

Enterprise-grade clusters are complex and require best-practice configuration to enable self-service Kubernetes features. Self-service Kubernetes clusters can restart if a container fails and can replace containers or reschedule on noticing the dead nodes. Also, they help kill containers not responding to a user-defined health check.

Multi-Cloud capability

Nowadays, many businesses are switching to multi-cloud strategies, and there are various orchestrators available in the market that work with multi-cloud infrastructures. Kubernetes has the capability to host workloads running on both single and multiple clouds and is very flexible. Also, Kubernetes users can easily scale their environment.

Apart from the above-listed benefits, Kubernetes also supports frequent container image build and deployment, high efficiency, and more.

In this post, we will be going to explain how to install and deploy a three-node node Kubernetes Cluster on Ubuntu 20.04.

Prerequisites

  • Three servers running an Ubuntu 20.04 operating system on the Atlantic.Net Cloud Platform
  • Minimum 2 GB RAM and 2 Core CPUs on each node
  • A root password configured on each server

We will use the following setup to demonstrate a three-node Kubernetes cluster:

Kubernetes Node

IP Address

Operating System

Master-Node 69.28.88.236 Ubuntu 20.04
Worker1 104.219.55.103 Ubuntu 20.04
Worker2 104.245.34.163 Ubuntu 20.04

Step 1 – Create Atlantic.Net Cloud Server

First, log in to your Atlantic.Net Cloud Server. Create a new server, choosing Rocky Linux 8 as the operating system with at least 2GB RAM. Connect to your Cloud Server via SSH and log in using the credentials highlighted at the top of the page.

Once you are logged in to your server, run the following command to update your base system with the latest available packages.

apt-get update -y

Step 2 – Disable Swap and Enable IP Forwarding

Memory swapping causes performance and stability issues within Kubernetes, so it is recommended to disable Swap and enable IP forwarding on all nodes.

First, verify whether Swap is enabled or not using the following command:

swapon --show

If Swap is enabled, you will get the following output:

NAME      TYPE   SIZE USED PRIO
/swapfile file 472.5M   0B   -2

Next, run the following command to disable Swap:

swapoff -a

To disable Swap permanently, edit the /etc/fstab file and comment the line containing swapfile:

nano /etc/fstab

Comment or remove the following line:

#/swapfile                                 none            swap    sw              0       0

Next, edit the /etc/sysctl.conf file to enable the IP forwarding:

nano /etc/sysctl.conf

Un-comment the following line:

net.ipv4.ip_forward = 1

Save and close the file, then run the following command to apply the configuration changes:

sysctl -p

Also Read

How to Install Docker on Ubuntu 20.04 LTS

Step 3 – Install Docker CE

Kubernetes relies on a Docker container, so you will need to install the Docker CE on all nodes. The latest version of the Docker CE is not included in the Ubuntu default repository, so you will need to add Docker’s official repository to APT.

First, install the required dependencies to access Docker repositories over HTTPS:

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

Next, run the curl command to download and add Docker’s GPG key:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -

Next, add Docker’s official repository to the APT:

add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu  $(lsb_release -cs)  stable"

Once the repository is added, run the following command to install Docker CE:

apt-get install docker-ce -y

After the installation, verify the Docker installation using the following command:

docker --version

Sample output:

Docker version 20.10.10, build b485636

Step 4 – Add Kubernetes Repository

By default, the Kubernetes package is not included in the Ubuntu 20.04 default repository, so you will need to add the Kubernetes repository to all nodes.

First, add the Kubernetes GPG key:

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

Next, add the Kubernetes repository to APT:

apt-add-repository "deb http://apt.kubernetes.io/ kubernetes-xenial main"

Once the repository is added, update the APT cache using the command below:

apt-get update -y

Step 5 – Install Kubernetes Components (Kubectl, kubelet and kubeadm)

Kubernetes depends on three major components (Kubectl, kubelet and kubeadm) that make up a Kubernetes run time environment. All three components must be installed on each node.

Let’s run the following command on all nodes to install all Kubernetes components:

apt-get install kubelet kubeadm kubectl -y

Next, you will need to update the cgroupdriver on all nodes. You can do it by creating the following file:

nano /etc/docker/daemon.json

Add the following lines:

{ "exec-opts": ["native.cgroupdriver=systemd"],
"log-driver": "json-file",
"log-opts":
{ "max-size": "100m" },
"storage-driver": "overlay2"
}

Save and close the file, then reload the systemd daemon and restart the Docker service with the following command:

systemctl daemon-reload
systemctl restart docker
systemctl enable docker

At this point, all Kubernetes components are installed. Now, you can proceed to the next step.

Step 6 – Initialize Kubernetes Master Node

The Kubernetes Master node is responsible for managing the state of the Kubernetes cluster. In this section, we will show you how to initialize the Kubernetes Master node.

Run the kubeadm command-line tool to initialize the Kubernetes cluster.

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

Once the Kubernetes cluster has been initialized successfully, you will get the following output:

Your Kubernetes control-plane has initialized successfully!

To start using your cluster, you need to run the following as a regular user:

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

Alternatively, if you are the root user, you can run:

export KUBECONFIG=/etc/kubernetes/admin.conf

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
https://kubernetes.io/docs/concepts/cluster-administration/addons/

Then you can join any number of worker nodes by running the following on each as root:

kubeadm join 69.28.84.197:6443 --token tx7by6.nae8saexoj2y3gqb \
--discovery-token-ca-cert-hash sha256:a506a51aa88791b456275b289bedc5d3316534ff67475fdbc7c2c64ace82652f 

From the above output, copy or note down the kubeadm join full command. You will need to run this command on all worker nodes to join the Kubernetes cluster.

If you are logged in as a regular user then run the following command to start using your cluster:

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

If you are the root user, you can run the following command:

export KUBECONFIG=/etc/kubernetes/admin.conf

At this point, the Kubernetes cluster is initialized. You can now proceed to add a pod network.

Also Read

How to Use chmod (Change Mode) Command in Linux

Step 7 – Deploy a Pod Network

The pod network is used for communication between all nodes within the Kubernetes cluster and is necessary for the Kubernetes cluster to function properly. In this section, we will add a Flannel pod network on the Kubernetes cluster. Flannel is a virtual network that attaches IP addresses to containers.

Run the following command on the Master node to deploy a Flannel pod network.

kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml
kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/k8s-manifests/kube-flannel-rbac.yml

Next, wait for some time for the pods to be in running state. Then, run the following command to see the status of all pods:

kubectl get pods --all-namespaces

If everything is fine, you will get the following output:

NAMESPACE     NAME                                       READY   STATUS              RESTARTS        AGE
kube-system   calico-kube-controllers-5d995d45d6-tfdk9   1/1     Running            0                66m
kube-system   calico-node-5v5ll                          1/1     Running            0                66m
kube-system   calico-node-rws9b                          1/1     Running            0                66m
kube-system   calico-node-tkc8p                          1/1     Running            0                66m
kube-system   coredns-78fcd69978-7ggpg                   1/1     Running            0                127m
kube-system   coredns-78fcd69978-wm7wq                   1/1     Running            0                127m
kube-system   etcd-master                                1/1     Running            0                127m
kube-system   kube-apiserver-master                      1/1     Running            0                127m
kube-system   kube-controller-manager-master             1/1     Running            0                127m

Step 8 – Join Worker Nodes to the Kubernetes Cluster

After the successful pod network initialization, the Kubernetes cluster is ready to join the worker nodes. In this section, we will show you how to add both worker nodes to the Kubernetes cluster.

You can use the kubeadm join command on each worker node to join them to the Kubernetes cluster.

kubeadm join 69.28.88.236:6443 --token alfisa.guuc5t2f66cpqz8e --discovery-token-ca-cert-hash sha256:1db0bb5317ae1007c1f7774d5281d22b2189b239ffabecaedcd605613a9b10cd

Once the worker node is joined to the cluster, you will get the following output:

This node has joined the cluster:
* Certificate signing request was sent to apiserver and a response was received.
* The Kubelet was informed of the new secure connection details.

Run kubectl get nodes on the control-plane to see this node join the cluster.

If you forget the Kubernetes Cluster joining command, you can retrieve it any time using the following command on the master node:

kubeadm token create --print-join-command

You will get the Kubernetes Cluster joining command in the following output:

kubeadm join 69.28.88.236:6443 --token alfisa.guuc5t2f66cpqz8e --discovery-token-ca-cert-hash sha256:1db0bb5317ae1007c1f7774d5281d22b2189b239ffabecaedcd605613a9b10cd 

Next, go to the master node and run the following command to verify that both worker nodes have joined the cluster:

kubectl get nodes

If everything is set up correctly, you will get the following output:

NAME      STATUS   ROLES                  AGE    VERSION
master    Ready    control-plane,master   18m    v1.22.3
worker1   Ready                     101s   v1.22.3
worker2   Ready                     2m1s   v1.22.3

You can also get the cluster information using the following command:

kubectl cluster-info

You will get the following output:

Kubernetes control plane is running at https://69.28.88.236:6443
CoreDNS is running at https://69.28.88.236:6443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.

At this point, the Kubernetes cluster is deployed and running fine. You can now proceed to the next step.

Step 10 – Verify the Kubernetes Cluster

After setting up the Kubernetes cluster, you can deploy any containerized application to your cluster. In this section, we will deploy an Nginx service on the cluster and see how it works.

To test the Kubernetes cluster, we will use the Nginx image and create a deployment called nginx-web:

kubectl create deployment nginx-web --image=nginx

Wait for some time, then run the following command to verify the status of deployment:

kubectl get deployments.apps

If the deployment is in a ready state, you will get the following output:

NAME        READY   UP-TO-DATE   AVAILABLE   AGE

nginx-web   1/1     1            1           6s

Next, scale the Nginx deployment with 4 replicas using the following command:

kubectl scale --replicas=4 deployment nginx-web

Wait for some time, then run the following command to verify the status of Nginx replicas:

kubectl get deployments.apps nginx-web

You will get the following output:

NAME        READY   UP-TO-DATE   AVAILABLE   AGE
nginx-web   4/4     4            4           40m

To see the detailed information of your deployment, run:

kubectl describe deployments.apps nginx-web

Sample output:

Name:                   nginx-web
Namespace:              default
CreationTimestamp:      Thu, 06 Jan 2022 05:49:41 +0000
Labels:                 app=nginx-web
Annotations:            deployment.kubernetes.io/revision: 1
Selector:               app=nginx-web
Replicas:               4 desired | 4 updated | 4 total | 4 available | 0 unavailable
StrategyType:           RollingUpdate
MinReadySeconds:        0
RollingUpdateStrategy:  25% max unavailable, 25% max surge
Pod Template:
  Labels:  app=nginx-web
  Containers:
   nginx:
    Image:        nginx
    Port:         
    Host Port:    
    Environment:  
    Mounts:       
  Volumes:        
Conditions:
  Type           Status  Reason
  ----           ------  ------
  Progressing    True    NewReplicaSetAvailable
  Available      True    MinimumReplicasAvailable
OldReplicaSets:  
NewReplicaSet:   nginx-web-5855c9859f (4/4 replicas created)
Events:
  Type    Reason             Age   From                   Message
  ----    ------             ----  ----                   -------
  Normal  ScalingReplicaSet  52s   deployment-controller  Scaled up replica set nginx-web-5855c9859f to 1
  Normal  ScalingReplicaSet  30s   deployment-controller  Scaled up replica set nginx-web-5855c9859f to 4

As you can see, the Nginx deployment has been scaled up successfully.

Now, let’s create another pod named http-web and expose it via http-service with port 80 and NodePort as a type.

First, create a pod using the command below:

kubectl run http-web --image=httpd --port=80

Next, run the following command to expose the above pod on port 80:

kubectl expose pod http-web --name=http-service --port=80 --type=NodePort

Wait for some time to bring up the pod then run the following command to check the status of the http-service:

kubectl get service http-service

You will get the following output:

NAME           TYPE       CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE
http-service   NodePort   10.109.210.63           80:31415/TCP   8s

To get the detailed information of the service, run:

kubectl describe service http-service

You will get the following output:

Name:                     http-service
Namespace:                default
Labels:                   run=http-web
Annotations:              
Selector:                 run=http-web
Type:                     NodePort
IP Family Policy:         SingleStack
IP Families:              IPv4
IP:                       10.109.210.63
IPs:                      10.109.210.63
Port:                       80/TCP
TargetPort:               80/TCP
NodePort:                   31415/TCP
Endpoints:                10.244.1.4:80
Session Affinity:         None
External Traffic Policy:  Cluster
Events:                   

Next, run the following command to retrieve the IP address and the node on which the http-web pod is deployed:
kubectl get pods http-web -o wide

You will get all information in the following output:

NAME       READY   STATUS    RESTARTS   AGE   IP           NODE      NOMINATED NODE   READINESS GATES
http-web   1/1     Running   0          62s   10.244.1.4   worker1              

As you can see, the http-web is deployed on the worker2 node and their IP address is 10.244.1.4.

You can now use the curl command to verify the webserver using port 80:

curl http://10.244.1.4:80

If everything is set up correctly, you will get the following output:

<html><body><h1>It works!</h1></body></html>

Conclusion

In this guide, we explained how to install and deploy a three-node Kubernetes cluster on Ubuntu 20.04 server. You can now add more worker nodes to scale the cluster if necessary. For more information, read the Kubernetes documentation. Try to deploy Kubernetes cluster today on your dedicated servers from Atlantic.Net!

Get A Free To Use Cloud VPS

Free Tier Includes:
G3.2GB Cloud VPS Free to Use for One Year
50 GB of Block Storage Free to Use for One Year
50 GB of Snapshots Free to Use for One Year


Looking for a Hosting Solution?

We Provide Cloud, Dedicated, & Colocation.

  • Seven Global Data Center Locations.
  • Flexible Private, Public, & Hybrid Hosting.
  • 24x7x365 Security, Support, & Monitoring.
Contact Us Now! Med Tech Award FTC
SOC Audit HIPAA Audit HITECH Audit

Recent Posts

How to Make the Best Use of the Cloud in the Internet of Things (IoT)
How to Make the Best Use of Artificial Intelligence in Cloud Computing
How to Make the Most Innovative Use of Data in the Cloud
Top 8 Best USA-Based Software as a Service Solutions for SMBs in 2022
How Is the Cloud Enabling Scientific Discoveries and Research?

Get started with 12 months of free cloud VPS hosting

Free Tier includes:
G3.2GB Cloud VPS Server Free to Use for One Year
50 GB of Block Storage Free to Use for One Year
50 GB of Snapshots Free to Use for One Year


New York, NY

100 Delawanna Ave, Suite 1

Clifton, NJ 07014

United States

San Francisco, CA

2820 Northwestern Pkwy,

Santa Clara, CA 95051

United States

Dallas, TX

2008 Lookout Dr,

Garland, Texas 75044

United States

Ashburn, VA

1807 Michael Faraday Ct,

Reston, VA 20190

United States

Orlando, FL

440 W Kennedy Blvd, Suite 3

Orlando, FL 32810

United States

Toronto, Canada

20 Pullman Ct, Scarborough,

Ontario M1X 1E4

Canada

London, UK

14 Liverpool Road, Slough,

Berkshire SL1 4QZ

United Kingdom

Resources