Sudo user is the regular user in Linux which has admin or root privileges to perform administrative tasks. But, by default all regular users in Linux are not sudo users, root user has to manually assign sudo rights to the user by adding it to wheel group.

In RHEL distributions like Red Hat Enterprise Linux, Rocky Linux and AlmaLinux, a group with name ‘wheel’ is created during the installation and its entry is already defined in system’s sudoers file.

# grep -i "^[%wheel]" /etc/sudoers
%wheel  ALL=(ALL)       ALL
#

When any regular user is added to this wheel group then that user will get sudo rights and can run all admin commands by using ‘sudo’ in front of the commands. In this post, we will learn how to create a new sudo user on RHEL, Rocky Linux and AlmaLinux OS step by step.

1) Login to system as root

Login to your system as root user or if you have logged-in as regular user switch to root user, use following command

$ su - root

2) Create regular user with useradd command

While creating a new regular user, specify ‘wheel’ as secondary group.

Syntax:

# useradd -G wheel <User_Name>

Let’s assume we want to create a user with name ‘sysadm’, run following useradd command

# useradd -G wheel sysadm

Assign the password to above newly created user with beneath passwd command,

# echo "P@##DW0$Ds" | passwd sysadm --stdin

Note: Replace the password string with the password that you want to set for the user.

Use following command to add an existing regular user to wheel group,

# usermod -aG wheel  <User_Name>

Run beneath command to verify whether user is part of wheel group or not.

# id sysadm
uid=1000(sysadm) gid=1000(sysadm) groups=1000(sysadm),10(wheel)
#

3) Test Sudo User

To confirm whether newly created user has sudo rights or not, run couple of admin commands and don’t forget to type sudo in front of commands.

First switch to regular user or login with regular user and run following commands,

# su - sysadm
$ sudo whoami
[sudo] password for sysadm:
root
$
$ sudo dnf install -y net-tools

Output of above command would like below:

Above confirms that user has sudo rights and can run admin commands. If you have noticed carefully, we must specify password for executing admin commands via sudo. In case, you want to run sudo commands without password, then edit the sudoer files, comment out the line “%wheel  ALL=(ALL)       ALL” and uncomment “# %wheel        ALL=(ALL)       NOPASSWD: ALL”

# vi /etc/sudoers

Save and exit the file.

Alternate way to run sudo commands without password is that create a separate file with name like ‘sysadm’ under the directory ‘/etc/sudoers.d’ and add the following entry.

User_Name ALL=(ALL) NOPASSWD: ALL

Run beneath echo command to complete above task,

$ su -
# echo -e "sysadm\tALL=(ALL)\tNOPASSWD: ALL" > /etc/sudoers.d/sysadm
# cat /etc/sudoers.d/sysadm
sysadm  ALL=(ALL)       NOPASSWD: ALL
#

Now, if we run admin commands via sudo then it will not prompt for the password.

Great, that’s all from this post. Please do post your queries and feedback in below comments sections.

Also Read: 10 Quick Tips About sudo command for Linux systems

Nmcli (network manager command-line interface) is a command-line utility used to control the NetworkManager daemon which is used to configure network interfaces.

With the nmcli utility, you can display, create, edit, enable and disable network interfaces or connections. It is especially handy for servers and headless systems which do not have a GUI.

In this tutorial, we focus on how you can configure IP networking with the nmcli command in Linux.

Basic Syntax

The nmcli command takes the syntax shown below:

$ sudo nmcli [OPTIONS] OBJECT {COMMAND | help }

Where Object can be any of the following:

• Device or network interface managed by NetworkManager
• NetworkManager’s connection.
• NetworkManager’s stats

Let us now check out how you can configure IP networking with the nmcli command in Linux

Display active and inactive network interfaces

Without any command arguments, the nmcli command displays detailed information about all the network interfaces – both active and inactive.

$ nmcli

Some of the information displayed includes the state of the network connection, hardware type of the network adapter associated with the interface, MAC address, IPv4 and IPv6 addresses and default routes.

To get a brief summary of the network interfaces run the command:

$ nmcli device status 
OR
$ nmcli dev status

To list all the active interfaces on your system, execute the command:

$ nmcli connection show
OR
$ nmcli con show

The output displays the name of the connection, UUID, the type of connection (Wired or WiFi) and the device (network interface)

Alternatively, you can run the command:

$ nmcli connection show --active

Specify output fields in the output

You can specify what fields you want to be displayed on the terminal. Valid fields include DEVICE, TYPE, CONNECTION, CONN-UUID, STATE, IP4-CONNECTIVITY, and IP6-CONNECTIVITY.

In the example below, we have chosen to display the DEVICE and DEVICE TYPE only.

$ nmcli -f DEVICE, TYPE device

Using the -p (pretty) option, you can display the output in a more human-readable format where the values and headers are well aligned.

$ nmcli -p device

Configuring a static IP using the nmcli utility

In this section, we will demonstrate how you can configure a static IP address with the following values:

• IP address:                   192.168.2.150/24
• Default gateway:         192.168.2.1
• Preferred DNS:           8.8.8.8, 8.8.4.4
• IP addressing              static

Before we assign a static IP, let us check the current IP address of our system which is 192.168.2.104 as indicated.

To set the static IP address with the connection name or profile called static-ip, IPv4 address 192.168.2.150, and default gateway  192.168.2.150 we will run the command:

$ sudo nmcli con add type ethernet con-name "static-ip" ifname enp0s3 ipv4.addresses 192.168.2.150/24 gw 192.168.2.1

Next, we will configure the DNS server as follows.

$ sudo nmcli con mod static-ip ipv4.dns "8.8.8.8 8.8.4.4"

To activate the connection we will run the command:

$ sudo nmcli con up static-ip ifname enp0s3

We have simply added another IP address to our network interface enp0s3. To confirm that the IP address was successfully added, we will run the ip command:

$ ip addr

Enabling / Disabling a network connection

In this section, we will explore how you can manage the connection by either activating or deactivating them. To disable or deactivate a connection, run the command:

$ sudo nmcli con down id "static-ip" ifname enp0s3

You can also simply leave out the ifname enp0s3 parameters.

$ sudo nmcli con down id "static-ip"

To bring up or enable a connection, run the command:

$ sudo nmcli con up id "static-ip" ifname enp0s3

Alternatively, you can truncate the command as follows:

$ sudo nmcli con up id "static-ip"

To check out more on nmcli command options, simply run the command:

$ nmcli --help

Conclusion

The nmcli utility is a useful tool for adding and managing network connections on Linux systems. It provides easy command-line options to help you configure networking particularly on headless servers. In this guide, we have demonstrated how you can add and manage network connections with the nmcli command in Linux.

Also Read: 9 tee Command Examples in Linux

EndeavourOS is a terminal-centric Arch-based Linux distribution that provides a cool and elegant desktop environment and prides itself in having a vibrant community of opensource developers. Like all rolling releases, it’s an evolving distribution that aims at provides the best and the latest software packages. If you fancy an Arch-based distribution with a beginner-friendly User Interface, then EndeavourOS is the go-to Linux flavor.

In this guide, we will journey through a step-by-step installation of EndeavourOS with screenshots.

Prerequisites

As you get started, here is what you need:

• An ISO image of EndeavourOS. You can download the latest release this from the official download page. The latest release combines both the offline & online installer. The offline installer ships with XFCE while the online installer offers you the option of 7 desktop environments including GNOME, LXQt, MATE, Cinnamon, KDE Plasma and GNOME Budgie.
• A 16 GB USB pendrive for creating a bootable installation medium.
• A good internet connection (for the online installation option)
• A System with minimum 4GB RAM and 10 GB hard disk space.

Step 1)  Create a bootable USB Drive

The first step is to create a bootable USB drive from the downloaded ISO image. This is simple and you can use the Rufus utility tool which is free to download and use. Once you have made your USB drive bootable, plug it in on the target system where you will install EndeavourOS and reboot. Be sure to set the boot priority in such a way that your bootable USB drive will be detected first.

Step 2) Begin EndeavourOS installation

On the boot-up screen, you will see a grub menu with a number of options listed. By default, the first option will be highlighted, and this is the option we will select to kick-start the installation.

Soon thereafter, you will see a flurry of boot messages on the screen as the live installer gets ready.

In a short moment, the EndeavorOS live environment will come to view, and a pop-up dialogue box will appear with a list of options. Since our goal is to install EndeavorOS select ‘Start the installer‘ to begin the installation.

A pop-up will appear providing you with two installation methods: Offline and Online. You can select either depending on your environment. In this case, we went with the offline method.

Step 3) Select installation language

Once you have selected your preferred installation option, The calamares installer will be displayed. The first step will be to select your preferred installation language. Then click on ‘Next’.

Step 4) Configure locale and timezone settings

In the next step, select your geographical location and set the timezone accordingly. Then click ‘Next’.

Step 5) Configure Keyboard

The next step will require you to configure your keyboard. This is, by default, set to English(US). Feel free to configure it to your preferred language and model and perform a typing test in the text field provided below.

Once you are satisfied with your selection, click on ‘Next’.

Step 6) Create disk partitions

In disk partitioning, you get two options: Automatic and manual partitioning. The ‘automatic partitioning’ option allows the installer to automatically configure the disk partitions and is especially recommended for beginners in Linux.

The ‘manual partitioning’ option gives you total freedom of creating your disk partitions. It allows you to specify your own partitions and their sizes.

In this guide, we settled for automatic partitioning. To choose this option, click on the ‘Erase disk’ option.

Then click ‘Next’.

Step 7) Create a regular login user

In this step, create a login user by specifying the username and password. Be sure to also specify your PC name as well.

Step 8) Overview of pre-installation summary

Before the actual installation of EndeavourOS begins with the copying of system files and packages on your PC, a pre-installation summary will be provided with all your configuration selections.

Go through all the settings and ensure that all looks good. If you are satisfied with what you have, click ‘Install’. Otherwise, click on ‘back’ and change your settings.

Once you click on the ‘Install’ button, a pop-up will appear prompting you start the installation. So, click ‘Install now’.

The installation will commence as the installer copies all the required files and software packages on your PC. This takes a while, and in our case, it took roughly 25 minutes. At this point, you can take a break and grab some coffee.

Once the installation is complete, you will be prompted to restart your PC. So, select the ‘Restart now’ button and click ‘Done’ to reboot your PC. At this point, be sure to remove the bootable installation medium.

Step 9) Boot System with EndeavourOS

When the system reboots, select the first option as indicated.

When the login page is presented, provide your password and press the ‘Login’ button.

This ushers you to the EndeavourOS XFCE elegant desktop environment. Click on the ‘EndeavourOS’ button to browse various applications and get started.

Feel free to run the neofetch utility to probe for more information such as the OS, kernel, uptime, number of installed packages , resolution, CPU type and so much more.

And that’s it. We have successfully walked you through the installation of EndeavourOS.

Also Read: How to Create and Configure Sudo User on Arch Linux

Debian, which is a hugely popular Linux distribution, has given rise to a wide selection of popular Debian flavors. Among the most celebrated and hugely popular Debian flavors is MX Linux, which takes the first position in Distrowatch at the time of penning down this tutorial.

MX Linux project is made possible by the collaborative efforts of AntiX and former MEPIS Linux communities. It is a desktop-oriented Linux flavor that provides XFCE as the default desktop environment – although you can get it in KDE Plasma and Fluxbox.

MX Linux is a middleweight Linux distribution that combines a colorful and efficient desktop with rock-solid stability and superb performance. The latest stable version of MX Linux is MX Linux 21, codenamed Wildflower. It is based on Debian 11 Bullseye and ships with all the latest software updates and goodness for an amazing and elegant desktop distribution.

In this guide, we will show you how to install MX Linux 21 step-by-step.

Step 1) Download the MX Linux ISO installation file

The first step is to download the MX Linux ISO image. To do this, head over to the MX Linux 21 release page and download your preferred MX Linux desktop environment and architecture. The download will be initiated from SourceForge.

Once downloaded, create a bootable USB drive from the ISO image using an application such as Rufus or UNetBootin.

With the bootable USB drive in place, plug it into your PC and reboot. Ensure that your BIOS is set to boot from the USB installation media by setting the boot priority accordingly.

Step 2) Begin the installation of MX Linux

Once your system has booted, select the first option labeled ‘MX-21 x64 (October 20, 2021)‘.

This will boot into the live installation environment and a dialogue pop-up window will appear with an array of options to choose from. Since our objective is to install MX Linux, click on the ‘Install MX Linux’ option.

Step 3) Configure the keyboard

In the next step, read the terms of use, and ensure that your keyboard settings are configured to your preference. To proceed to the next step, click on the ‘Next’ button.

Step 4) Disk partitioning

The next step provides you with two installation modes. You can install using the regular installation mode, or alternatively, you can opt to customize the disk layout.

The first option is the easier of the two as it automatically partitions your hard drive, and here, we opted to go with the first option.

To proceed, click ‘Next’.

A pop-up will appear prompting you to format and use the entire disk. Click ‘Yes’

The installation will get underway as the installer copies all the required packages on your hard drive. This will take a while, so just be patient as the installation of MX Linux continues.

Be on the lookout for the ‘Paused for required operator input’ label on the progress bar. This indicates that some additional information is required. At this point, click on the ‘Next’ button.

Step 5) Configure computer name

In this section, provide your computer name, and domain (if applicable ) and click ‘Next’.

Step 6) Configure system locale, time and date

Be sure to configure your locale, time zone, and system clock format. Once again, click ‘Next’ to proceed.

Step 7) Create a regular and root account

In the next section, you will be required to create two accounts: a regular account and a root account. To create a regular login account, provide your preferred username and password. Then create a root account by providing a strong password and confirming it.

Then click ‘Next’ to go to the next step.

The installer will then proceed to install the remainder of the packages including the GRUB bootloader and perform all the necessary configurations to ensure the system is successfully installed.

Step 8) Wrap up the installation and reboot

When the installation is complete, click on the ‘Finish’ button. This will reboot your system.

But before the system reboots, you will be prompted to remove your installation media and press ENTER. So, remove your bootable USB drive and hit ENTER to restart your system, and boot into your fresh MX Linux installation.

Step 9 ) Login to MX Linux 21

On the GRUB menu, select the first option ‘MX 21 Wildflower’.

After the booting process, you will be ushered to the login screen as shown. Provide your username and password and click ‘Login’.

And the beautiful and dazzling MX Linux desktop will come into view.

You can use the neofetch command to probe for the OS and system information as shown.

$ neofetch

This provides information such as the OS type, hardware platform, kernel version, uptime, bash version and screen resolution to mention just a few parameters.

To get started with MX Linux, feel free to refresh the package lists and upgrade the packages to their latest versions:

$ sudo apt update -y && sudo apt upgrade -y

Conclusion

And that’s it. We have successfully walked you through a step-by-step installation of MX Linux 21 WildFlower.

Sometimes, you might want to define your own custom $PATH variable which, in most cases, is not provided by your operating system. Doing this will enable you to invoke your variable from any location in the Linux shell without specifying the full path to the variable or command. In this tutorial, we will walk you through how you can set your custom $PATH variable in Linux. This works across all Linux distributions, so don’t worry about the distribution you are using. It will work just fine.

Set Custom $PATH Variables in Linux

When you type and run a command on the Linux shell, you are basically telling the shell to run the program. This includes even the basic of commands such as the mkdir, pwd, ls, mv and so many more. Now, your operating system doesn’t shuttle to and fro multiple directories looking to see if there’s a program or executable by that name. These programs are part of an environment variable called $PATH.

The $PATH environment variable tells the shell which directories to find the executable files or programs in response to the commands run by the user. Simple commands such as cp, rm, mkdir, and ls are small programs that have their executable in the /usr/bin directory.

To find the location of the executable program of a shell command, simply run the which command as follows:

$ which command

For instance, to identify the location of the cp command, for example,  execute the command:

$ which cp

Other locations where you can find executable programs include /usr/sbin, /usr/local/bin and /usr/local/sbin

To check what is in your $PATH, run the following echo command:

$ echo $PATH

This displays a list of all the directories – separated by a colon – that store the executable programs, some of which we have just mentioned a while ago.

Now, we are going to add a custom directory to the $PATH variable.

Setting your own PATH

In this example, we have a shell script called myscript.sh in the scripts directory located in the home directory as shown. This is just a simple script that prints out a greeting when invoked.

To add the script to PATH so that we can call it or execute it no matter which directory we are in, we will use the syntax:

$ export PATH=$PATH:/path/to/directory

Here, we will execute the command:

$ export PATH=$PATH:/home/linuxtechi/scripts

Now, we can execute or run the script from whichever directory on the system simply by typing its name without including the full path to the script.

In the snippet shown, we are running the script in different directory location by simply invoking the script name alone.

Setting custom PATH permanently

When you reboot your system, or start a new terminal, the path you added does not persist. For this reason, it’s best if you set the PATH permanently so that it remains even after restarting the system.

To achieve this, you need to add the export PATH line to the ~/.bashrc  or ~/.bash_profile file.

So, open any of the two files.

$ sudo vim ~/.bashrc

Then add the line shown. Of course, this will vary according to your own individual PATH.

export PATH=$PATH:/home/linuxtechi/scripts

Save the file and exit. Then reload the changes using the source command.

$ source ~/.bashrc

At this point, we have successfully set custom $PATH on Linux. That’s all from this tutorial, your feedback and queries on this is highly welcome.

BusyBox is a handy utility tool that provides a collection of several stripped-down UNIX shell command-line tools and tiny Linux programs in a single executable file of approximately 2 MB. It runs in multiple environments such as Android, Linux, FreeBSD, and so many others. BusyBox was specifically created for embedded devices with very limited memory and storage space.

BusyBox is dubbed a Swiss Army knife tool and provides minimalistic replacements for shell utilities that you would find in GNU shellutils, fileutils, and coreutils. It can also be found in Linux distributions with a small footprint such as Alpine Linux.

In this guide, we will help you get started with Busybox on Linux. We will also learn how to install and use it effectively.

How to Install BusyBox on Linux

There are a number of ways of installing BusyBox on a Linux system. Starting with Debian / Ubuntu-based distributions, you can use the APT package manager as follows.

$ sudo apt update
$ sudo apt install busybox

For Other distributions such as ArchLinux, Fedora, RHEL, CentOS , Rocky and AlmaLinux, you will have to install it from a  prebuilt binary file. So, first, download the Busybox 64-bit binary file as follows.

$ wget https://busybox.net/downloads/binaries/1.31.0-defconfig-multiarch-musl/busybox-x86_64

Next, give it a simpler name. In my case, I renamed it to  busybox

$ mv busybox-x86_64  busybox

Then assign it execute permissions using the chmod command.

$ chmod +x busybox

To run BusyBox and check out the version , usage and currently supported functions, run the command:

$ busybox

BusyBox is also available as a Docker container image. But first, ensure that you have already installed Docker.

To pull the BusyBox image, run the command:

$ sudo docker pull busybox

To confirm the existence of the image, execute:

$ sudo docker images

Accessing BusyBox shell

To access the BusyBox shell from the BusyBox container image, simply run the command as follows.

$ sudo docker run -it --rm busybox

From here, you can start running basic Linux commands as you would normally do on a Linux terminal.

Alternatively, if you installed BusyBox from the binary file or using the APT package manager (In case of Debian and Ubuntu ) you can gain access to the shell as follows.

$ busybox sh

Trying out BusyBox

To start using BusyBox’s tools or applets you need to precede the commands with the busybox keyword while in the BusyBox shell. The syntax is:

$ busybox command

There are about 400 commands and programs that are available for use: You can check that using the command:

$ busybox --list | wc -l

To list the files and folders in the current directory path, simple run:

$ busybox ls -l

Also, you can try pinging a domain name such as google.com

$ busybox ping -c google.com

Use HTTPD webserver on BusyBox

One of the tiny Linux programs that BusyBox provides is the httpd webserver. You can confirm this by running the command:

$ busybox --list | grep httpd

To spin up a quick webserver, access the Busybox shell as the root user:

# busybox sh

And activate the webserver as shown.

# busybox httpd

You can confirm that the webserver process is running:

# ps -ef | grep httpd

Next, we are going to create a simple HTML file that we will use to test the webserver.

# busybox vi index.html
<!DOCTYPE html>
<html>
<body>
Welcome to BusyBox !
</body>
</html>

Now, open your browser and browse your server’s localhost address. This is what you will get.

Conclusion

There’s so much more you can do with BusyBox.  Hopefully, we have given you the basic knowledge that you need to get started out with BusyBox. We look forward to your feedback and queries.

Read Also: How to Create Backup with tar Command in Linux

Losing data is one of the most unsettling and harrowing experiences that any user can go through. The prospect of not ever finding precious data once it is deleted or lost is what usually inspires anxiety and leaves users helpless. Thankfully, there are a couple of tools that you can use to recover deleted files on your Linux machines. We have tried out a few data recovery tools that can help you get back your deleted files and one that stood out among the rest. This is the TestDisk data recovery tool.

TestDisk is an opensource and powerful data recovery tool that, apart from recovering your data, rebuilds and recovers boot partitions and fixes partition tables. It recovers deleted files from filesystems such as FAT, exFAT ext3, ext4, and  NTFS to mention just a few, and copies them to another location. TestDisk is a command-line data recovery tool, and this is one of the attributes that sets it apart from other data recovery tools.

In this guide, we will demonstrate how you can recover deleted files in Linux using the Test disk utility tool. We will demonstrate how TestDisk can recover deleted data from a removable USB drive in Ubuntu 20.04.

Step 1) Installing the TestDisk utility tool

The first step is to install TestDisk. To do so on Debian/Ubuntu distributions, update the package lists and install TestDisk as follows.

$ sudo apt update
$ sudo apt install testdisk

If you are running CentOS 8, RHEL 8, Rocky Linux 8, AlmaLinux 8, you need to , first , install EPEL repository.

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

Next, update the system and install Test disk as follows.

$ sudo dnf update
$ sudo dnf install testdisk

Once installed, you can verify that Testdisk is installed by checking the version of TestDisk as follows.

$ testdisk --version

From the output, you can see that we have installed TestDisk 7.1 Now, let’s simulate how you can recover deleted files from a drive.

Step 2) Recover deleted files using TestDisk

To demonstrate how you can recover files deleted from a Disk, we have deleted two files from a USB drive. The files are not even in the trash bin and our objective is to recover them.

You can have a similar setup where you have deleted a few files on your pendrive/ usb drive. To recover them, follow along.

On your terminal, run the following command to launch TestDisk

$ testdisk

Being a command-line tool, TestDisk provides a list of options as shown. By default, it highlights the most logical option to take as you get started out. So, press ENTER on the ‘create’ option.

The next screen presents you with the mounted volumes. However, to view all the disks and partitions, you need sudo permissions.

Therefore, using the arrow forward key, select ‘sudo’ and press ENTER.

NOTE: To avoid the hassle, you can simply run testdisk utility as a sudo user from the terminal.

$ sudo testdisk

Now, this time around, all the mounted partitions will be displayed. Select your preferred drive. In our case, we have selected out removable USB drive. Using the arrow forward key, select ‘Proceed’ and press ENTER.

TestDisk automatically detects the partition table type. For non-partitioned disks such as USB drives, a non-partitioned media type will be detected. So, press ENTER.

Your removable drive’s partition table will be listed as indicated. At the bottom, select ‘Undelete’

TestDisk scans your drive for undeleted files and highlights them in red.

To recover these files, you need to select them first. So, scroll down and type a full colon (:) for each selection. You will discover that each file is highlighted in green.

Now press SHIFT + C   for capital ‘C’ to copy the files. You will be prompted to select your preferred destination to save the files. In this example, we have chosen to save the files in the ‘Public’ directory. Once you have selected your directory, press ENTER.

The modification dates of the target directory will be displayed. You can choose any option, and once again, press ENTER.

TestDisk will notify you that the files have been successfully copied.

To confirm that the files have been copied, head over to the destination directory and confirm that the files exist.

The recovered files are saved with root permissions and ownership. You can change the permissions with chown command.

$ sudo chown linuxtechi 'Cover letter.txt' 'How-to-get-CLIENTS-to-say-YES.pdf'

To exit TestDisk, press ‘q’ repeatedly until your finally go back to your bash shell.

Conclusion

That was a demonstration of how you can recover deleted files in Linux using the TestDisk utility. In case you have a hard disk that you want to recover files from or cannot boot entirely, simply remove the hard disk, and attach it to a USB adapter and plug it in a Linux system with TestDisk installed. We hope you have found this guide useful. We look forward to having your feedback.

Also Read: Top 6 Screenshot Tools for Ubuntu / Linux Mint / Debian

As we know podman is an open-source daemon-less tool which provides environment to build, run and manage containers. Running containers as systemd service means that containers will automatically start when the system gets rebooted.

In this post, we will learn how to run containers as systemd service with podman on RHEL based distributions like RHEL 8, CentOS 8 and Rocky Linux 8.

Prerequisites  :

• Minimal RHEL based OS Installation.
• Stable Internet Connection
• Sudo User with root privileges

In this demonstration, I am using minimal RHEL 8.5, but these steps are also applicable for CentOS 8 and Rocky Linux 8.  Let’s jump into the steps,

Step 1) Install Podman

To install podman on RHEL 8 , run

$ sudo dnf install @container-tools -y

For CentOS 8 / Rocky Linux 8, run

$ sudo dnf install -y podman

Verify podman installation

To check whether podman is installed successfully or not, try to spin ‘hello-world’ container using beneath podman command.

$ podman -v
podman version 3.3.1
$
$ podman run 'hello-world'

Note: When we run podman first time then it prompt us to choose the registry where you want to download the container image.

Output of above command would like below:

Prefect above confirms that podman is installed successfully. Let’s move to the next step.

Step 2) Generate Systemd Service of a container

Let’s assume we want to generate systemd service for rsyslog container. First spin up rsyslog container using following podman commands,

$ podman run -d --name <Container-Name>  <Image-Name>

Note : If you wish to download rsyslog container image from a specific registry then use following syntax:

$ podman run -d --name container-name  <registry-URL>/<image-name>

In this demonstration, I have used Red hat registry. So first login to registry

$ podman login registry.access.redhat.com
Username: <Specify-User-Name>
Password: <Enter-Password>
Login Succeeded!
$

Now try to spin container using following podman command,

$ podman run -d --name rsyslog-server registry.access.redhat.com/rhel7/rsyslog
$ podman ps

Now create systemd service for rsyslog-server container, run the following commands

$ mkdir -p .config/systemd/user
$ cd .config/systemd/user/
$ podman generate systemd --name rsyslog-server --files --new
/home/sysops/.config/systemd/user/container-rsyslog-server.service
$

As we can above that systemd service is created.

For more details on ‘podman generate systemd‘ command, refer it’s help page

$ podman generate systemd --help

Step 3) Start and Enable Container Systemd Service

Run following systemctl command to start and enable systemd service for rsyslog-server container.

$ cd .config/systemd/user/
$ systemctl --user daemon-reload
$ systemctl --user enable container-rsyslog-server.service
$ systemctl --user restart container-rsyslog-server.service

Now verify the systemd service status and container status, run

$ systemctl --user status container-rsyslog-server.service
$ podman ps

Now, When the system is rebooted, container will automatically be started via its systemd service. So let’s reboot it once and verify the container service.

$ sudo reboot

Once the system is back online, then login to system and verify the container service

$ podman ps
$ cd .config/systemd/user/
$ systemctl --user status container-rsyslog-server.service

Great, this confirms that rsyslog-server container is started automatically post reboot via it’s systemd service.

That’s all from this post, I hope you have found it informative. Please do share your feedback and queries.

Also Read: How to Run Jenkins Container as Systemd Service with Docker

The usual style of executing a command on a Linux terminal is to simply run it and wait for it to gracefully exit. Once the command exits, you can then proceed to execute other commands in succession. This is what is known as running commands in the foreground. As the word suggests, you can visually see the output of the command on the terminal.

Sometimes, however, running commands in the foreground can present a set of challenges. The command can take too long to exit causing you to waste precious time and other times, it can be totally attached to the shell session leaving you stuck.

In such cases, running a command in the background is your best bet. You can send a command(s) to the background as you concurrently execute other commands in the foreground. This improves the efficiency of working on the terminal and saves you time.

In this guide, we focus on how you can run Linux shell command or script in the background.

Running shell command in background using (&) sign 

To run a command or a script to the background, terminate it with an ampersand sign (&) at the end as shown.

$ command &

NOTE: Ending the command with the ampersand sign does not detach the command from you. It merely sends it to the background of the current shell that you are using, the command will still print the output to STDOUT or STDERR which will prevent you from executing other commands on the terminal.

A better approach is to redirect the command to /dev/null and later append the ampersand sign at the end as shown

$ command &>/dev/null &

To confirm that the command was sent to the background, run the jobs command.

To terminate the background process, run the kill command followed by the PID of the process as follows. The -9 option terminates the process immediately.

$ kill -9 138314

Running shell command or script in background using nohup command

Another way you can run a command in the background is using the nohup command. The nohup command, short for no hang up, is a command that keeps a process running even after exiting the shell.

It does this by blocking the processes from receiving a SIGHUP (Signal Hang UP) signal which is a signal that is typically sent to a process when it exits the terminal.

To send a command or script in the background and keep it running, use the syntax:

$ nohup command &>/dev/null &

$ nohup shell-script.sh &>/dev/null &

For example,

$ nohup ping google.com &>/dev/null &

Again, you can verify that the command is running in the background using the command:

$ jobs

Conclusion

In this guide, we have covered two ways of running commands or shell scripts in the background. We have seen how you can run commands in the background using the & sign and the nohup command.

Read Also : Linux Zip and Unzip Command with Examples

Hello Techies, as you know Openshift provides container platform and can installed on onprem or in public cloud using different methods like IPI (Installer Provisioned Installer), UPI (User Provisioned Infrastructure) and Assisted Bare Metal installer.

In this post, we will demonstrate how to install Openshift 4.9 on bare metal nodes with UPI approach.

For the demonstration purpose, I am using KVM virtual machines. Following are my lab setup details,

Total Virtual Machines: 7

Bastion Node:  

• OS – Rocky Linux 8 / CentOS 8,
• RAM- 4GB, vPCU-4,
• Disk- 120 GB
• Network: Management N/w – (169.144.104.228), ocp internal n/w – (192.168.110.115)

Bootstrap Node:

• OS : Core OS
• RAM : 8GB
• vCPU: 4
• Disk: 40 GB
• Network: OCP Internal Network (192.168.110.116)

Control Plane 1 Node:

• OS : Core OS
• RAM : 10GB
• vCPU: 6
• Disk: 60 GB
• Network: OCP Internal Network (192.168.110.117)

Control Plane 2 Node:

• OS : Core OS
• RAM : 10GB
• vCPU: 6
• Disk: 60 GB
• Network: OCP Internal Network (192.168.110.118)

Control Plane 3 Node:

• OS : Core OS
• RAM : 10GB
• vCPU: 6
• Disk: 60 GB
• Network: OCP Internal Network (192.168.110.119)

Worker Node 1:

• OS : Core OS
• RAM : 12GB
• vCPU: 8
• Disk: 60 GB
• Network: OCP Internal Network (192.168.110.120)

Worker Node 2:

• OS : Core OS
• RAM : 12GB
• vCPU: 8
• Disk: 60 GB
• Network: OCP Internal Network (192.168.110.121)

Note: In KVM hypervisor, we have created host only network for ocp-internal.

Use the following file and commands to create host only network in KVM,

$ cat hostonly.xml
<network>
  <name>hostnet</name>
  <bridge name='virbr2' stp='on' delay='0'/>
  <ip address='192.168.110.1' netmask='255.255.255.0'>
      <range start='192.168.110.10' end='192.168.110.254'/>
  </ip>
</network>
$ sudo virsh net-define hostonly.xml
$ virsh net-start hostnet
$ virsh net-autostart hostnet
$ sudo systemctl restart libvirtd

Download Openshift Software from Red Hat portal

a)    Login to Red Hat Portal using following URL:

https://cloud.redhat.com/openshift

b)    Click on Create Cluster

c)     Choose Datacenter Tab –> Click on BareMetal

d)    Select the Installation Type as ‘UPI’ (User-provisioned infrastructure)

e)    Download the followings

• OpenShift Installer
• Pull Secret
• Command Line Interface
• RHCOS ISO
• RHCOS RAW

Let’s now jump into the installation steps of OpenShift

Step 1) Prepare Bastion Node

Create a virtual machine with resources mentioned above for bastion, you can install OS either Rocky Linux 8 or CentOS 8.  Assign the ip address from management and ocp internal network.

Similarly create bootstrap, control plane VMs and Worker VMs and attach OCP network (hostnet) to interface and note down their mac address. So, in my case following are the MAC addresses,

• Bootstrap:  52:54:00:bf:60:a3
• ocp-cp1: 52:54:00:98:49:40
• ocp-cp2: 52:54:00:fe:8a:7c
• ocp-cp3: 52:54:00:58:d3:31
• ocp-w1: 52:54:00:38:8c:dd
• ocp-w2: 52:54:00:b8:84:40

Step 2) Configure Services on bastion node

Transfer the downloaded Openshift software including the secret to bastion node under the root folder.

Extract the openshift client tar file using following tar command,

# tar xvf openshift-client-linux.tar.gz
# mv oc kubectl /usr/local/bin

Confirm client tool installation and its version by running,

# oc version
# kubectl version

Output of above command would look like below:

Extract Openshift Installer tar file,

# tar xpvf openshift-install-linux.tar.gz

README.md

openshift-install

#

Configure Zones and masquerading (SNAT)

In my bastion node, I have two lan cards, ens3 and ens8. On ens3 , external or management network is configured and on ens8, ocp internal network is configured. So, define the following zones and enable masquerading on both the zones.

# nmcli connection modify ens8 connection.zone internal
# nmcli connection modify ens3 connection.zone external
# firewall-cmd --get-active-zones
# firewall-cmd --zone=external --add-masquerade --permanent
# firewall-cmd --zone=internal --add-masquerade --permanent
# firewall-cmd --reload

Verify the zone settings by running following firewalld commands,

# firewall-cmd --list-all --zone=internal
# firewall-cmd --list-all --zone=external

Now let’s configure DNS, DHCP, Apache, HAProxy and NFS Service.

Note: For the demonstration purpose, I am using ‘linuxtechi.lan’ as the base domain.

Configure DNS Server

To install DNS server and its dependencies, run following dnf command

# dnf install bind bind-utils -y

Edit /etc/named.conf and make sure file has the following contents,

# vi /etc/named.conf

Now create forward and reverse zone file,

# mkdir /etc/named/zones
# vi /etc/named/zones/db.linuxtechi.lan

Save and exit the file.

Create reverse zone file with following entries,

# vi /etc/named/zones/db.reverse

Save and close the file and then start & enable dns service

# systemctl start named
# systemctl enable named

Allow the DNS server in firewall, run

# firewall-cmd --add-port=53/udp --zone=internal --permanent
# firewall-cmd –reload

Configure DHCP Server 

Install and configure the dhcp server, bind the mac address of bootstrap, control planes and worker nodes to their respective IPs. Run below command to install dhcp package,

# dnf install -y dhcp-server

Edit the /etc/dhcp/dhcpd.conf file and add the following contents, use the mac addresses that we have collected in step1 and specify the IP address of nodes according the DNS entries. So in my case contents of file will look like below,

[root@ocp-svc ~]# vi  /etc/dhcp/dhcpd.conf
authoritative;
ddns-update-style interim;
allow booting;
allow bootp;
allow unknown-clients;
ignore client-updates;
default-lease-time 14400;
max-lease-time 14400;
subnet 192.168.110.0 netmask 255.255.255.0 {
 option routers                  192.168.110.215; # lan
 option subnet-mask              255.255.255.0;
 option domain-name              "linuxtechi.lan";
 option domain-name-servers       192.168.110.215;
 range 192.168.110.216 192.168.110.245;
}

host ocp-bootstrap {
 hardware ethernet 52:54:00:bf:60:a3;
 fixed-address 192.168.110.216;
}

host cp1 {
 hardware ethernet 52:54:00:98:49:40;
 fixed-address 192.168.110.217;
}

host cp2 {
 hardware ethernet 52:54:00:fe:8a:7c;
 fixed-address 192.168.110.218;
}

host cp3 {
 hardware ethernet 52:54:00:58:d3:31;
 fixed-address 192.168.110.219;
}

host w1 {
 hardware ethernet 52:54:00:38:8c:dd;
 fixed-address 192.168.110.220;
}

host w2 {
 hardware ethernet 52:54:00:b8:84:40;
 fixed-address 192.168.110.221;
}

Save and close the file.

Start DHCP service and allow dhcp service for internal zone in firewall, run

[root@ocp-svc ~]# systemctl start dhcpd
[root@ocp-svc ~]# systemctl enable dhcpd
[root@ocp-svc ~]# firewall-cmd --add-service=dhcp --zone=internal --permanent
success
[root@ocp-svc ~]# firewall-cmd --reload
success
[root@ocp-svc ~]#

Configure Apache Web Server

We need apache to serve ignition and rhcos file, so let’s first install it using below command,

[root@ocp-svc ~]# dnf install -y  httpd

Change the default apache listening port from 80 to 8080 by running beneath sed command

[root@ocp-svc ~]# sed -i 's/Listen 80/Listen 0.0.0.0:8080/' /etc/httpd/conf/httpd.conf

Start and enable apache service via below command,

[root@ocp-svc ~]# systemctl start httpd
[root@ocp-svc ~]# systemctl enable httpd

Allow Apache service port (8080) for internal zone,

[root@ocp-svc ~]# firewall-cmd --add-port=8080/tcp --zone=internal --permanent
[root@ocp-svc ~]# firewall-cmd --reload

Configure HAProxy

We will use haproxy to load balance the Openshift services like ectd, ingress http & ingress https and apps like openshift console.

So, let’s first install haproxy by running following dnf command,

[root@ocp-svc ~]#  dnf install -y haproxy

Edit haproxy confile and add the following contents to it

[root@ocp-svc ~]# vi /etc/haproxy/haproxy.cfg
# Global settings
#---------------------------------------------------------------------
global
    maxconn     20000
    log         /dev/log local0 info
    chroot      /var/lib/haproxy
    pidfile     /var/run/haproxy.pid
    user        haproxy
    group       haproxy
    daemon
    # turn on stats unix socket
    stats socket /var/lib/haproxy/stats
#---------------------------------------------------------------------
# common defaults that all the 'listen' and 'backend' sections will
# use if not designated in their block
#---------------------------------------------------------------------
defaults
    log                     global
    mode                    http
    option                  httplog
    option                  dontlognull
    option http-server-close
    option redispatch
    option forwardfor       except 127.0.0.0/8
    retries                 3
    maxconn                 20000
    timeout http-request    10000ms
    timeout http-keep-alive 10000ms
    timeout check           10000ms
    timeout connect         40000ms
    timeout client          300000ms
    timeout server          300000ms
    timeout queue           50000ms

# Enable HAProxy stats
listen stats
    bind :9000
    stats uri /stats
    stats refresh 10000ms

# Kube API Server
frontend k8s_api_frontend
    bind :6443
    default_backend k8s_api_backend
    mode tcp

backend k8s_api_backend
    mode tcp
    balance source
    server      ocp-bootstrap 192.168.110.216:6443 check
    server      cp1 192.168.110.217:6443 check
    server      cp2 192.168.110.218:6443 check
    server      cp3 192.168.110.219:6443 check

# OCP Machine Config Server
frontend ocp_machine_config_server_frontend
    mode tcp
    bind :22623
    default_backend ocp_machine_config_server_backend

backend ocp_machine_config_server_backend
    mode tcp
    balance source
    server      ocp-bootstrap 192.168.110.216:22623 check
    server      cp1 192.168.110.217:22623 check
    server      cp2 192.168.110.218:22623 check
    server      cp3 192.168.110.219:22623 check

# OCP Ingress - layer 4 tcp mode for each. Ingress Controller will handle layer 7.
frontend ocp_http_ingress_frontend
    bind :80
    default_backend ocp_http_ingress_backend
    mode tcp

backend ocp_http_ingress_backend
    balance source
    mode tcp
    server cp1 192.168.110.217:80 check
    server cp2 192.168.110.218:80 check
    server cp3 192.168.110.219:80 check
    server w1 192.168.110.220:80 check
    server w2 192.168.110.221:80 check

frontend ocp_https_ingress_frontend
    bind *:443
    default_backend ocp_https_ingress_backend
    mode tcp

backend ocp_https_ingress_backend
    mode tcp
    balance source
    server cp1 192.168.110.217:443 check
    server cp2 192.168.110.218:443 check
    server cp3 192.168.110.219:443 check
    server w1 192.168.110.220:443 check
    server w2 192.168.110.221:443 check

save and exit the file.

Start and enable haproxy to make above changes into the effect

[root@ocp-svc ~]# setsebool -P haproxy_connect_any 1
[root@ocp-svc ~]# systemctl start haproxy
[root@ocp-svc ~]# systemctl enable haproxy

Allow HAProxy ports that we have defined in its configuration file in OS firewall. Run beneath commands,

[root@ocp-svc ~]# firewall-cmd --add-port=6443/tcp --zone=internal --permanent
[root@ocp-svc ~]# firewall-cmd --add-port=6443/tcp --zone=external --permanent
[root@ocp-svc ~]# firewall-cmd --add-port=22623/tcp --zone=internal --permanent
[root@ocp-svc ~]# firewall-cmd --add-service=http --zone=internal --permanent
[root@ocp-svc ~]# firewall-cmd --add-service=http --zone=external --permanent
[root@ocp-svc ~]# firewall-cmd --add-service=https --zone=internal --permanent
[root@ocp-svc ~]# firewall-cmd --add-service=https --zone=external --permanent
[root@ocp-svc ~]# firewall-cmd --add-port=9000/tcp --zone=external --permanent
[root@ocp-svc ~]# firewall-cmd --reload
[root@ocp-svc ~]#

Configure NFS Server

We need NFS server to provide the persistent storage to OpenShift registry.

Run following command to install nfs server,

[root@ocp-svc ~]# dnf install nfs-utils -y

Create following directory and set the required permissions.  This directory will be exported as NFS share,

[root@ocp-svc ~]# mkdir -p /shares/registry
[root@ocp-svc ~]# chown -R nobody:nobody /shares/registry
[root@ocp-svc ~]# chmod -R 777 /shares/registry

Now export the share by adding the following line to /etc/exports file.

[root@ocp-svc ~]# vi /etc/exports
/shares/registry  192.168.110.0/24(rw,sync,root_squash,no_subtree_check,no_wdelay)

Save and close the file and run ‘exportfs -rv’ to export the directory

[root@ocp-svc ~]# exportfs -rv
exporting 192.168.110.0/24:/shares/registry
[root@ocp-svc ~]#

Start and enable NFS service

[root@ocp-svc ~]# systemctl start nfs-server rpcbind nfs-mountd
[root@ocp-svc ~]# systemctl enable nfs-server rpcbind

Allow NFS service in OS firewall, run following commands,

[root@ocp-svc ~]# firewall-cmd --zone=internal --add-service mountd --permanent
[root@ocp-svc ~]# firewall-cmd --zone=internal --add-service rpc-bind --permanent
[root@ocp-svc ~]# firewall-cmd --zone=internal --add-service nfs --permanent
[root@ocp-svc ~]# firewall-cmd --reload

Step 3) Generate Manifests and Ignition files

To generate ignition files for bootstrap, control plane and worker nodes, refer the following steps

a)    Generate SSH keys

[root@ocp-svc ~]# ssh-keygen

These ssh keys will be used to remotely access the bootstrap, control plane and worker nodes.

b)    Create install-config.yaml file with following contents

[root@ocp-svc ~]# vi /ocp-install/install-config.yaml
apiVersion: v1
baseDomain: linuxtechi.lan        #base domain name
compute:
  - hyperthreading: Enabled
    name: worker
    replicas: 0 # Must be set to 0 for User Provisioned Installation as worker nodes will be manually deployed.
controlPlane:
  hyperthreading: Enabled
  name: master
  replicas: 3
metadata:
  name: lab # Cluster name
networking:
  clusterNetwork:
    - cidr: 10.128.0.0/14
     hostPrefix: 23
  networkType: OpenShiftSDN
  serviceNetwork:
    - 172.30.0.0/16

platform:
  none: {}
fips: false
pullSecret: '{"auths": ...}'           # Copy the pullsecret here
sshKey: "ssh-ed25519 AAAA..."          # Copy ssh public key here

In Line 23 and 24 copy contents of pull secret and public key that we generated above.

After making the changes file will look like below:

c)   Generate manifests file

Run following openshift-install command,

[root@ocp-svc ~]# ~/openshift-install create manifests --dir ~/ocp-install

Above warning message says that master nodes are schedulable, it means we can have workload on control planes (control planes will also work as worker nodes). If you wish to disable this then run following sed command,

# sed -i 's/mastersSchedulable: true/mastersSchedulable: false/' ~/ocp-install/manifests/cluster-scheduler-02-config.yml

Note: In my case, I am not disabling it.

d)    Generate Ignition and auth file

Run beneath openshift-install command,

[root@ocp-svc ~]# ~/openshift-install create ignition-configs --dir ~/ocp-install/

Output,

e)    Serve Manifests, ignition and core OS image file via web server

Create /var/www/html/ocp4 directory and copy all the files from ‘/root/ocp-install’ to ocp4.

[root@ocp-svc ~]# mkdir /var/www/html/ocp4
[root@ocp-svc ~]# cp -R ~/ocp-install/* /var/www/html/ocp4
[root@ocp-svc ~]# mv ~/rhcos-metal.x86_64.raw.gz /var/www/html/ocp4/rhcos

Set the required permissions on ocp4 directory

[root@ocp-svc ~]# chcon -R -t httpd_sys_content_t /var/www/html/ocp4/
[root@ocp-svc ~]# chown -R apache: /var/www/html/ocp4/
[root@ocp-svc ~]# chmod 755 /var/www/html/ocp4/

Verify whether these files are accessible or not via curl command

[root@ocp-svc ~]# curl 192.168.110.215:8080/ocp4/

Output should look like below

Perfect, now we are ready to start deployment.

Step 4) Start OpenShift deployment

Boot the bootstrap VM with rhcos-live ISO file. We will get the following screen

When it boots up with the ISO file, we will get the following screen,

Type coreos-installer command and hit enter

$ sudo coreos-installer install /dev/sda --inscure --image-url http://192.168.110.215:8080/ocp4/rhcos  --ignition-url http://192.168.110.215:8080/ocp4/bootstrap.ign --insecure-ignition

Once the installation is completed, we will get the following screen,

Reboot the bootstrap node so that it boots up with hard disk this time.

$ sudo reboot

Similarly boot all three-control plane nodes with RHEL Core OS (rhcos) ISO file. Once control nodes boot up then run the following command and hit enter

$ sudo coreos-installer install /dev/sda --insecure --image-url http://192.168.110.215:8080/ocp4/rhcos  --ignition-url http://192.168.110.215:8080/ocp4/master.ign --insecure-ignition

Reboot the control plane and boot it with hard disk.

Repeat this procedure for rest of control planes and monitor bootstrap process using following command.

[root@ocp-svc ~]# ~/openshift-install --dir ~/ocp-install wait-for bootstrap-complete --log-level=debug

Boot both the worker nodes with Core OS ISO file and once it boots up then run following command on the nodes

$ sudo coreos-installer install /dev/sda --insecure --image-url http://192.168.110.215:8080/ocp4/rhcos  --ignition-url http://192.168.110.215:8080/ocp4/worker.ign --insecure-ignition

Now the check status of nodes by using following commands

[root@ocp-svc ~]# export KUBECONFIG=~/ocp-install/auth/kubeconfig
[root@ocp-svc ~]# oc get nodes
NAME                     STATUS   ROLES           AGE   VERSION
cp1.lab.linuxtechi.lan   Ready    master,worker   69m   v1.22.0-rc.0+894a78b
cp2.lab.linuxtechi.lan   Ready    master,worker   66m   v1.22.0-rc.0+894a78b
cp3.lab.linuxtechi.lan   Ready    master,worker   68m   v1.22.0-rc.0+894a78b
[root@ocp-svc ~]#

Now approve all the pending CSR from worker nodes so that they can join cluster and become ready. Run following oc command to view pending CSR

[root@ocp-svc ~]# oc get csr

Run following oc command to approve the pending CSRs

[root@ocp-svc ~]# oc get csr -o go-template='{{range .items}}{{if not .status}}{{.metadata.name}}{{"\n"}}{{end}}{{end}}' | xargs oc adm certificate approve

Output of above two commands would look like below:

After couple of minutes, worker nodes should join the cluster and should be in ready state, run beneath commands to confirm the same.

[root@ocp-svc ~]# oc get nodes

Great, above confirms that both worker nodes join the cluster and in ready state.

Also check the status of bootstrap and in the output we should get the following output

[root@ocp-svc ~]# ~/openshift-install --dir ~/ocp-install wait-for bootstrap-complete --log-level=debug

Above confirms that bootstrap process is completed, and we are good to stop and delete bootstrap VM resources and bootstrap entries from haproxy file.

This conclude the article; I hope you find it informative. Please do share your feedback and comments.

Also Read : How to Setup Single Node OpenShift Cluster on RHEL 8

In a previous topic, we walked you through how create and manage KVM machines on command line. For command-line enthusiasts, this is an ideal way of creating and keeping tabs on virtual machines. For those who prefer using a graphical display, the Cockpit utility comes very much in handy.

Cockpit is a free and opensource web-based GUI that allows you to easily monitor and administer various aspects of your Linux server. It is lightweight, and resource-friendly and does not gobble up resources and neither does it reinvent subsystems or add its own tooling layer. It’s purely an on-demand service and uses your normal system login credentials.

Cockpit allows you to perform a subset of operations including:

• Configuring a firewall.

• Creating and managing user accounts.

• Configuring network settings.

• Creating and managing virtual machines.

• Updating / Upgrading software packages.

• Downloading and running containers.

• Inspecting system logs.

• Monitoring the server’s performance.

The primary focus of this guide is to manage kvm virtual machines using cockpit web console.

Prerequisites

Before you proceed any further, ensure that KVM and all of its associated packages are installed on your server. If you are running Ubuntu 20.04, check out how to install KVM on Ubuntu 20.04.

For CentOS 8 users, we also have a guide on how to install KVM on CentOS 8.x and RHEL 8.x.

Additionally, ensure that Cockpit is installed. Check out how to install Cockpit on Ubuntu 20.04 and how to install Cockpit on CentOS 8.

In this guide, we will be managing KVM Virtual machines on Ubuntu 20.04 system.

Step 1)  Install additional dependencies

To manage virtual machines, we first need to install the cockpit-machines package. This is the Cockpit user interface for virtual machines. The package communicates with the libvirt virtualization API which handles platform virtualization.

To install the cockpit-machines package on Ubuntu / Debian, run the command:

$ sudo apt install cockpit-machines

For CentOS 8.x, RHEL 8.x and Rocky Linux 8, execute the command:

$ sudo dnf  install cockpit-machines

Once installed, restart the Cockpit utility.

$ sudo systemctl restart cockpit

And check to confirm whether is it running:

$ sudo systemctl status cockpit

Step 2) Access the cockpit web console

To access Cockpit, launch your browser and browse the link shown below.

https://server-IP:9090

If you are having any trouble accessing the Cockpit web console, you need to open port  9090 on the firewall. This is the port that Cockpit listens on. If you are running a UFW firewall, execute the command:

$ sudo ufw allow 9090/tcp
$ sudo ufw reload

If it is your first time logging in, you will find a warning that you are about to browse a risky site. But worry not. The reason you are getting such a ‘warning’ is that Cockpit is encrypted using a self-signed SSL certificate which is not recognized by CA (Certificate Authority ).

To get around this restriction, click the ‘Advanced’ button.

Next, click on ‘Accept the Risk and Continue’ to proceed to the Cockpit  login  page.

At the login screen, provide your username and password and click ‘Login’ to access the cockpit dashboard.

This lands you on this ‘Overview’ section that gives you a glance at your system’s performance metrics.

Since our interest is in creating and managing virtual machines, click on the ‘Virtual machines’ option on the left sidebar as shown.

Existing virtual machines will be listed. However, since we are starting from scratch our Virtual machines section is blank. At the far right we are presented with two options ‘Create VM’ and ‘Import VM’.

How to create a new virtual machine

To create a new Virtual machine, click on the ‘Create VM’ button.

Fill out the virtual machine details including the Name of the VM, installation type, installation source, OS type, disk, and memory capacity.

Once you have selected all the options, click the ‘Create’ button to create the virtual machine.

NOTE: By default, the ‘Immediately Start VM’ option is checked. This option causes the Virtual machine to be immediately launched once you click the ‘Create’ button. If you wish to review the settings before launching your virtual machine, uncheck it and hit the ‘Create’ button.

Thereafter, cockpit will start creating the virtual machine.

Once the creation of the VM is complete, you will get an overview of the Virtual machine details as shown. Other sections that you can navigate include Usage, Disks, Network Interfaces, and Consoles.

If you are ready, simply click the ‘Install’ button as shown.

NOTE:

Before you proceed, one setting you might want to configure before installing the VM is the network interface. You can configure this to allow the VM to be accessible by other users within the network.

So, head over to the ‘Network Interfaces’ section and click on the ‘Add network Interface’ button.

Specify ‘Bridge to LAN’ and point the source to the active network interface on your PC and click on the ‘Add’ button.

The bridged network will be listed below the default network that Cockpit creates for the VM.

Finally, click the ‘install’ button to begin the installation of your operating system.

This will take you to the ‘Console’ section where you have an option of selecting the Console type. The default selection is VNC.

You have the luxury of also selecting between Desktop Viewer and Serial Console. I’d recommend selecting the Desktop viewer which is more user-friendly and easier to use to access the VM graphically.

Once you have selected the ‘Desktop Viewer’ option, you will get some details on the IP and the port to use. Desktop Viewer uses the Spice GUI connection.

To make a connection, search for and launch the remote viewer which is provided by virt-viewer package.

Once launched, enter the URL as provided and click connect.

The Remote viewer will open the Virtual machine and from here, you can proceed with the installation of your operating system.

Import a Virtual machine

To import a VM, simply click the ‘Import VM’ tab. On the pop-up GUI that appears, be sure to fill in the name of the VM, select the existing disk image location, OS type, and memory capacity. Finally hit the ‘Import’ Button.

Fill out the details such as the name of the VM, Installation source, OS, and memory, and click ‘Import’.

Configure KVM Storage Pools

A storage pool is simply a directory or storage device that is managed by the libvirtd daemon. Storage pools comprise storage volumes that either accommodate virtual machine images or are directly connected to VMs as additional block storage.

By default, there are two storage pools listed when you create a VM. To list them, click on the ‘Storage Pools’ tab.

The ‘default’ storage pool stores all virtual machine images in the /var/lib/libvirt/images directory.

Click on the ‘default’ storage pool, to reveal detailed information such as the Target path.

The other storage pool points to the location of the disk image that you used to create the VM. In my case, this is the ‘Downloads’ directory in my home directory.

To create a new storage pool click on ‘Create Storage Pool’.

Next, fill in all the essential details. A storage pool can take various  forms such as:

• Filesystem directory
• Network file system
• iSCSI target / iSCSI directory target
• Physical disk device
• LVM volume group

Configure KVM Networking

In addition, you can create virtual networks in KVM. Simply click on the ‘Network’ option.

This will list all the available virtual networks. By default, KVM creates a default virtual network called virbr0 which lets virtual machines communicate with each other.

The default Virtual network provides it’s own subnet, and DHCP IP range as shown. You can add as many virtual network as per your preference. Other options in network management include deactivating and deleting a network.

Restart / Pause / Shutdown a virtual machine

Lastly, you can control the running state of your virtual machines. You can restart, Pause, Shutdown and even delete your virtual machine.

Under the ‘Restart’ option, you get 2  other sub-options:

• Restart
• Force Restart

The ‘Restart’ option performs the usual restart of the VM while the ‘Force Restart’ immediately restarts the VM.

Under the ‘Shutdown’ option, you get 3 sub-options:

• Shut Down
• Force Shut Down
• Send Non-Maskable interrupt

The ‘Shut Down’ option performs a graceful shutdown while the  ‘Force Shut Down’ option instantly powers off the virtual machine without giving it time to gracefully shutdown.

A Non-Maskable Interrupt ( NMI ) is a signal sent to a vm which it cannot ignore. It comes in handy when the VM is not responsive to a Shutdown, or restart signal. The NMI causes the VM’s kernel to panic and generate a memory dump which is then used for debugging.

Closing Thoughts:

As you have seen, creating and managing virtual machines using cockpit is a walk in the part. You simply rely on the graphical interface to perform all operations, and not once will you be required to run any commands on the console. Cockpit provides you with the relevant tools and features to easily manage various aspects of your virtual machine.

We hope that this guide was beneficial as you get started in managing virtual machines using Cockpit.

KVM (Kernel based Virtual Machine) is an opensource virtualization technology built for Linux machines. It comprises a kernel module – kvm.ko which provides the core virtualization platform and a processor-specific module ( kvm-intel.ko for Intel processors or kvm-amd.ko for AMD processors ).

There are two ways of creating virtual machines using KVM. You can leverage the virt-manager tool which is an X11 server that provides a GUI interface for creating virtual machines. Additionally, you can use the command line to create a virtual machine by defining various parameters associated with the virtual machine you want to deploy.

We already have an elaborate guide on how to install KVM virtual machines using GUI on Ubuntu. In this guide, we take a different approach and demonstrate how you can create a KVM virtual machine from the command line interface. We are using Ubuntu 18.04, but this should work across all Linux distributions.

Step 1) Check whether Virtualization is enabled

As we get started out, we need to check if your system supports Virtualization technology. To achieve this, run the following command.

$ egrep -c '(vmx|svm)' /proc/cpuinfo

If your system supports virtualization technology, you should get an output greater than 0.

Next, confirm if your system can run KVM virtual machines.

$ kvm-ok

If you get an error on the screen, it implies that the kvm-ok utility is not yet installed. Therefore, install the following command to install the kvm-ok utility.

$ sudo apt install -y cpu-checker

Now run the kvm-ok command to confirm whether KVM virtualization is supported.

Step 2) Install KVM, Qemu, virt-manager & libvirtd daemon

The next step is to install KVM and associated packages. So, run the command:

$ sudo apt install -y qemu qemu-kvm libvirt-daemon libvirt-clients bridge-utils virt-manager

The command installs the following packages.

• qemu-kvm –  This is the main KVM package that provides virtualization support.
• libvirt – Includes the libvirtd daemon which supports creation and management of virtual machines.
• libvirt-client – This package provides the virsh utility used for interacting with virtual machines.
• virt-install – A utility that helps you to create virtual machines and install OS on those virtual machines from command line.
• virt-viewer – A utility that displays the graphical view for the virtual machine.

Once installed, we need to confirm if the required kvm modules are loaded. Therefore, run the command:

$ lsmod | grep kvm

Additionally, confirm that the libvirtd daemon is running as follows.

$ sudo systemctl status libvirtd.service

Perfect! All the prerequisites are in place. Let’s now proceed and install a virtual machine.

Step 3)  Create a virtual machine from the command line

We are going to install a Debian virtual machine using a Debian 11 iso image located in the Downloads folder in the home directory.

To create the new virtual machine, we will run the following command.

$ sudo virt-install --name=debian-vm \
--os-type=Linux \
--os-variant=debian9 \
--vcpu=2 \
--ram=2048 \
--disk path=/var/lib/libvirt/images/Debian.img,size=15 \
--graphics spice \
--location=/home/james/Downloads/debian-11.1.0-amd64-DVD-1.iso \
--network bridge:virbr0

Let’s take a minute and analyze this command:

• The –name attribute denotes the name of the virtual machine. Feel free to give it an arbitrary name.
• The  –os-type directive specifies the type of Operating system – in this case Linux.
• The  –os-variant option specifies the operating system releases.

NOTE:   KVM provides predefined  –os-variant options and you just cannot make up your own. To check the various variants that are supported, run the osinfo-query os command. This lists all the possible Operating systems and the supported variants. Also, note that the variants my not coincide with your latest Linux release. In this case, I’m using  debian9 instead of debian11 since the latter is not provided by KVM as one of the variant options.

• Moving on, the –vcpu parameter specifies the number of CPU cores to be allocated to the virtual machine.
• The –ram option specifies the amount of RAM in Megabytes to be allocated.
• The –disk path option defines the path of the virtual machine image. The –disk directive is the disk space of the VM in Gigabytes.
• The –graphics option specifies the graphical tool for interactive installation, in this example, we are using spice.
• The –location option points to the location of the ISO image
• Lastly, the –network bridge directive specifies the interface to be used by the virtual machine.

If all goes well, you should get some output as indicated in the image above followed by a virt viewer pop-up of the virtual machine awaiting installation.

In our case, we are installing Debian 11 and this is the initial installation screen. We proceeded with the installation until the very end.

Step 4) Interacting with virtual machines

The virsh utility is a component that is used to interact with virtual machines on the command-line. For instance, to view the currently running virtual machines, execute the command:

$ virsh list

To list all the virtual machines including those that are powered off, append the –all option.

$ virsh list --all

To shut down a virtual machine use the syntax:

$ sudo virsh shutdown vm_name

For example, to turn off our virtual machine, the command will be:

$ sudo virsh shutdown debian-vm

To start or power on the virtual machine, run:

$ sudo virsh start debian-vm

To reboot the machine, run the command:

$ sudo virsh reboot debian-vm

To destroy or forcefully power off virtual machine, run:

$ sudo virsh destroy debian-vm

To delete or removing virtual machine along with its disk file, run

a)   First shutdown the virtual machine

b)   Delete the virtual machine along with its associated storage file, run

$ sudo virsh undefine –domain <Virtual-Machine-Name> –remove-all-storage

Example:

$ sudo virsh undefine --domain debian-vm --remove-all-storage

Closing Thoughts :

This was a guide on how to install a virtual machine using KVM  on the command line. We have highlighted some of the salient options to specify to ensure the successful deployment of the virtual machine. We also went a step further and demonstrated how to interact with the virtual machine on command-line using the virsh utility. Those were just a few options, there are quite several of them.

Docker is an open platform tool which provides container run time environment. With the help of docker, developers can build, ship and run their code as a container anywhere like on-prem or public cloud. Docker makes use of OS-level virtualization to spin up the containers.  The host on which docker is installed and containers are spun are called as ‘Docker Engine’.

In this post, we will cover how to install Docker Engine (Community Edition) on Debian 11 (Bullseye) step by step.

Prerequisite of Docker

• Minimal Debian 11 Installation
• 64-bit System
• Stable Internet Connection
• User with sudo rights

Let’s jump into the installation steps of Docker on Debian 11

Step 1) Update Package Index and Install dependencies

Login to Debian 11 system, open the terminal and run below command to update package index

$ sudo apt update

Now, run below apt command to install docker dependencies,

$ sudo apt install apt-transport-https ca-certificates curl gnupg lsb-release -y

Step 2) Configure Docker Repository

To configure docker repository, let’s first add Docker’s GPG key via following curl command.

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

Execute below echo command to configure official docker repository.

$ echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/debian \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Output of above command,

Step 3) Install Docker Engine

Run the following apt commands to install docker engine,

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

Output of above apt commands would look like below,

Once the docker is installed successfully, verify its version and service status by running,

$ sudo docker version

$ sudo systemctl status docker

Above output confirm that, docker service is up and running. In case docker service is not running then try to start its service using beneath command.

$ sudo systemctl start docker

Step 4) Verify Docker Installation

To verify the docker installation, try to spin up ‘hello-world’ container and see whether informational message is displayed or not.

To spin up ‘hello-world’ container, run below docker command with sudo

$ sudo docker run hello-world

Above informational message confirms that docker is installed and working properly.

Step 5) Allow Local User to Run Docker Command

To allow local user to run docker commands without sudo, add the user to docker group (secondary group) using usermod command.

$ sudo usermod -aG docker linuxtechi

Note: Replace the username in above command as per your setup and also don’t forget to logout & login to make the changes into the effect.

Removal of Docker Engine

In case you are done with docker testing and want to remove docker from your system then run following commands to uninstall it,

$ sudo apt purge -y docker-ce docker-ce-cli containerd.io
$ sudo rm -rf /var/lib/docker
$ sudo rm -rf /var/lib/containerd

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