Are you looking for an easy guide on how to install Kubernetes (k8s) using kubespray?

The step-by-step guide on this page will show you how to install Kubernetes Cluster using kubespray on linux systems.

Kubespray is a free and open-source tool that provide ansible playbooks to deploy and manage Kubernetes clusters. It is designed to simplify the installation process of Kubernetes clusters across multiple nodes, allowing users to deploy and manage a production-ready Kubernetes cluster quickly and easily.

It supports a range of operating systems, including Ubuntu, CentOS, Rocky Linux and Red Hat Enterprise Linux, and it can deploy Kubernetes on a variety of platforms, including bare metal, public cloud, and private cloud.

In this guide, we are using the following lab,

• Ansible Node (Kubespray Node): Minimal installed Ubuntu 22.04 LTS (192.168.1.240)
• 3 Controller Nodes: Minimal Installed Rocky Linux 9 (192.168.1.241/242/243)
• 2 Worker Nodes: Minimal Installed Rocky Linux 9 (192.168.1.244/245)

Minimum system requirements for kubespray

• Master Nodes: 1500 MB RAM, 2 CPU and 20 GB free disk space
• Worker Nodes: 1024 MB, 2 CPU, 20 GB free disk space
• Ansible Node: 1024 MB, 1CPU and 20 GB disk space
• Internet connectivity on each node
• Regular with sudo admin rights

Without any further delay, let’s deep dive into the installation steps,

Step 1) Configure Kubespray Node

Login to your Ubuntu 22.04 system and install ansible. Run the following set of commands,

$ sudo apt update
$ sudo apt install git python3 python3-pip -y
$ git clone https://github.com/kubernetes-incubator/kubespray.git
$ cd kubespray
$ pip install -r requirements.txt

Verify the ansible version, run

$ ansible --version

Create the hosts inventory, run below commands and don’t forget to replace IP address that suits to your deployment.

$ cp -rfp inventory/sample inventory/mycluster
$ declare -a IPS=(192.168.1.241 192.168.1.241 192.168.1.242 192.168.1.243 192.168.1.244 192.168.1.245)
$ CONFIG_FILE=inventory/mycluster/hosts.yaml python3 contrib/inventory_builder/inventory.py ${IPS[@]}

Modify the inventory file, set 3 control nodes and 2 worker nodes

$ vi inventory/mycluster/hosts.yaml

Save and close the file

Review and modify the following parameters in file “inventory/mycluster/group_vars/k8s_cluster/k8s-cluster.yml”.

kube_version: v1.26.2
kube_network_plugin: calico
kube_pods_subnet: 10.233.64.0/18
kube_service_addresses: 10.233.0.0/18
cluster_name: linuxtechi.local

To enable addons like kuberenetes dashboard and ingress controller, set the parameters as enabled in the file “inventory/mycluster/group_vars/k8s_cluster/addons.yml”

$ vi inventory/mycluster/group_vars/k8s_cluster/addons.yml
-----------
dashboard_enabled: true
ingress_nginx_enabled: true
ingress_nginx_host_network: true
-----------

save and exit the file.

Step 2) Copy SSH-keys from ansible node to all other nodes

First generate the ssh-keys for your local user on your ansible node,

$ ssh-keygen

Copy the ssh-keys using ssh-copy-id command,

$ ssh-copy-id sysops@192.168.1.241
$ ssh-copy-id sysops@192.168.1.242
$ ssh-copy-id sysops@192.168.1.243
$ ssh-copy-id sysops@192.168.1.244
$ ssh-copy-id sysops@192.168.1.245

Also Read: How to Setup Passwordless SSH Login in Linux with Keys

Also run the following command on each node.

$ echo "sysops ALL=(ALL) NOPASSWD:ALL" | sudo tee /etc/sudoers.d/sysops

Step 3) Disable Firewall and Enable IPV4 forwarding

To disable firewall on all the nodes, run following ansible command from ansible node,

$ cd kubespray
$ ansible all -i inventory/mycluster/hosts.yaml -m shell -a "sudo systemctl stop firewalld && sudo systemctl disable firewalld"

Run following ansible commands to enable IPv4 forwarding and disable swap on all the nodes,

$ ansible all -i inventory/mycluster/hosts.yaml -m shell -a "echo 'net.ipv4.ip_forward=1' | sudo tee -a /etc/sysctl.conf"
$ ansible all -i inventory/mycluster/hosts.yaml -m shell -a "sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab && sudo swapoff -a"

Step 4) Start Kubernetes deployment

Now, we are all set to start Kubernetes cluster deployment, run following ansible playbook from ansible node,

$ cd kubespray
$ ansible-playbook -i inventory/mycluster/hosts.yaml --become --become-user=root cluster.yml

Now monitor the deployment, it may take 20 to 30 minutes depending on internet speed and hardware resources.

Once the deployment is completed, we will get following output on our screen,

Great, above output confirms that deployment is completed successfully.

Step 5) Access Kubernetes cluster

Login to first master node, switch to root user, run kubectl commands from there,

$ sudo su -
# kubectl get nodes
# kubectl get pods -A

Output,

Perfect, output above confirms that all the nodes in the cluster are in ready state and Pods of all the namespace are up and running. This shows that our Kubernetes cluster is deployed successfully.

Let’s try to deploy nginx based deployment and expose it as nodeport, run the following kubectl commands

$ kubectl create deployment demo-nginx-kubespray --image=nginx --replicas=2
$ kubectl expose deployment demo-nginx-kubespray --type NodePort --port=80
$ kubectl get  deployments.apps
$ kubectl get pods
$ kubectl get svc demo-nginx-kubespray

Output of above commands,

Now try accessing this nginx application using worker’s IP address and node port (30050)

Either use below curl command or web browser to access this application.

$ curl 192.168.1.245:30050

Or

Perfect, this confirms that application is accessible outside of our cluster.

Step 6) Kubernetes Dashboard (GUI)

To access the Kubernetes dashboard, let’s first service account and assign admin privileges so that it can access dashboard using token.

Create service account with name ‘admin-user’ in kube-system namespace.

$ vi dashboard-adminuser.yml
apiVersion: v1
kind: ServiceAccount
metadata:
  name: admin-user
  namespace: kube-system

save and close the file.

$ kubectl apply -f dashboard-adminuser.yml
serviceaccount/admin-user created
$

Create a cluster role binding,

$ vi admin-role-binding.yml
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: admin-user
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- kind: ServiceAccount
  name: admin-user
  namespace: kube-system

save and exit the file.

$ kubectl apply -f admin-role-binding.yml
clusterrolebinding.rbac.authorization.k8s.io/admin-user created
$

Now, create the token for admin-user,

$ kubectl -n kube-system  create token admin-user

Copy this token and place it somewhere safe because we will use token to login Kubernetes dashboard.

Connect to first master node from your system using following ssh command

$ ssh -L8001:localhost:8001 sysops@192.168.1.241

Note : Replace IP address that suits to your env.

After login, switch to root user and run ‘kubectl proxy‘ command,

$ sudo su -
# kubectl proxy
Starting to serve on 127.0.0.1:8001

Open the web browser of your system, set the proxy settings as shown below,

Once you are done with proxy settings, paste the following url in browser,

http://localhost:8001/api/v1/namespaces/kube-system/services/https:kubernetes-dashboard:/proxy/#/login

Select the login mechanism as Token and paste the token that you have generated above for admin-user and then click on ‘Sign in’

That’s all from this guide, I hope you found it informative. Kindly do post your queries and feedback in below comments section.

In this post, we will cover how to install minikube on RHEL 8, Rocky Linux 8 or AlmaLinux 8 step by step.

Minikube is a cross-platform and open-source tool that makes it possible for you to deploy a single-node Kubernetes cluster on your local machine.

Kubernetes, also known as k8s or simply as Kube, is an open-source container orchestration platform used for the automation scaling and deployment of containers.Minikube cluster helps developers and admins to build their test environment in minikube cluster.

Prerequisites of MiniKube

• Minimal Installed RHEL 8 or Rocky Linux 8 or AlmaLinux 8
• Locally Configured Repo or Subscription for RHEL 8.
• Minimum of 2 GB RAM and 2 vCPUs
• 20 GB hard disk space
• Sudo User with admin
• A stable internet connection
• Docker or virtual machine manager like VirtualBox, KVM,and VMware etc.

In this post, we will be using docker as driver for minikube. With all the prerequisites met, it’s time now to roll up our sleeves and get our hands dirty.

Step 1) Enable Official Docker Repository

To enable docker official repository run,

$ sudo dnf config-manager --add-repo=https://download.docker.com/linux/centos/docker-ce.repo
$ sudo dnf repolist

Step 2) Install Docker CE (Community Edition)

Run the following dnf command to install docker and its dependencies,

$ sudo dnf install docker-ce docker-ce-cli containerd.io -y

output,

Once docker is installed the start and enable it’s service, run following systemctl commands,

$ sudo systemctl start docker
$ sudo systemctl start docker

Allow your local user to run docker commands without sudo, run

$ sudo usermod -aG docker $USER
$ newgrp docker

Step 3) Install Kubectl Binary

Kubectl is a command-line tool which interacts with Kubernetes cluster via APIs. Using kubectl we deploy our applications as deployment. By default, kubectl is not included in RHEL 8 , Rocky Linux 8 or AlmaLinux 8 package repositories. Therefore, we are going to manually install it using beneath commands,

$ curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
$ sudo cp kubectl /usr/local/bin/ && sudo chmod +x /usr/local/bin/kubectl
$ kubectl version --client

Output of above commands would be something like below,

Step 4) Download MiniKube Binary and Start Cluster

After installing the kubectl, let’s download and install minikube binary using the following commands,

$ curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
$ sudo install minikube-linux-amd64 /usr/local/bin/minikube

Now start minikube cluster using the beneath command,

$ minikube start --driver docker

Output above confirms that minikube command has started the single node Kubernetes cluster using docker as driver.

Run below minikube command to verify the status of your local Kubernetes cluster,

[sysops@localhost ~]$ minikube status
minikube
type: Control Plane
host: Running
kubelet: Running
apiserver: Running
kubeconfig: Configured
[sysops@localhost ~]$
[sysops@localhost ~]$ minikube ip
192.168.49.2
[sysops@localhost ~]$

To stop stop the minikube cluster, execute,

$ minikube stop

Execute the “kubectl” commands to view cluster and node information

$ kubectl cluster-info
$ kubectl get nodes

Step 5) Test and Verify Kubernetes Cluster

To test Kubernetes cluster, let try to create k8s deployment using echo server image, it is equivalent to http web server and expose it as a service on port 8080,

[sysops@localhost ~]$ kubectl create deployment test-minikube --image=k8s.gcr.io/echoserver:1.10
deployment.apps/test-minikube created
[sysops@localhost ~]$

To access test-minikube deployment, expose it as service, run the following command,

[sysops@localhost ~]$ kubectl expose deployment test-minikube --type=NodePort --port=8080
service/test-minikube exposed
[sysops@localhost ~]$

Run below kubectl command to get deployment,pods and service  information for above created deployment,

$ kubectl get deployment,pods,svc

To access service, get its url by running the beneath command.

[sysops@localhost ~]$ minikube service test-minikube --url
http://192.168.49.2:32291
[sysops@localhost ~]$
[sysops@localhost ~]$ curl http://192.168.49.2:32291/

Great, it means our Kubernetes cluster is working fine as we are able to access our sample application.

Step 6) Enable MiniKube Addons

Minikube offers addons which can add additional functionality to our clusters. To list all available addons run,

$ minikube addons list

Kubernetes ships with a dashboard that allows you to manage your cluster. In Minikube, dashboard has been added as an addons. So to enable it, run

$ minikube addons enable dashboard

Also to enable nginx ingress controller, run

$ minikube addons enable ingress

To access the dashboard, run

$ minikube dashbaord --url

This will start the dashboard in your systems’s web vrowser.

And that’s just about it. We have managed to successfully install Kubernetes with Minikube on RHEL 8, Rocky Linux 8 or AlmaLinux 8. You are welcome to share your feedback and comments in below comments section.

Also Read : How to Configure NFS based Persistent Volume in Kubernetes

Pgadmin4 is a free and opensource web-based administration and development platform for PostgreSQL. It interacts with PostgreSQL database server on both local and remote servers and displays server statistics using intuitive and interactive dashboards.

Pgadmin4 is a rewrite of Pgadmin 3 and provides the following notable features:

• A responsive web UI with intutive and real-time monitoring dashboards
• An improved web interface with cool and new panels and icons.
• An SQL query editor with syntax highlighting.
• Extensive documentation.
• Useful tips to help you get started.

In this guide, we will demonstrate how to install Pgadmin4 on RHEL 9.

Prerequisites

Before you begin, ensure that you have a RHEL 9 server instance with PostgreSQL database server installed. Check out guide on how to install PostgreSQL 15 on RHEL 9.

With PostgreSQL server installed, carry on with the following steps.

Step 1) Add Pgadmin4 Repository on RHEL 9

The first step is to add the Pgadmin4 repository on RHEL 9. But first, install the EPEL repository which provides essential software packages.

$ sudo dnf install https://dl.fedoraproject.org/pub/epel/epel-release-latest-9.noarch.rpm

Next, install Pgadmin4’s repository as follows.

$ sudo dnf install -y https://ftp.postgresql.org/pub/pgadmin/pgadmin4/yum/pgadmin4-redhat-repo-2-1.noarch.rpm

Once done, build a cache for Pgadmin4 and EPEL repositories as follows.

$ sudo dnf makecache

Step 2) Install PgAdmin4 on RHEL 9

Once the Pgadmin4 and EPEL repositories are in place, proceed and install Pgadmin4 using the DNF package manager as shown.

$ sudo dnf install pgadmin4 -y

This installs a myriad of packages including Pgadmin4, Apache HTTP web servers, and Python packages to mention a few.

To confirm that Pgadmin4 has been installed, run the following command:

$ rpm -qi pgadmin4

This prints out quite some information including the name, version, release, and architecture of the installed package.

Step 3) Start / Enable PgAdmin4 on RHEL 9

At this point, Pgadmin4 is successfully installed. However, you need to go a step further and get it running. To start the Pgadmin4 service, run the command:

$ sudo systemctl start httpd

Be sure also to enable the service to start every time the system boots.

$ sudo systemctl enable httpd

To confirm that Pgadmin4 is running run the command:

$ sudo systemctl status httpd

Step 4) Initializing PgAdmin4 on RHEL 9

The Pgadmin4 package provides a configurable script for setting up the pgAdmin web service. This allows you to create a user account which is used to authenticate and configure SELinux policies and Apache web server.

Therefore, run the script as follows.

$ sudo /usr/pgadmin4/bin/setup-web.sh

Provide the email and password that you will use as login credentials on the login page.

NOTE: Sometimes, you may encounter a ‘semanage: command not found‘ error as shown in the output below. This indicates that the semanage package is missing.

Semanage, short for SELinux (Security-Enhanced Linux) policy management tool, is a utility used to configure some aspects of SELinux policy without requiring modification to or recompilation from policy sources.

To fix this error, you need to check for the package that provides semanage. You can do this by running the command:

$ sudo dnf provides /usr/sbin/semanage

From the output, you can see that semanage is provided by the  policycoreutils-python-utils-3.3-6.el9_0.noarch  package.

To install this package, run the following command.

$ sudo dnf install policycoreutils-python-utils -y

Once again, run the Pgadmn4 installation script as shown.  Provide the email address and password and type ‘y’ when prompted.

$ sudo /usr/pgadmin4/bin/setup-web.sh

Step 5) Access the Pgadmin4 Web Interface

At this point, Pgadmin4 is successfully installed. To access it from a web browser, head over to the following address:

http://server-ip/pgadmin4

You will get the following login web interface. Be sure to provide the Email and password you provided when running the installation script and click ‘Login’.

Once logged in, the Pgadmin4 dashboard will come to view as shown.

To add a server that can be administered by Pgadmin4, click ‘Add New Server’

On the ‘General’ tab fill out the name of the server and add comments for better description.

Next, click ‘Connection’ and fill out the Hostname/Address , Port , maintenance database , username and password. Then finally click ‘Save’.

Thereafter, you will see PosrgreSQL server statistics displayed on interactive and intuitive dashboards. On the left sidebar, you can browse various PostgreSQL parameters.

Conclusion

We hope you found this guide informative, kindly do post your queries and feedback in below comments section.

In this guide, we are going to cover how you can install Golang Go on Ubuntu Linux step-by-step. For demonstration purposes, we will use Ubuntu 22.04 LTS as our Linux environment.

Go is also referred to as Golang, it is a free and open-source programming language designed at Google by Robert Griesemer, Rob Pike, and Ken Thompson. It is an apple to many a developer’s eye due to its simplicity, efficiency, and concurrency. Its concurrent nature implies means its ability to run multiple tasks at the same time.

It is mostly used for backend purposes such as server-side programming. It features majorly in the game and cloud-native development,  development of command-line tools, data science, and many more use cases.

There are three main ways of installing Go in Linux:

1. Installing from the Official Binary package
2. Installing using APT package manager ( Debian & Ubuntu distros)
3. Installing from Snap packages

Let us go through each of these installation methods.

Install Go from the Official Binary Package

This is the most preferred installation method as it provides the latest version of Golang Go and cuts across all Linux distributions. To achieve this, follow the steps outlined.

Step 1:  Download the Go

The first step in installing Go is to update the system. So log in to your server and update the local package index as shown.

$ sudo apt update

Step 2:  Download the Go Binary Package

The next step is to download the installation file which is a tarball file. To download it, head over to the official Go download page and download the 64-bit tarball installation file ( amd64.tar.gz )

On the command line, you can download the latest tarball file using the wget command. At the time of writing this guide, the latest version of Go is Go 1.20.1. This is likely to change by the time you are reading this guide, so ensure to replace the version number accordingly.

$ wget https://go.dev/dl/go1.20.1.linux-amd64.tar.gz

Step 3:  Unzip the tarball file & move it to /usr/local directory

Once the download is complete, unzip the tarball to the /usr/local/ directory which is the primary directory for executable files.

$ sudo tar -C /usr/local -xzf go1.20.1.linux-amd64.tar.gz

The -C option uncompresses the contents of the tarball file to the /usr/local directory inside the go folder. To confirm this, list the contents of the /usr/local/  directory using the ls command.

$ ls /usr/local/go

Step 4: Add the Golang binary to the $PATH environment variable

The next step is to add Go to the $PATH environment variable.

Open up your .bashrc or .bash_profile file.

$ nano ~/.bash_profile

Paste the following line.

export PATH=$PATH:/usr/local/go/bin

Save the changes and exit the file.

Next, reload the  .bashrc or .bash_profile file using the source command as shown.

$ source ~/.bash_profile

Now Go is successfully installed.

Step 5: Verify Go Version

To check if Go is installed and its version, run the command:

$ go version

The following output shows that go has successfully been installed.

Install Go from the APT Package Manager

If you are running Debian / Ubuntu or any of their derivatives and don’t mind not installing the latest version of Go, then using the APT package manager will do just fine.

To get started, update the package lists as shown.

$ sudo apt update

If you are curious enough, you can search for the availability of the golang-go package from Debian / Ubuntu repositories as shown.

$ apt search golang-go

To install Golang Go using apt command, run

$ sudo apt install golang-go

Once the installation is complete, verify that Go is installed as shown.

$ go version

From the output, you can see that Go version 1.18.1 has been installed. Notably, this is not the latest version at the time of writing this guide.

Install Go from Snap Package

Installing Go from snap is as easy as they come. First, you need to ensure that snap is already enabled on your system. Next, install Go from snap as follows.

$ sudo snap install go --classic

Once the installation is complete, verify that Go has successfully been installed as shown

$ /snap/bin/go version

Testing Go Installation

In this section, we will create a simple Go program and test it to see if our installation works.

We will create a separate directory for our project as follows.

$ mkdir -p ~/go_projects/test

Next, we will navigate into the directory.

$ cd ~/go_projects/test

We will create a simple program called greetings.go that prints out a simple message on the terminal.

$ nano greetings.go

Copy and paste the following lines of code into the file.

package main
import "fmt"
func main() {
    fmt.Printf("Congratulations! Go has successfully been installed on your system\n")
}

Save the changes and exit. Then run the program as follows

$ go run greetings.go

You will get the following output. This confirms that the installation of Golang Go is working as expected.

Conclusion

You are now all set! Go has successfully been installed. In this guide, we have demonstrated how to install Go (Golang ) programming language on Linux.

In this post, we will cover how to Install nginx web server on Ubuntu 22.04 LTS step-by-step.

Nginx is a free and open-source web server, it can also be used as reverse proxy, HTTP load balancer, HTTP Cache and mail proxy. Nginx is available for all the Unix like operating systems and released under BSD-like license.

Prerequisites

• Pre-Installed Ubuntu 22.04 LTS
• Sudo User with admin rights
• Internet Connectivity

Nginx Installation on Ubuntu 22.04 LTS

Nginx package and its dependencies are available in the default package repositories. Si, its installation is straight forward , open the terminal and run following apt commands.

$ sudo apt update
$ sudo apt install nginx -y

Start & Enable Nginx service, run

$ sudo systemctl start nginx
$ sudo systemctl enable nginx

Use below commands to verify the nginx service status,

$ sudo systemctl status nginx
$ sudo systemctl is-active nginx

Output of above commands would be something like below,

Allow Nginx Ports ( 80 & 443 ) in firewall

In case OS firewall is enabled and configured on your Ubuntu 22.04 system then execute the below ufw commands to allow 80 and 443 port,

$ sudo ufw allow 80/tcp
Rules updated
Rules updated (v6)
$ sudo ufw allow 443/tcp
Rules updated
Rules updated (v6)
$

Now Verify rules using the below command,

$ sudo ufw status numbered
Status: active
     To                         Action      From
     --                         ------      ----
[ 1] 80/tcp                     ALLOW IN    Anywhere
[ 2] 443/tcp                    ALLOW IN    Anywhere
[ 3] 22/tcp                     ALLOW IN    Anywhere
[ 4] 80/tcp (v6)                ALLOW IN    Anywhere (v6)
[ 5] 443/tcp (v6)               ALLOW IN    Anywhere (v6)
[ 6] 22/tcp (v6)                ALLOW IN    Anywhere (v6)
$

Once you are done with above changes, let’s verify the Nginx Welcome Page!!!

$ curl -v http://<Server-IP-Address>

or

Open your Web browser, type : http://{Your-Server-IP-Address}

Above Screen confirms that basic nginx web server installation is completed. Let’s discuss server block in nginx.

Server Block / Virtual Host in Nginx

In Apache Web Server we have virtual hosts concept where we can define details of multiple web sites, similarly in Nginx we have Server blocks means block for each web site, let’s look into the default server block (/etc/nginx/sites-available/default) and then we will create our own site’s server block,

pkumar@linuxtechi:~$ sudo vi /etc/nginx/sites-available/default

Define Your Custom Server Block

Let’s assume, we want to create a custom server block for web server www.linuxtechi.lan,

Create a document root using below command,

$ sudo mkdir /var/www/linuxtechi

Create a index.html under web server document root,

$ sudo vi /var/www/linuxtechi/index.html
<!DOCTYPE html>
<html>
<head>
<title>Welcome to LinuxTechi</title>
</head>
<body>
<h1>Welcome to LinuxTechi</h1>
<p>LinuxTechi Test Page running on NGINX Web Server - Ubuntu 22.04</p>
</body>
</html>

save and close the file.

Now create your server block by creating a file “linuxtechi.lan” with the following content under the folder /etc/nginx/sites-available

server {
       listen 80;
       root /var/www/linuxtechi;
       index index.html;
       server_name www.linuxtechi.lan;
}

To activate the above created server block, create a symbolic link from “/etc/nginx/sites-available/linuxtechi.lan” to “/etc/nginx/sites-enabled”

$ sudo ln -s /etc/nginx/sites-available/linuxtechi.lan /etc/nginx/sites-enabled

Restart your nginx service using below command,

$ sudo systemctl restart nginx

Note: In case you don’t have DNS server then you should add below entries in hosts file of your client machine,

192.168.1.224 www.linuxtechi.lan

Now access your web server via url : http://{Web-Server-Name}

In my case , url is http://www.linuxtechi.lan

Enable SSL Certificates for Your NGINX Server

As of now our nginx web server is running on non-secure port 80, to make the web server secure then we need to install ssl certificates. You can get the SSL certificates from the trusted sources or you can also use self-signed certificates generated via openssl command.

In this post, I am generating the self-signed certificates for my web server using openssl command,

$ sudo openssl req -x509 -days 703 -sha256 -newkey rsa:2048 -nodes -keyout /etc/ssl/private/linuxtechi.key -out /etc/ssl/certs/linuxtechi-cert.pem

Output,

Above command has generated the private key with “linuxtechi.key” and certificates with name “linuxtechi-cert.pem“, these certificates will be applicable for the next two years.

Now update your server block, add the key and certificate location and change the web server port from 80 to 443,

$ sudo vi /etc/nginx/sites-available/linuxtechi.lan
server {
       listen 443 ssl;
       root /var/www/linuxtechi;
       index index.html;
       server_name www.linuxtechi.lan;
       ssl_certificate /etc/ssl/certs/linuxtechi-cert.pem;
       ssl_certificate_key /etc/ssl/private/linuxtechi.key;
}

Save and exit file and then restart nginx service using following command,

$ sudo systemctl restart nginx

Access your web server on https protocol like,

https://www.linuxtechi.lan

Note: As we have installed our self-signed certificates so we have to first time click on  “Advanceed” and then “Accept the Risk and Continue” while accessing the web server on https.

This confirms that we have successfully enabled self-signed certificates on our Nginx Web server. That’s all from this article, kindly do post your queries and feedback in below comments section.

Attackers are constantly on the prowl, conducting reconnaissance on web servers to retrieve crucial details such as the Nginx version. With this information at hand, they can then leverage known vulnerabilities associated with the version of the Nginx web server and initiate an attack.

Hiding the version of Nginx is, therefore, one of the many ways of securing your Nginx web server and warding off potential attacks.

In this guide, we will explore how to hide the Nginx version in Linux.

Prerequisites

Before you get started, ensure that you have an instance of Nginx web server installed and running on your Linux system.

Viewing Version Number of Nginx Web Server

Whenever you query the HTTP headers of a site hosted on Nginx, the version of Nginx is displayed by default among other details. In fact, if you browse a non-existent page of a website hosted on the Nginx web server, you will get a 404 error page with the version of Nginx displayed.

Similarly, you can view the version using the curl command to display the HTTP headers.

$ curl - I ip-address
OR
$ curl - I hostname

As explained, exposing the version of Nginx is not recommended as it can leave your web server prone to attacks. Let’s now see how to hide this information.

How to hide the version of Nginx using the server_tokens directive

The ‘server_tokens‘ directive is a parameter in Nginx that is responsible for displaying the version of Nginx on error pages and in the HTTP response header field. To hide the version of Nginx, this directive needs to be set to off.

To do this, open the default Nginx configuration file.

$ sudo nano /etc/nginx/nginx.conf

Locate the  ‘server_tokens off‘ directive. By default, this is commented.

Uncomment it and save the changes.

For the changes to take effect, reload or restart the Nginx service.

$ sudo nginx -s reload
OR
$ sudo systemctl restart nginx

Confirm that the Nginx version is hidden

To verify that the version of Nginx is now hidden, now browse any error page on your web server and you will notice that this time around, the version will not be displayed.

Also, you can query the HTTP headers. Likewise, you will discover that the version is not displayed.

This confirms that the version of Nginx has been hidden from anyone that might want to spy or conduct some reconnaissance on your web server.

Conclusion

We hope that you found this guide insightful and that you can now hide your web server’s version. Your feedback on this article is welcome.

Also Read: How to harden and secure Nginx web server

Hello techies, in this post, we will cover how to Install Elementary OS 7 step by step with screenshots on laptop or desktop. It is based on latest and stable Ubuntu 22.04 LTS.

Elementary OS 7 with code name “Horus” released with lot of improvements like :

• Improved AppCenter and install all application that one need.
• Improved sideloading and alt store (Flathub) experience
• Latest GNOME Web 43 support for creating web apps.
• Getting OS and Applicate Updates quickly
• Power Profile Management
• Improvement in App Description

System Requirements for Elementary OS 7

• Dual Core 64-bit processor
• 4 GB RAM or more
• 32 GB hard disk
• Internet Access
• Bootable USB Flash Drive ( 4 GB Storage)

Without any further delay, let’s jump into the installation steps

1) Download Elementary OS 7

Use below official URL to download ISO file,

• Download Elementary OS 7 ISO

Once ISO file is downloaded then burn it into USB flash drive and make it bootable.

On Windows operating use “Rufus” software to make bootable USB drive using ISO file. In Linux, refer the following URL:

• How to Create Bootable USB Drive on Ubuntu / Linux Mint

2) Boot the system with bootable media

Now boot the target system with bootable USB drive. From bios settings change the boot medium from hard disk to USB. When the system boots up with USB drive then we will get the following screen,

3) Select Language for Installation

Choose your preferred language and then click select,

4) Choose Keyboard Layout

In this step, you will be requested to choose keyboard layout and then click on ‘Select’

5) Try or Install elementary OS

We will be presented the beneath screen, where we must our choose installation type. It gives us following options,

• Try Demo Mode – Try Elementary OS 7 without installing
• Erase disk and Install – Installer will erase the whole disk and will create required partitions automatically.
• Custom Install (Advanced) – It will give us the option to create custom partitions.

In this post, I will go with the 2nd option (Erase disk and install).

Click on “Erase Disk and Install”

In the following screen, select the drive on which OS will be installed and then click on “Erase and Install”

If you want to encrypt the device’s drive, then click on “Choose Password” else click on “Don’t Encrypt”.

6) Installation Progress

As we can see below, installation got started and is in progress.

Once the installation is completed, installer will prompt to reboot the system.

Click on “Restart Device” and don’t forget to change boot medium from bios settings so that it boots up with the disk.

7) Create Local User and Set Hostname

When the system boots up after the installation, you will be prompted to enter local user details and hostname of your system.

Specify the details as per your requirement,

Click on “Finish Setup”.

In the following screen, you will be prompted to enter your local user credentials that you have created above,

After entering the credentials, hit enter

8) Elementary OS 7 Welcome Screen

We will get the beneath welcome screen,

Choose “Skip All”

Click “Get Started” and then we will get following desktop screen,

Great, it confirms that you have successfully installed Elementary OS 7 on your system. That’s all from this guide, explore this exciting Linux distribution and have fun 😊.

KubeSphere is an open-source enterprise-grade Kubernetes container platform that provides streamlined DevOps workflows and full-stack automation. It offers an intuitive and user-friendly web interface that helps developers build and monitor feature-rich platforms for enterprise Kubernetes environments.

In this guide, you will learn how to install Kubesphere on Linux step-by-step.

Step 1) Prepare your Linux System

The first step is to decide which system you will use to install Kubesphere. At the moment of writing this article, the following are the only operating systems that are supported.

• Ubuntu 16.04, 18.04, 20.04, 22.04
• Debian 9, 10
• Red Hat Enterprise Linux 7
• SUSE Linux Enterprise Server 15
• OpenSUSE Leap 15.2

Regardless of the system you choose, ensure that it meets the following minimum system requirements:

• CPU: 2 Cores
• Memory: 4 G ( 8G recommended )
• Disk Space: 40 G

NOTE: It is recommended that you have a clean OS (without any other software installed) to prevent any conflicts.

In this guide, we will use Ubuntu 22.04 as our OS environment with 4 CPU cores, 8GB RAM, and 40GB disk space.

Step 2) Installing prerequisite packages

A couple of package requirements are needed before proceeding with the installation. Therefore, install them as shown.

$ sudo apt update
$ sudo apt install curl socat conntrack ebtables ipset -y

Once installed, proceed to the next step.

Step 3) Download KubeKey

Next, download KubeKey from its Github release page or run the following command:

$ curl -sfL https://get-kk.kubesphere.io | VERSION=v3.0.2 sh -

The above command downloads the latest release of KubeKey (v3.0.2). Feel free to change the version number to download a specific version.

Next, make the kk file executable using chmod command.

$ chmod +x kk

Step 4) Get started with the installation of Kubesphere

To install both the Kubernetes cluster and Kubesphere, use the syntax shown below,

$ sudo ./kk create cluster [--with-kubernetes version] [--with-kubesphere version]

We will specify the latest versions of Kubernetes and Kubesphere as shown. Take note that these versions might be different by the time you read this guide. So, be sure to substitute the versions accordingly.

This is an all-in-one installation and, therefore, you do not need to make any configuration to your system.

$ sudo ./kk create cluster --with-kubernetes v1.24.2 --with-kubesphere v3.3.1 --container-manager containerd

NOTE: If you do not add the flag –with-kubesphere in the command in this step, KubeSphere will not be deployed. KubeKey will install Kubernetes only. If you include the same flag without specifying a KubeSphere version, the latest version of KubeSphere will be installed. Also if you want to install kubernetes v1.24.x then it is mandate to pass –contianer-manager flag.

Once executed, the command runs a pre-check on your node to ensure that the prerequisite packages are installed, and you should see the following table.

To proceed with the installation, type ‘yes’ and hit ENTER to continue

The installation takes quite a while, in our case, this took about 20 minutes. At this point, you can take a break as the installation of Kubernetes and Kubesphere progresses.

Once complete, you will get some information about how you can access the web interface for Kubesphere.

On your browser, head over to the URL provided for accessing the web console. This will get you to the login page shown below. Login using the default credentials shown.

• Username: admin
• Password: P@88w0rd

You will then be required to change your password and provide a unique and stronger one.

Finally, you will be ushered to the dashboard shown below.

To get an overview of your cluster resource utilization, click on ‘Platform’ at the top left corner.

On the menu that appears, select the ‘Cluster Management’ option.

This opens the interface shown that displays the cluster resource usage.

To the left is a menu that provides a list of options for accessing and viewing various components of your cluster. For example, to view the nodes in the cluster, head over to Nodes > Cluster nodes.

Obviously, you will only see one node which works as control and worker node on which you have just installed Kubernetes and Kubesphere.

To view system components, click ‘System Components’

Back on the terminal, run the following commands to interact with cluster (or kubectl commands)

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

To get node information, run

$ kubectl describe node

To get information about the pods in all the namespaces on your cluster, run the command:

$ kubectl get pods --all-namespaces

Conclusion:

In this guide, we have demonstrated how to install Kubesphere on Linux, specifically on Ubuntu 22.04. For more information check out the Kubesphere official site.

Hello techies, in this post, we will cover how to install Fedora server 37 step-by-step with screenshots.

Fedora Server is a free, open-source and powerful Linux distribution, which is built for servers. It is suitable for a wide range of workloads, from web servers to databases and file servers, and it provides a lot of features out of the box and with a fast release cycle.

Fedora server is developed and maintained by Fedora Project, which is a community based open-source project sponsored by Red Hat.

Minimum System Requirements for Fedora Server

• 2 GB RAM or more
• 2 GHz dual core processor or mor
• 20 GB disk space
• Installation Media (USB / DVD)

Without further ado, let’s deep dive into Fedora server 37 installation steps.

1) Download Fedora Server 37 ISO File

From the Fedora official page get Fedora server 37 Standard ISO file for x86_64.

• Download Fedora Server ISO

Once the iso file is downloaded then burn it into a USB drive and make it bootable.

In Linux, refer following to create bootable USB drive,

• How to Create Bootable USB Drive on Ubuntu / Linux Mint

Use Rufus in Windows OS to create a bootable USB drive using ISO file

2) Boot the System with Bootable Media

Move to the target system, boot it with bootable media (USB drive).  When the system boots up, we will get following screen,

Choose the first option “Install Fedora 37” and hit enter.

3) Select Your Preferred Language

Choose your preferred language for Fedora Server installation,

Click on Continue

4) Installation Summary

In this step, we will get the following installation summary screen, we must complete the items marked with icon to proceed with the installation.

Complete the following marked items

• Installation Destination
• Root Account
• User Creation

 Installation Destination:

In this section, we decide partitioning scheme for Fedora Server. There are two options here:

• Automatic Partitioning: Here Installer will automatically create partitions on the disk.
• Custom: If you wish to create own custom partitions manually then choose this option.

In this post, we will go with 2nd option and will create following partitions on 80 GB disk.

• /boot – 2GB (Std XFS file system)
• /home – 25 GB (XFS file system)
• /var    – 30 GB (XFS file system)
• /          – 20 GB (XFS file system)
•  Swap –  2GB
• biosboot – 1MB

Click on ‘Installation Destination” then we will get following screen,

Select Custom and then click on Done, this will take us to the following screen.

Choose LVM and click on + (plus) symbol.

Create the first partition as /boot of size 2 GB and format it as standard XFS file system.

Click on “Add mount point”

Next, create /home LVM partition of size 25 GB with XFS file system.

Click on + symbol again, specify the details as shown below:

Click on “Add mount point”, it will automatically mark this partition as LVM of type XFS.

Similarly Create /var and / of size 30GB and 20GB respectively.

Now, create last partition as swap of size 2GB.

Note: If your disk is GPT label then you need to create biosboot partition of size 1 MB

Once you are done with custom manual partitions, click on Done to proceed further.

Choose “Accept Changes”

Now, set Root User password and create local user. Click on Root Account from Installation Summary screen, enable root account and set it’s password.

Click on Done, this will take us back to installation summary. Now, click on “User Creation” and specify the local user details as show below,

Click Done.

We are all set to start the actual installation, click on “Begin Installation” to proceed further.

5) Fedora Server Installation Progress

As we can see in the following screen, installation is started and is in progress.

Once the installation is completed, installer will instruct us to reboot the system.

Click on “Reboot System”. It will restart the system and don’t forget to remove the installation media and set the boot medium as hard disk.

6) Fedora Server Login Screen After Installation

When we reboot the Fedora Server we will get following grub screen, choose the first option and hit enter.

When the system boots up successfully, we will get beneath login cli screen. We can use either root user or local user credentials to login that we have created during the installation.

Perfect, above screen confirms that we have successfully installed Fedora Server 37.

That’s all from this post. Kindly do post your queries and feedback in below comments section.

Linux operating system is a popular choice for servers – and for multiple reasons. First, it’s free (with exception of a few commercial distributions such as RHEL and SUSE Linux Enterprise Server ) and open-source. Its open-source nature implies that developers can view its source code, modify it and redistribute it according to the laid-out license terms. In addition, Linux is generally considered stable, versatile, and more secure than Windows. Furthermore, it can easily be deployed across various platforms such as bare-metal, virtual, and cloud environments.

In this article, we highlight the top 10 Linux distributions for servers.

1) Red Hat Enterprise Linux (RHEL) 

Red Hat Enterprise Linux, abbreviated as RHEL, is a commercial Linux distribution that was developed specifically for enterprise environments. It is a performance-driven, reliable, and secure operating system that provides enhanced usability and seamless deployment which makes it ideal for server environments.

RHEL supports a wide range of workloads in bare-metal, virtual, and cloud environments. In fact, it’s the world’s leading open-source solutions provider offering a myriad of products including Red Hat OpenShift, Ansible automation platform, Open hybrid cloud, JBoss Enterprise Application Platform, and SAP to mention a few.

2) Ubuntu Server

Developed and maintained by Canonical, Ubuntu is one of the most popular and widely used Linux distributions. It is a Debian-based Linux distribution that is absolutely free and open-source and is renowned for Its Desktop edition which is intuitive, user-friendly, and considered ideal for learners and beginners. Ubuntu comes in 3 editions namely; Desktop, Ubuntu Server, and Core.

While the Desktop Edition enjoys massive global usage, the Server edition also offers a solid platform for server environments. First, it can be deployed in any environment, be it on a physical, virtual, or cloud environment with extensive scale-out functionality. This implies you can add resources on the go to meet evolving demands.

And since the server version is completely stripped down without any GUI, it’s relatively lightweight leading to low resource overhead. This means low CPU and memory usage. This consequently leads to improved performance and enterprise-grade stability.

Apart from installing it on physical data centers and virtual servers, Ubuntu server is available in public clouds such as AWS and Azure. According to Canonical, 55% of OpenStack clouds run on Ubuntu.  In addition, you can have your own managed Openstack cloud for a fee.

3) Debian

Debian is one of the earliest Linux distributions that is renowned for its rock-solid stability. It comes in three variants: Stable, Unstable, and Testing.

The Debian stable branch is the latest officially released distribution of Debian and is the most popular version for servers and desktop PCs. All packages shipped with this branch have undergone rigorous testing and debugging, and are hence considered ready for production workloads.

Debian server is tailored to be a fast and reliable operating system with an emphasis on security and stability. It’s for this reason that it makes for a perfect choice for server environments. In addition, It provides extensive hardware support with over 59,000 software packages, by far the greatest number of packages provided by any OS.

Just like Ubuntu Server, Debian is lightweight, versatile, and highly stable for enterprise workloads. In fact, it is considered more stable and easier to manage than Ubuntu.

4) SUSE Linux Enterprise Server

Another formidable and worthy contender in providing an excellent platform for servers is SUSE Linux Enterprise Server ( SLES ). The server operating system is created and maintained by SUSE, a German-based organization.

SLES is a commercial distribution that was built to handle enterprise-grade workloads. It is adaptable to any environment and is optimized for stability, reliability, and security. It is highly scalable and allows IT teams to efficiently deploy their applications and services in response to growing business demands.

The latest SLES release provides interoperability with ease of administration. It also provides increased support and compatibility with Docker containers, Kubernetes, and geo-clusters. The latter provides flexibility with high availability allowing IT teams to configure replication clusters that span multiple data center regions.

SUSE Linux Enterprise Server not only supports in-house workloads but is also offered on popular cloud providers including Microsoft Azure, Google Compute Engine, and Amazon Web Services.

5) OpenSUSE Leap

Developed by the OpenSUSE project, OpenSUSE is a non-commercial RPM-based Linux distribution that is developed and maintained by SUSE. OpenSUSE is free and open-source and provides two editions:

• OpenSUSE Leap
• OpenSUSE Tumbleweed

OpenSUSE TumbleWeed is the rolling release version of OpenSUSE. It contains the latest stable applications including an updated kernel, git, SAMBA, desktop applications, and many more. It, therefore, makes a perfect distribution of choice for developers or power users who need to leverage the latest software stacks in their workloads. However, due to frequent kernel updates, it’s not the ideal choice for servers since frequent updates can cause inconsistencies with other third-party driver modules.

OpenSUSE Leap is the preferred OpenSUSE option for servers. It’s an open-source and community-driven distribution that has a slower release cycle and, hence, a better fit than TumbleWeed. It is community-driven and this means that it undergoes rigorous testing before being released.

Leap is comparatively easy to use and offers high performance and stability ideal for handling enterprise-grade workloads. It is a great alternative to commercial server distributions such as SLES and RHEL and allows companies to deploy their workloads both on bare metal and cloud deployments.

6) Rocky Linux

Rocky Linux is a Linux distribution that was developed as a replacement for CentOS Linux which reached EOL ( End Of Life ) on 31st,  December 2021. It is a free and opensource Linux distribution that is enterprise-ready, providing rock-solid stability, reliability, and regular updates with a 10-year support lifecycle at absolutely no cost

Rocky Linux is an enterprise operating system designed to be 100% bug-for-bug compatible with Red Hat Enterprise Linux and is currently under intensive development by the community.

The distribution has gained massive popularity since the untimely discontinuation of CentOS Linux. It can be installed on both servers, and desktop computers. It’s also available in custom-built images on Public cloud providers such as Amazon AWS, and Google Compute Engine.

Rocky Linux developers have availed a migration script that allows users to migrate from other enterprise editions such as CentOS Linux and Oracle Linux to Rocky Linux.

7) AlmaLinux

Another alternative that was developed to plug in the gap left by CentOS Linux is AlmaLinux. This is yet another enterprise operating system that is completely free and opensource.

AlmaLinux was originally created by CloudLinux but is currently community driven. It offers a production-grade enterprise operating system that is 1:1 binary compatible with Red Hat Enterprise Linux (RHEL). In a nutshell, it’s a clone of RHEL and provides rock-solid stability and benefits that come with RHEL at no cost.

Being an Enterprise-grade server OS, AlmaLinux can comfortably run heavy and critical workloads. In addition, it provides regular releases that come with long-term support.

8) Oracle Linux

Developed by Oracle Corporation, Oracle Linux is a secure and high-performance operating system that is compiled from RHEL source code. It is optimized for hybrid and multi-cloud deployments, and just like Rocky and AlmaLinux, Oracle Linux is 100% binary compatible with Red Hat Linux.

Oracle Linux is a viable option for data centers and certainly a perfect replacement for CentOS which reached EOL. It is rock-solid stable and posts incredible performance ideal for enterprise applications.

Unlike Commercial Linux distributions such as RHEL and SUSE, Oracle Linux is completely free to download, use and redistribute. It is available under the GNU General Public License (GPLv2)

9) Fedora Server

Fedora is a free and open-source Linux distribution that is developed and maintained by Fedora Project which is sponsored by Red Hat.

Fedora serves as the upstream, community distribution of Red Hat Enterprise Linux. All the applications go through rigorous testing before they are pushed to RHEL. As such, it is referred to as a ‘Bleeding Edge’ operating system. This implies is regularly gets the latest software applications and updates.

For a long time, Fedora has been popular for its Workstation Edition which was built for laptop and desktop computers. Over time, it has expanded to include other editions such as Fedora Server, Fedora IoT, and Fedora CoreOS.

Fedora Server is a robust, reliable, and flexible operating system that ships with the best and latest data center technologies. As a leading-edge edition, it offers the very latest technologies in the open-source community. It is easy to install, set up, and administer using various tools such as Cockpit web console.

Fedora is also fast, remarkably stable, and secure. It works just fine for production and enterprise workloads.  New releases of Fedora are pushed out once every 6 months.

10) Fedora CoreOS

Last on our list is Fedora CoreOS. This is a minimal operating system that is optimized specifically for running containerized applications and workloads. According to its home page, it touts itself as  “an automatically-updating, minimal operating system for running containerized workloads securely and at scale.”

By default, it ships with both podman and docker and comes in three release streams namely:  Stable, Testing, and Next. You can get images for bare-metal servers and virtualized environments as well as cloud images that are hosted by major cloud providers such as Amazon Web Service (AWS) and Google Cloud Platform (GCP).

Conclusion

That was a round-up of the best Linux distributions for servers. We hope you found this guide insightful. Any thoughts on our guide? Your feedback is very much welcome.

Developed and maintained by Mojang studios, Minecraft is an immensely popular sandbox game that has amassed a huge player base. As of 2021, Minecraft reported 19 million monthly active users and by August 2022, this figure had shot up to 173 million

In this post, we will demonstrate how to install Minecraft on Ubuntu 22.04 step-by-step. The installation can take two approaches: installing from a Debian package or from snap. Let us go through each of these installation methods.

Method 1: Install Minecraft on Ubuntu 22.04 from a Debian Package

To set sail, go over to your terminal and download the Minecraft Debian package using the wget command as follows. This should take roughly a few seconds with a fast internet connection.

$ wget -o ~/Minecraft.deb https://launcher.mojang.com/download/Minecraft.deb

Once downloaded, install Minecraft by running the following apt command.

$ sudo apt install ./Minecraft.deb

Minecraft is now installed with a few simple steps. Let’s now check out the other installation method.

Method 2: Install Minecraft from snap

The other option is to install Minecraft from a snap package. Snap is a software packaging system that uses snaps to package software. A snap package is an isolated environment that bundles software alongside dependencies, libraries, framework, configuration files and everything required by the software to run.

To install Minecraft from snap, run the command:

$ sudo snap install mc-installer

The installation takes just a few minutes to complete.

Launch Minecraft

To launch Minecraft, click ‘Activities’ at the top left corner of your screen and search for Minecraft. Then click on the icon to launch Minecraft.

Thereafter, a pop-up will appear showing the update of Minecraft launcher. This takes approximately 3-5 minutes.

Once done, the Minecraft login screen will come to view presenting you with two login options.

From here, log in using either your Microsoft or Mojang account and enjoy your gaming adventures.

Conclusion

That was a walkthrough of the installation of Minecraft server on Ubuntu 22.04. As you can see, it’s quite an easy and seamless process whichever method you choose to go with. And that’s it for this post. Kindly do post your feedback and queries in below comments section.

Hello techies, in this post we will show you how to configure DHCP server on Ubuntu 22.04 LTS step-by-step.

DHCP stands for Dynamic Host Configuration Protocol, it works on client-server architecture. DHCP server assign IPv4 and IPv6 automatically to clients (computers) on the network. DHCP Server offers a lease of IP address to client, if the clients request IP address and DHCP acknowledge it then client will get IP address for the lease time. If the lease time expires and clients wants to use the same IP address, then it must request IP address to DHCP server again.

Prerequisites

• Pre-Installed Ubuntu 22.04 LTS
• Sudo User with admin rights
• Internet Connectivity or locally configured Repository
• Two Ethernet Cards (1st for access management & 2nd will used for DHCP Subnet)

Lab Setup:

I am using two VMs for Lab setup. 1st VM is Ubuntu 22.04 which will configured as DHCP server and 2nd VM is RHEL 9, which will work as client and will get IP address from DHCP server automatically.

Ubuntu 22.04 LTS has two Lan cards (NICs)

• enp0s3 (192.168.1.204) – It will used for access management and internet connectivity
• enp0s8 (192.168.56.4)– It will be used for DHCP, we will expose the DHCP subnet on this interface.

RHEL 9 VM has one NIC enp0s3 which will request for DHCP IP address. This NIC should be mapped to DHCP subnet VLAN.

Without any further delay, let’s jump into the installation steps.

1 ) Update Package Index

Login to Ubuntu 22.04 system and run beneath apt command to update package index

$ sudo apt update

2) Install DHCP Server and its dependencies

Run following apt command to install DHCP server and its dependent packages.

$ sudo apt install isc-dhcp-server -y

 3) Configure DHCP Server

Edit /etc/default/isc-dhcp-server file and mention the interface on which DHCP would be running. In my case it is enp0s8

$ sudo vi /etc/default/isc-dhcp-server
----
INTERFACESv4="enp0s8"
----

Save and close the file.

Now, edit main dhcp configuration file “/etc/dhcp/dhcpd.conf” and uncomment & set the following parameters,

Comment out the domain name server parameters as we are not using any DNS server,

#option domain-name "example.org";
#option domain-name-servers ns1.example.org, ns2.example.org;

Uncomment

authoritative;

Add the subnet and IP address range to be used for DHCP Server. Also specify the ip address of enp0s8 interface as routers.

subnet 192.168.56.0 netmask 255.255.255.0 {
  range 192.168.56.20 192.168.56.120;
  option routers 192.168.56.4;
}

Save and exit the file

Start and enable dhcp server service using following commands,

$ sudo systemctl start isc-dhcp-server
$ sudo systemctl enable isc-dhcp-server

Verify dhcp server service status, run

$ sudo systemctl status isc-dhcp-server

Output above confirms that DHCP server service is up and running. Now, it’s time to configure client so that it can get IP address from this DHCP server automatically.

4) Configure DHCP Client

In our case, our DHCP client is a RHEL 9 machine, So login to it and configure interface enp0s3 so that it requests for DHCP IP over network.

$ sudo nmtui

Edit enp0s3 interface and set IPv4 Configuration as “Automatic”

Click OK and then deactivate and activate the connection to make the changes into effect.

Verify the IP address, run below ip command

$ ip add show enp0s3

Head back to DHCP server and see the leased ip address, run following cat command

$ cat /var/lib/dhcp/dhcpd.leases

That’s all from this guide. I hope you have found it informative. Kindly do post your queries and feedback in below comments section.

This post covers how to install PostgreSQL 15 on RHEL 9 system step by step.

PostgreSQL is an open-source, multi-platform, robust and highly extensible database server based on the SQL language. It provides the features like data integrity, build applications and create fault-tolerant environments.

Prerequisites

• ·        Minimal Installed RHEL 9
• ·        At least 2GB RAM and 2 CPU
• ·        Sudo User with admin rights
• ·        Red Hat Subscription or locally configured Repository
• ·        Stable Internet Connectivity (In case of Red Hat subscription)

Without any further delay let’s jump into PostgreSQL 15 installation steps.

1) Enable PostgreSQL 15 Package Repository

In the default package repositories of RHEL 9, postgresql 15 is not available. So let’s first enable its DNF/yum package repository using following dnf command.

$ sudo dnf install https://download.postgresql.org/pub/repos/yum/reporpms/EL-9-x86_64/pgdg-redhat-repo-latest.noarch.rpm -y

2) Install PostgreSQL 15 on RHEL 9

In step 1, we have already configured PostgreSQL 15 package repository, so to install it, run the beneath dnf command.

$ sudo dnf install postgresql15-server -y

Once postgresql and it’s dependencies are installed, verify its version using following command.

$ psql -V
psql (PostgreSQL) 15.1
$

Above command’s output shows PostgreSQL 15.1 is installed on the system. Now, let initialize its database in the next step.

3) Initialize PostgreSQL Database (initdb)

To initialize PostgreSQL 15 initdb database, run

$ sudo /usr/pgsql-15/bin/postgresql-15-setup initdb

Output,

4) Start PostgreSQL 15 Service

Run the following systemctl commands to start and enable postgresql 15 service.

$ sudo systemctl start postgresql-15
$ sudo systemctl enable postgresql-15

To verify its service status, run

$ sudo systemctl status postgresql-15

Above output shows that postgresql service is up and running.

5) Securing PostgreSQL 15 Database

By default, postgresql database is not secure, one can easily switch to postgres user without any password and start using psql as shown below:

Now to secure database, set password to postgres user using passwd command.

$ sudo passwd postgres
$ su – postgres
$ psql -c "ALTER USER postgres WITH PASSWORD ‘xxxxxxxxxxx';"

Output of commands,

Now. Let’s try to switch to postgres user and connect to database. This it should prompt you to enable password first,

$ su - postgres
Password:
$ psql

Perfect, above output confirms that postgres user and database is secure now.

That’s all from this post, please do post your queries and feedback on below comments section.

FreeFileSync is an open-source file synchronization & backup tool that helps in synchronizing files across folders and various devices and keeping your data updated. It’s a multi-platform tool that is available for Windows, Linux, and Mac.

In this tutorial, we will cover how to install FreeFileSync on Ubuntu 22.04 step-by-step.

Prerequisites

• Pre-Installed Ubuntu 22.04 LTS system
• Sudo User with admin rights
• Stable Internet connectivity

1. Update Package Lists

To get started, log into your Ubuntu 22.04 workstation and update the package lists:

$ sudo apt update

Once the update is complete, proceed to the next step to install FreeFileSync.

2. Download the FreeFileSync Setup file

FreeFileSync is not included in the official Ubuntu repositories at the time of writing this guide. The only way of installing it is by downloading the binary file from the official site and then running the installation file.

Therefore, visit the official FreeFileSync download page and download the tarball file for Linux by clicking on it as shown below.

Alternatively, you can copy the link and download it using the wget command as follows. Take note that the version number is likely to be different at the time you are referring to this guide and, therefore, replace the version number to correspond to the latest version.

$ wget https://freefilesync.org/download/FreeFileSync_11.28_Linux.tar.gz

3. Extract the downloaded Setup File

Once the download is complete, navigate to the file location and extract it using below tar command.

$ tar -xvf FreeFileSync_11.28_Linux.tar.gz

The installer file comes already with execute permissions, and therefore, you do not need to assign execute permissions.

4. Install FreeFileSync on Ubuntu 22.04

To install FreeFile Sync, simply run the installer file as shown.

$ sudo ./FreeFileSync_11.28_Install.run

Type ‘y’ and press ENTER to accept the License Terms.

Next, the following output will be displayed on the terminal. Just leave the default settings the way they appear and hit ENTER to proceed with the installation.

In just a matter of seconds, the installation will be complete, and you will get the following output as confirmation.

Upon completion of the installation, you will get two icons at the bottom right of your Ubuntu desktop as shown.

To activate the FreeFileSync desktop icon, right-click on it and select ‘Allow Launching’.

The icon now turns green as shown. To launch FreeFileSync, simply double-click the icon.

The FreeFileSync desktop application will pop open. The ‘About’ pop-up displays the version of FreeFileSync installed and contributors to the project.

To access the dashboard, click the ‘Close’ button

This is what the dashboard looks like.

5. Synchronize files using FreeFileSync

In this section, we are going to demonstrate how to synchronize files from one folder to another. This is our directory setup

• Source folder :                /home/linuxtechi/data
• Destination folder :         /home/linuxtechi/Documents

First, click the ‘Browse’ button in the first section and select the source folder. Similarly, click the ‘Browse’ button in the second section to select the destination directory in which the synchronization is going to occur.

Finally. Click the ‘Synchronize’ button.

Next, click ‘Start’ to start the file synchronization process

This can take a while depending on the size of the files being synchronized. You should see a progress chart indicating how the synchronization is going on.

Once done, confirm that the source and destination folders have the same files

Conclusion

This brings down the curtains on this guide. In this tutorial, we have installed FreeFileSync on Ubuntu 22.04 and demonstrated how you can use it to synchronize files between folders.

In this tutorial, we walk you through the installation of Docker Desktop on Ubuntu 22.04.

The conventional way of running and managing Docker container images is on the command line. However, this can be a daunting prospect for beginners who are just getting started out with learning Docker. And this is where Docker Desktop comes in.

Developed by Docker, Docker Desktop is a free and user-friendly GUI application that allows users to easily run and manage Docker containers and images from their Linux PC without the need for executing commands on the CLI.

Docker Desktop is a cross-platform application which means you can install it on Windows, Linux, and Mac. It is free for companies of up to 250 employees beyond which you need a paid subscription.

Prerequisites

Before installing anything else, ensure that your PC meets the following set of basic requirements.

• 64-bit CPU with Virtualization Support enabled.
• At least 4GB RAM
• A GUI desktop environment (Preferably GNOME, MATE, or KDE )
•  A Sudo User with admin rights

Now let us jump right in and install Docker Desktop on Ubuntu 22.04

Step 1) Confirm KVM virtualization is enabled

To get off the ground, you need to ensure that KVM virtualization is supported. To check if the KVM module is loaded, run the command:

$ lsmod | grep kvm

If the module is loaded, you should get the following output. This shows that the KVM module for the Intel CPU is enabled.

If the module is not loaded, you can run the following commands:

For Intel Processors

$ sudo modprobe kvm_intel

For AMD Processors

$ sudo modprobe kvm_amd

Step 2) Install Docker on Ubuntu 22.04

The next step is to install Docker. But first, update the package lists and install the requisite dependencies as follows

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

Once the installation is complete, add Docker’s GPG signing key.

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/trusted.gpg.d/docker-archive-keyring.gpg

Next, add the official Docker’s repository to your system as follows.

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

Once the repository is in place, install Docker and other Docker tools as shown.

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

After successful installation, add the user account to the Docker group using the following commands:

$ sudo usermod -aG docker $USER
$ newgrp docker

To verify that docker is running, execute the following command:

$ sudo systemctl status docker

You can also check the version of Docker installed alongside other information as shown.

$ docker version

Step 3) Install Docker Desktop on Ubuntu 22.04

Docker Desktop is not yet available on official Ubuntu repositories or Docker itself. Therefore, you need to manually download the Debian binary file. from the Official Docker website.

At the time of writing this guide, the latest version of Docker Desktop is Docker Desktop version 4.15.0. You can use the wget command as shown.

$ wget https://desktop.docker.com/linux/main/amd64/docker-desktop-4.15.0-amd64.deb

Alternatively, you can click the following link under the ‘Linux DEB’.

Once the file is downloaded, install Docker Desktop by running the following command:

$ sudo apt install ./docker-desktop-*-amd64.deb

Step 4) Launch Docker Desktop 

Once Docker Desktop is installed, you can use the application manager to search and launch it as shown.

You can also launch on the command line as shown.

$ sudo systemctl --user start docker-desktop

Once Docker Desktop is launched, the following pop-up will be displayed. Click ‘Accept’ to accept the license terms.

Shortly after, the Docker Desktop GUI dashboard will launch. It takes roughly 3 -5 minutes to initialize and get started so, be patient.

To take a tour of the Docker desktop and get tips on how to get started with Docker, hit the ‘Start’ button.

If you don’t wish to take the tour, simply click ‘skip tutorial’.

Finally, you will land on the Docker Desktop home page as you can see below with instructions on how to get started with containers.

Step 5) Configure Docker Desktop

Docker Desktop is highly configurable, and you can tweak almost every setting to suit your preferences.

These settings are grouped into the following:

• General
• Resources
• Docker Engine
• Experimental Features
• Kubernetes
• Software Updates
• Extensions

To access these settings, click on the top gear icon and the ‘Settings’ tab will appear with the above-mentioned options.

For example, in the resource tab, you can configure system resources required by Docker Desktop such as No, of CPUs, RAM, Swap space, etc.

Step 6) Running containers with Docker Desktop

When you have configured Docker Desktop according to your preferences, you can start running containers. As an example, we will run a Redis container.

So, click on ‘Run’

On the pop-up that appears, select the directory in which the container image will be pulled.

Docker Desktop will start pulling the container image from the Docker hub and create a container instance of Redis which is an in-memory key-value data store.

Once the image is pulled, a container will be created, and the following overview dashboard will be displayed.

You can click on the ‘Containers’ tab to view and manage all the containers on the system (whether running or stopped).

Similarly, you can click on the ‘Images’ tab to view and manage pulled container images.

Step 6) Uninstalling Docker Desktop

If you no longer need Docker Desktop on your system, you can uninstall it using the following command.

$ sudo apt purge docker-desktop

The remove the associated Docker Desktop files.

$ rm -r $HOME/.docker/desktop
$ sudo rm /usr/local/bin/com.docker.cli

Final Words

In this guide, we walked you through the installation of Docker Desktop and demonstrated the basics of how you can get started and start creating and managing container images. Your feedback on this guide will be appreciated.

Also Read: 20 Useful Docker Command Examples in Linux

Garuda Linux is a user-friendly and visually appealing Linux distribution that is popular among gamers. It is a rolling distribution based on Arch Linux that is designed to offer exemplary performance while focusing on offering an immersive user experience with beautiful and elegant desktop themes.

Garuda Linux offers its users a wide selection of vibrant desktop environments including Plasma KDE, GNOME, LXQt-win, Xfce, and Qtile to mention a few. Like Arch Linux, it uses Pacman as its default package manager and ships with a huge collection of software packages.

Key highlights of Garuda Linux include:

• Calameres installer for simplifying the installation process.
• BTRFS is the default filesystem with zstd compression.
• Enhanced Linux kernel for optimized multimedia and gaming.
• Elegant desktop themes with blur effects out of the box.
• Garuda Assistant GUI tool for managing various tasks along with snapper.
• Automatic snapshots using the Timeshift backup tool.
• Garuda Settings Manager for managing kernels and drivers.
• Garuda gamer for managing gaming software.

In this guide, we will demonstrate how to install Garuda Linux step-by-step with screenshots.

Step 1) Download Garuda Linux ISO

The first step in installing Garuda Linux is to download the ISO image file. Currently, there are 10 Editions of Garuda that are available. So, head over to the official Garuda Download page and download your preferred ISO file.

Once you have downloaded the Garuda Linux ISO file, grab a 16GB USB drive and create a bootable USB installation medium using Rufus, Balena Etcher or any other software for writing image files onto a USB drive.

Step 2)  Boot system with installation medium

With the installation medium at hand, plug it into your PC and reboot the system. Be sure to set the bootable USB drive to have the highest boot priority and continue booting.

The first screen that comes to view provides you with a list of options as shown below. You can choose either the ‘Boot with opensource drivers’ or ‘Boot allowing proprietary drivers (NVIDIA)’ option.

Soon afterward, you will see the boot messages splash on your screen for a minute or so.

The Garuda installer will be initialized, and you should see the Garuda Linux logo.

A moment later, you will land into the live Garuda Linux environment. On the welcome screen, click ‘Install Garuda Linux’ to commence the installation of Garuda Linux.

Step 3) Select Installation Language

The beautiful and intuitive Calameres installer will come to view. On the left sidebar is a list of installation steps that you will be required to take.

To proceed with the installation, select the installation language and click ‘Next’.

Step 4)  Select Geographical Region

Next, select your current or preferred geographical location and time zone and click ‘Next’

Step 5)  Select Keyboard Layout

Next, select your preferred layout. Here, we will go with the default selection which works just fine. Then click ‘Next’.

Step 6) Configure Partitioning

In this section, you will be required to partition your hard drive. You will be presented with two options as shown.

• Erase Disk: This option wipes out everything on your hard drive including the existing operating system and all the files. It’s preferred if you want to start from scratch. In addition, the option automatically partitions the hard drive and is recommended for Linux users who are not comfortable with manual partitioning.
• Manual Partitioning: This option offers the autonomy to create your disk partitions. It’s recommended if you want to have a dual boot setup.

For this guide, we will go with ‘Manual partitioning’. These are the partitions we are going to create:

• /boot/efi      –   512MB
• Swap           –   8GB
• /                   –   18GB
• /home         –   14GB

Next, click ‘New Partition Table’

We will opt to go with the GPT (GUID Partition Table) option which is the most preferred, and click ‘Ok’.

Your hard drive will be labeled as ‘Free Space’ to begin with. This is because no partitions have been created so far. To begin creating disk partitions, click ‘Create’.

Since we are using UEFI boot mode, we will start by creating the /boot/efi partition as shown.

• Size: 512MB
• File System: FAT32
• Mount Point:  /boot/efi
• Flag:  boot

Once you are done, click ‘Ok’.

For swap space:

• Size: 512MB
• File System: linuxswap
• Flag:  swap

For /  partition

• Size: 18500MB
• File System: btrfs
• Mount Point:  /
• Flag:  root

For /home partition

• Size: 14718MB
• File System: btrfs
• Mount Point:  /home

The complete partition table looks like this. To proceed, click ‘Next’.

Step 7)  Create a login and administrative user

Next, you will be required to create a regular login user and root account. Therefore, fill in the required details as shown below and click ‘Next’.

Step 8) Installation Summary & Start Installation of Garuda

A summary of all the settings that you have configured or selected will be displayed. So, carefully review the settings, and if all looks good, click ‘Install’.

On the pop-up that appears, click ‘Install Now’ to confirm.

The installation of Garuda Linux will commence as the installer copies the files from the installation medium to the hard drive. This takes about 30 minutes, so you can take a breather.

Once the installation is complete, click ‘Restart’ and then click ‘Done’ to reboot in order to log in to your new Garuda installation.

Once the system is rebooted, you will get the following Garuda assistance pop-up prompting you to apply system updates. So, click ‘Ok’.

This opens a terminal on which the update of the packages will take place. Authenticate with your password and press ENTER.

Once the update is complete, you will then be required to log in using your password.

Conclusion

This concludes this guide on the installation of Garuda Linux. All the best as you get started out with one of the most visually appealing Arch-based Linux distributions.

In this post, we will show you how to create a sudo user on Ubuntu Linux.

Sudo user is a regular user in Linux who has some admin rights to perform administrative task on the system. In Linux, root is the super user who has full admin rights, but it not recommended to give root credentials other users or to work on a system as root user.

So, the best practice is to create a regular user and assign sudo rights.  By doing so we can track which user has executed which commands using sudo logs (/var/log/auth.log).

When we install Ubuntu Desktop or Ubuntu server then a group named ‘sudo’ is created automatically. If we add any regular user to that sudo group then that user will have sudo admin rights.

Creating Sudo User from Command Line

In this post, we have tested following commands on Ubuntu 22.04 LTS (Jammy Jellyfish). To create new sudo user, open the terminal and switch to root user and run following command,

# adduser <user-name>

Example,

# adduser sysops

This command will prompt to set password of sysops user and other details as shown below,

Output of id command confirms that sysops user is created successfully, now add this user to sudo group using usermod command,

# usermod -aG sudo sysops
# id sysops

Output,

To add an existing user to sudo group, run

# usermod -aG sudo <<Exiting-User-Name>>

Testing Sudo User Access

To test sudo access, switch to sudo user and try to run some admin commands by placing sudo in front of command.

# su – sysops
$ sudo ls -l /root
$ sudo apt update

As we can see above, sysops user is able to run admin commands by putting sudo in front of each command. When we run the command with sudo first time then it will prompt you to enter user’s password and will save it for next 5 minutes. After that interval, it will prompt to enter password again while executing sudo command.

Creating new sudo user from Desktop Environment (GUI)

If you are not comfortable with command line and wants to create a new sudo user from GUI then refer the below steps.

From the Activity, search users and click on user’s icon as show below,

It will take us to the following window, click on unlock and enter your user’s password,

After entering the credentials, click on Add User option and specify the user details like full name, username, standard or administrator (sudo) and password.

Click on Add,

Great, above window shows that sysops user is created as a sudo user (administrator). To start using this user, logout and login with this user.

That’s all from this post. we hope you have learnt how to create a sudo user on ubuntu Linux from command line and desktop environment (GUI). Please don’t hesitate to post your queries and feedback in below comments section.

Are you looking for an easy guide on how to install docker on openSUSE Linux?

The instructions on this page will show you how to install docker on openSUSE Leap 15.4.

Docker provides software platform where we can build, test and package application in a container image. Using the container image, we can quickly deploy application because that container image will have all the libraries, code, system tools and run time.

Prerequisites

• Pre-Installed openSUSE Leap 15.4
• Local user with sudo rights
• Internet Connectivity

Without further ado, let’s jump into Docker installation steps.

1) Install Updates

Login to your openSUSE system and open the terminal and run following zypper command to install updates,

sudo zypper refresh
sudo zypper update -y

Once all the updates are applied, then reboot the system,

sudo reboot

2) Install docker with zypper command

Docker package and its dependencies are available in the default repositories of openSUSE Leap 15.4, run following zypper command to install docker,

sudo zypper install -y docker

Once the docker package installation is completed, start its service in the next step.

3) Start and enable docker service

Run the following systemctl commands to start and enable docker service,

sudo systemctl start docker
sudo systemctl enable docker

To verify the docker service status, run

sudo systemctl status docker

Execute the beneath command to view docker version,

sudo docker version

As you can see above, we have used sudo in front of docker command, so to allow local user to run docker command without sudo then add your local user to docker group as shown below,

sudo usermod -aG docker $USER
newgrp docker

4) Test docker installation

To test docker installation, let’s spin up a container using hello-world docker image,

docker run hello-world

Above informational message confirms that docker installation is successful.

Remove Docker

To remove docker from your system, run following set of commands,

sudo zypper remove docker
sudo rm -rf /var/lib/docker
sudo rm -rf /var/lib/containerd

That’s all from this guide, please do submit your queries and feedback in below comments section.

In this post, we will explain how to install Node.js on RHEL 9 system step-by-step.

Built on Google’s V8 Javascript engine, Node.js is a free and opensource, cross-platform JavaScript runtime that is mostly used for building server-side applications. It uses an event-driven and asynchronous model that helps developers build highly scalable, data-intensive real-time applications (RTAs ). You can use NodeJS to build both front-end and back-end applications.

Node.js is commonly used in building the following applications:

• Chat applications
• Streaming applications
• Browser games
• Command-line tools
• Embedded systems

Top companies that use NodeJS in their tech stacks include PayPal, Netflix, and Uber to mention a few.

There are three main ways of installing Node.JS:

1. Installing Node.JS from the NodeSource repository
2. Installing Node.JS from the distribution’s Official repository
3. Installing Node.JS using NVM

Let us check out how to install Node.JS on RHEL 9 using each of these methods.

Prerequisites

• Minimal Installed RHEL 9 System
• Sudo User with admin rights
• Internet Connectivity
• Red Hat Subscription or locally configured repository

Installing Node.js from NodeSource Repository

NodeSource is a technology company that seeks to help organizations run production-ready Node.Js applications with more focus on resource usage and enhanced security and application performance. It provides the latest versions of Node.JS and NPM.

To install Node.SJ from Nodesource, first, update the system packages as shown.

$ sudo dnf update -y

Next, install the required build tools which will be required during the installation of Node.JS. These include the GCC c/c++ compiler, Perl, and Python debuggers to mention a few.

$ sudo dnf groupinstall 'Development Tools' -y

Next, we are going to install Node.JS 18.x from Nodesource. To do this, download and run the NodeSource setup script as follows.

$ curl -fsSL https://rpm.nodesource.com/setup_18.x | sudo bash -

The script adds the Nodesource repository to your system among other tasks

At the tail end of the output, you will see some additional instructions provided on how to install Node.JS and npm.

Therefore, to install Node.JS and npm (Node Package Manager), run the command:

$ sudo dnf install nodejs -y

Once the installation is complete, verify the version of Node.JS and NPM as shown.

$ node -v
$ npm -v

The output shows that we are running Node v18.12 which is the latest LTS release and NPM 8.19.2.

Installing Node.js from the official RHEL repositories

The other way of installing NodeJS and NPM is by installing them from your distribution’s official repository. However, this approach does not provide the latest versions.

If you don’t mind not installing the latest versions of Node and NPM. , then run the following command on the command line.

$ sudo dnf update -y
$ sudo dnf install nodejs npm -y

Installing Node.js using NVM

Lastly, you can install Node.JS using NVM ( Node Version Manager) which is a tool for managing Node versions on your system. The tool helps developers work efficiently on different projects which require different versions of Node.JS

NVM is not installed by default You need to install it by running the Shell script which is available on the Official GitHub Page.

$ curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.2/install.sh | bash

This downloads and saves nvm in the .nvm directory in your home directory.

Once installed, close your terminal sessions and open a new terminal. Then run the following command to confirm that NVM has been installed.

$ command -v nvm

Next, you can list all the available versions of Node.JS using the following command:

$ nvm ls-remote

Alternatively, you can list all the latest LTS releases for Node.JS versions as shown.

$ nvm ls-remote | grep -i latest

To install the very latest version of Node.JS (currently v19.0.0 ), run the command:

$ nvm install node

You can then verify the version of Node installed as shown.

$ node -v

In addition, you can install a specific version of Node. JS. For example, to install v18.2.0, run the command:

$ nvm install v18.12.0

To list all the installed versions of NodeJS on your system, run the command:

$ nvm ls

The first entry with the sign ( – > ) points to the version of Node.JS that is currently in use. This is then followed by other versions as indicated below

To switch to another version of Node.JS, use the syntax:

$ nvm use <version>

For example, to use Node version 19.0.0, run the command:

$ nvm use 19.0.0

Again, check the installed versions of Node.JS, and this time the  ( – > ) sign will point to v19.0.0

Conclusion

In this guide, we have demonstrated how to install Node.js using three different methods. In addition, we have provided a few ways in which you can manage the Node versions using NVM. We hope that you can now comfortably install NodeJS on RHEL and choose the version that you want to work with on your project.

Sometimes, you might want to delete some disk partitions on your Linux system to recover or regain some storage space. You can easily accomplish this on the command line with a few simple steps.

In this guide, we will demonstrate how you can delete a partition in Linux step-by-step. We will start off by deleting a standard partition and then deleting an LVM partition.

Delete a standard partition using the fdisk utility

The fdisk tool, also known as format disk, is a Linux utility that ships by default with every modern Linux distribution. The tool provides disk partitioning functions such as creating and deleting disk partitions, modifying the partition table, and printing the disk partitions to mention just a few.

Before deleting a partition, it is always advised to back up any data on it.

In our setup, we have a USB drive attached to the system with two partitions: /dev/sdc1 and /dev/sdc2. To confirm the existence of the partitions, we will run the fdisk utility as follows.

$ sudo fdisk -l /dev/sdc

You can also run the command to list the partitions on the block volume as shown.

$ lsblk | grep sdc

We are going to delete the second partition /dev/sdc2 using the fdisk utility.

To get started, invoke the fdisk command-line tool.

$ sudo fdisk /dev/sdc

This launches an interactive command-line prompt. Type ‘p’ to print the current partition table of the drive. The output below confirms the existence of the two partitions.

Since our mission is to delete the second partition, we will type ‘d’  for delete and press ENTER. Next, specify the partition number of the drive to be deleted – in this case, partition number 2  which corresponds to /dev/sdc2.

You will get the message: Partition 2 has been deleted.

To save the changes made to the partition table, type ‘w’ to write changes and press ENTER.

To verify that the volume has been deleted, once again, run the fdisk utility as follows.

$ sudo fdisk /dev/sdc

When prompted for the command, type ‘p’ for print to view the partition table. This time around, only one partition is listed – /dev/sdc1. This confirms that we have successfully deleted the second partition.

How to delete an LVM partition

LVM (Logical Volume Management ) is a storage concept that combines multiple disk partitions or hard drives into a single volume group (VG). The volume group can, hence, be used as a single large volume or sub-divided into other logical volumes (LV)

In this setup, we have a volume group called vg01 mounted on a mount point called /data.

$ df -Th | grep -i /data

You can also run the lvs command to list the Logical Volume and Volume Groups.

$ sudo lvs

We are going to delete lv01 Logical Volume from the vg01 Volume Group.

To do so, first, delete the Logical Volume entry from the /etc/fstab file.

$ cat /etc/fstab
...
/dev/mapper/vg01-lv01    /data    ext4    defaults     0 0
...

Save the changes and exit the file. Next, unmount the directory on which the Logical Volume is mounted.

$ sudo umount /data

Next, disable the Logical Volume Group.

$ sudo lvchange -an /dev/vg01/lv01

Be sure to delete the LVM volume. When prompted, type ‘y’ to proceed

$ sudo lvremove /dev/vg01/lv01

Next, disable the Volume Group.

$ sudo vgchange -an vg01

Thereafter, delete the Volume Group.

$ sudo vgremove vg01

Finally, delete the physical volumes that were used to create the Volume Group called vg01. In this case, these were /dev/sdb1 and /dev/sdb2.

$ sudo pvremove /dev/sdb1 /dev/sdb2

When you run the lvs command again, you won’t get any output. This is a confirmation that the LVM volume has successfully been deleted.

$ sudo lvs

Conclusion

And it’s a wrap. We have successfully demonstrated how you can delete a standard and an LVM partition in Linux. We hope you were able to follow along and implement the steps to delete disk partitions on your system.

Also Read: How to Create LVM Partition Step-by-Step in Linux