In this blog post, we will explain how to install Kubernetes cluster on Rocky Linux 9 or AlmaLinux 9 with Kubeadm utility.

Kubernetes, often referred to as K8s, is an open-source container orchestration platform. With its robust capabilities for automating deployment, scaling, and managing containerized applications, Kubernetes has become the go-to solution for DevOps teams worldwide.

Prerequisites

• A fresh Installation of Rocky Linux 9 or AlmaLinux 9
• Sudo user with admin rights
• Minimum of 2 GB RAM, 2 vCPUs and 20 GB Disk Space
• A reliable Internet Connection

Lab Setup

We have used three Virtual machines with following specification.

• K8s-master01 –  192.168.1.190
• K8s-worker01 –  192.168.1.191
• K8s-worker02 –  192.168.1.192
• Sysops as sudo user on each node

Without any further delay, lets deep dive into Kubernetes installation steps.

Step 1: Set Hostname and Update Hosts file

Login or ssh each machine and run hostnamectl commands to set their respective hostname.

$ sudo hostnamectl set-hostname “k8s-master01” && exec bash
$ sudo hostnamectl set-hostname “k8s-worker01” && exec bash
$ sudo hostnamectl set-hostname “k8s-worker02” && exec bash

Add the following entries in /etc/hosts file on each node.

192.168.1.190   k8s-master01
192.168.1.191   k8s-worker01
192.168.1.192   k8s-worker02

Step 2: Disable Swap Space on Each Node

For kubelet to work smoothly, we must disable swap space on all the nodes. Run beneath command,

$ sudo swapoff -a
$ sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

Step 3: Adjust SELinux and Firewall Rules for Kubernetes

Set SELinux mode as permissive on all the nodes using following commands,

$ sudo setenforce 0
$ sudo sed -i --follow-symlinks 's/SELINUX=enforcing/SELINUX=permissive/g' /etc/sysconfig/selinux

On the master node, allow following ports in the firewall.

$ sudo firewall-cmd --permanent --add-port={6443,2379,2380,10250,10251,10252,10257,10259,179}/tcp
$ sudo firewall-cmd --permanent --add-port=4789/udp
$ sudo firewall-cmd --reload

On the Worker Nodes, allow beneath ports in the firewall,

$ sudo firewall-cmd --permanent --add-port={179,10250,30000-32767}/tcp
$ sudo firewall-cmd --permanent --add-port=4789/udp
$ sudo firewall-cmd --reload

Step 4: Add Kernel Modules and Parameters

For kuberetes cluster, we must add the overlay and br_netfilter kernel modules on all the nodes.

Create a file and add following content to it,

$ sudo tee /etc/modules-load.d/containerd.conf <<EOF
overlay
br_netfilter
EOF

In order to load above modules, run

$ sudo modprobe overlay
$ sudo modprobe br_netfilter

Next, add the following kernel parameters, create a file and with following content,

$ sudo vi /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables  = 1
net.ipv4.ip_forward                 = 1
net.bridge.bridge-nf-call-ip6tables = 1

Save & close the file.

Now add these parameters by running below command

$ sudo sysctl --system

Step 5: Install Conatinerd Runtime

Kubernetes requires a container runtime, and one of the most popular choices is containerd. But It is not available in the default package repositories of Rocky Linux or AlmaLinux, so add the following docker repo on all the nodes.

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

Now, run following dnf command to install containerd on all the nodes.

$ sudo dnf install containerd.io -y

Configure containerd so that it will use systemdcgroup, execute the following commands on each node.

$ containerd config default | sudo tee /etc/containerd/config.toml >/dev/null 2>&1
$ sudo sed -i 's/SystemdCgroup \= false/SystemdCgroup \= true/g' /etc/containerd/config.toml

Restart and enable containerd service using beneath commands,

$ sudo systemctl restart containerd
$ sudo systemctl enable containerd

Verify conatinerd service status, run

$ sudo systemctl status containerd

Step 6: Install Kubernetes tools

Kubernetes tools like Kubeadm, kubectl and kubelet are not available in the default package repositories of Rocky Linux 9 or AlmaLinux 9. So, to install these tools, add the following repository on all the nodes.

$ cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://pkgs.k8s.io/core:/stable:/v1.28/rpm/
enabled=1
gpgcheck=1
gpgkey=https://pkgs.k8s.io/core:/stable:/v1.28/rpm/repodata/repomd.xml.key
exclude=kubelet kubeadm kubectl cri-tools kubernetes-cni
EOF

Note: At time of writing this post, Kubernetes 1.28 version was available, that’s why I have mentioned v1.28 while adding the repo.

Next, install Kubernetes tools by running following dnf command,

$ sudo yum install -y kubelet kubeadm kubectl --disableexcludes=kubernetes

After installing Kubernetes tools, start the kubelet service on each node.

$ sudo systemctl enable --now kubelet

Step 7: Install Kubernetes Cluster on Rocky Linux 9 / Alma Linux 9

Now, we are all set to install Kubernetes cluster. Run beneath Kubeadm command to initialize the Kubernetes cluster from the master node.

$ sudo kubeadm init --control-plane-endpoint=k8s-master01

Once above command is executed successfully, we will get following output,

From the output above make a note of the command which will be executed on the worker nodes to join the Kubernetes cluster.

To start interacting with Kubernetes cluster, run the following commands on the master node.

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

Next, join the worker nodes to the cluster, run following Kubeadm command from the worker nodes.

$ kubeadm join k8s-master01:6443 --token 69s57o.3muk7ey0j0zknw69 \
  --discovery-token-ca-cert-hash sha256:8000dff8e803e2bf687f3dae80b4bc1376e5bd770e7a752a3c9fa314de6449fe

Output from Worker01

Output from Worker02

Now, head back to master node and run kubectl command to verify the nodes status.

$ kubectl get nodes

Output above shows that nodes is “NoteRead”, so to make the nodes status “Ready”, install Calico network addon or plugin in the next step.

Step 8: Install Calico Network Addon

Calico network addon is required on Kubernetes cluster to enable communication between pods, to make DNS service function with the cluster and to make the nodes status as Ready.

In order to install calico CNI (Container Network Interface) addon, run following kubectl commands from the master node only.

$ kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.26.1/manifests/calico.yaml

Verify calico pods status,

$ kubectl get pods -n kube-system

Next, verify the nodes status, this time nodes status should be in Ready State.

$ kubectl get nodes

Perfect, output above confirms nodes are in Ready state and can handle workload. Let’s test our Kubernetes installation the next step.

Step 9: Test Kubernetes Cluster Installation

To test Kubernetes cluster installation, let’s try to deploy nginx based application using deployment. Run following kubectl commands,

$ kubectl create deployment web-app01 --image nginx --replicas 2
$ kubectl expose deployment web-app01 --type NodePort --port 80
$ kubectl get deployment web-app01
$ kubectl get pods
$ kubectl get svc web-app01

Try to access the application using nodeport “31121”, run following curl command,

$ curl k8s-worker01:31121

Great, above confirms that we can access our application web page. This also confirms that our Kubernetes cluster has been installed successfully.

That’s all from this post, we believe that you have found informative and useful. If you have any queries and feedback, please do post it in below comments section.

Also Read: How to Install and Access Kubernetes Dashboard Step-by-Step

In this post, we will cover how to create a virtual machine in Proxmox VE using the web interface (UI).

Proxmox Virtual Environment (VE) is a versatile and powerful platform that allows you to manage virtual machines (VMs) and containers from a centralized web interface. Whether you are a system administrator, a developer, or just a virtualization enthusiast, Proxmox VE provides a user-friendly and feature-rich environment to create and manage VMs effortlessly.

Prerequisites

• A Proxmox VE installation running and accessible through a web browser.
• Administrative access to the Proxmox VE web interface.
• Familiarity with basic virtualization concepts.

1) Login to Proxmox VE Web Interface

Open your preferred web browser and enter the URL of your Proxmox VE server. Typically, this will be in the format `https://your_proxmox_server_ip:8006`. Enter the credentials and login to web interface,

2) Upload ISO Image

We  will create a Rocky Linux VM, so I have uploaded Rocky Linux 9.2 ISO file as show below,

Choose “local (pv01)“–> ISO Image –> Select the ISO File and then click on Upload.

3) Create a New Virtual Machine in Proxmox VE

To create a new virtual machine, click the “Create VM” button located at the top of Web Interface.

It will start a Virtual machine wizard, follow the steps,

General Settings

• Enter a unique name for your VM.
• Choose the Node (physical server) where the VM will run.
• Set the VM ID (usually auto-generated unless you have a specific ID in mind).

Click on Next

OS Image Selection

• Choose the ISO image for the operating system you want to install on the VM.
• Select Storage as Local, Guest OS type as Linux and Version (6.x-2.6 kernel)

System

Under system tab, select the Graphic card, BIOS and SCSI Controller for the VM.

Click on Next

Hard Disk

Specify disk size for your VM and storage as local-lvm.

CPU & Memory

In CPU tab, select the socket and number cores and CPU type.

In memory tab, specify the memory (MiB) for the VM.

Click Next,

Network

In this tab, select the network for the VM. Choose vmbr0 as Bridge and Model as “Virtio paravirtualized”

Note: Linux bridge vmbr0 created automatically during Proxmox installation. VM interface will be mapped to this bridge.

Click Next

Confirm

On this tab, review the VM details and click on Finish to start creating the virtual machine.

4) Install the Operating System

Your new VM will appear under host pv01, so to begin the installation, select the VM and click the “Start” button and then click on Console.

Follow the screen instructions and complete OS installation.

Great, above confirms that OS installation is completed, click on “Reboot System” to restart the VM.

After the reboot we will get VM console, login the VM using credentials that you created during the installation and start using the VM.

5) Start and Manage Your VM

After completing the installation, your VM will be listed in the Virtual Machine Manager. You can start, stop, restart and pause the VM.

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

The step-by-step guide on this page will show you how to Install Proxmox VE on bare metal.

Proxmox Virtual Environment (VE) is a powerful, open-source platform for managing virtual machines (VMs) and containers. It combines two virtualization technologies, KVM (Kernel-based Virtual Machine) for virtual machines and LXC (Linux Containers) for lightweight containerization. Installing Proxmox VE on bare metal provides a solid foundation for building a virtualization infrastructure that can efficiently manage your workloads.

Prerequisites

• A bare metal server with hardware virtualization support (Intel VT-x/AMD-V).
• A bootable USB drive with the Proxmox VE ISO image.
• Access to the server’s management interface (e.g., IPMI, iDRAC, or a physical console).
• Basic knowledge of Linux commands.

1) Download Proxmox VE ISO Installer

Browse the URL https://www.proxmox.com/en/downloads/proxmox-virtual-environment/iso and download latest proxmox VE ISO installer. At the time of write this post, “proxmox ve 8.0.2” is available.

Once the download is completed, burn the ISO file into USB flash drive and make it bootable. In Windows environment, use Rufus software to create bootable USB drive from ISO file. In Linux, use the following,

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

2) Boot from the Proxmox VE Installer

Attach bootable USB drive to the server and go to the server’s BIOS or UEFI settings and ensure that the USB drive is set as the primary boot device.

Once the server boots from the USB drive, you will see the Proxmox VE boot menu. Choose “Install Proxmox VE (Graphical)” option and hit Enter.

3) Accept End User License Agreement

In this step, you will be prompted to accept end user license agreement,

Read the agreement and click on “I agree”

4) Choose Installation Target Disk

The installer will ask you to choose the target disk on which proxmox will be installed. By default, installer will format the file system with ext4, if wish to change the file system type then click on “Options” as shown below.

Select the target disk and file system and then click on Next to proceed further.

5) Set Location and Time Zone

Set your preferred Location (Country), Time zone and Keyboard layout.

Click on Next

6) Create Admin Password and Email Address

Create a password for the Proxmox VE web interface. This password will be used to log in to the Proxmox VE web management console. Also specify the valid email address where all notification will be sent.

Click Next

7) Network Configuration

Next, you’ll need to configure the network settings for Proxmox VE. Set FQDN, static IP address, subnet mask, gateway, and DNS server. Ensure that you specify the correct network configuration according to your environment.

Click Next to proceed further with the installation.

8) Begin Proxmox VE Installation

Review your installation settings one last time.

If everything looks correct, click on “Install“. The installation process will begin, and Proxmox VE will be installed on your bare metal server.

Once the installation is complete, server will be rebooted automatically. Don’t forget to remove the USB drive and change boot medium from BIOS settings so that Proxmox VE will boot from the installed disk.

9) Access the Proxmox VE Web Interface

Open a web browser and navigate to the IP address you assigned in Step 7, followed by port 8006 (e.g., http://your_server_ip:8006).

While accessing the Web interface, we will get following screen, So Accept the Risk and Continue as we are using self-signed certificates for web interface.

Next, log in with the username “root” and the password you set in Step 6.

Click on Login, this will take us to dashboard (Web UI). You will get a warning message like “No Valid Subscription”, Choose OK to ignore the warning,

Finally, we will get the following Proxmox VE Web UI.

Great, this confirms that Proxmox VE has been installed successfully on your server.

As we don’t have valid subscription, let’s change its enterprise package repository to community repository in the following step.

10) Change Proxmox Enterprise Repository to Community

From the Web UI, Select the host (pv01) under the Datacenter and then click on console,

Now, go to directory “/etc/apt/sources.list.d/”

# cd /etc/apt/sources.list.d/

Edit ceph.list file, comment out the enterprise repo and add community repo for ceph,

# vi ceph.list

#deb https://enterprise.proxmox.com/debian/ceph-quincy bookworm enterprise
deb http://download.proxmox.com/debian/ceph-quincy bookworm no-subscription

save and close the file

Next edit the ‘pve-enterprise.list’ and comment out enterprise proxmox repo and add community repo url.

# vi pve-enterprise.list

#deb https://enterprise.proxmox.com/debian/pve bookworm pve-enterprise
deb http://download.proxmox.com/debian/pve bookworm pve-no-subscription

save and quit the file.

Update the Repository index and install all available updates,

# apt update
# apt update -y

Once all the updates are installed then reboot the system once using following command,

# reboot

That’s all from this guide, I hope you have found it informative and useful. If you have encountered any issue during installation, kindly do post it in below comments section.

Conclusion

You have successfully installed Proxmox VE on bare metal. This powerful virtualization platform opens up a world of possibilities for managing virtual machines and containers. Explore the Proxmox VE web interface and start creating VMs and containers to meet your specific needs. Proxmox VE’s flexibility and robust features make it an excellent choice for virtualization enthusiasts and professionals alike.

In this blog post, we will show you how to assign static ip address on Debian 12.

In the world of Linux, Debian remains one of the most popular distributions, known for its stability and versatility. One essential aspect of managing a Linux system is configuring network settings. Whether you’re setting up a server or just want a consistent IP address for your desktop, assigning a static IP address on Debian 12 can be a crucial task.

Prerequisites

• Pre-Installed Debian 12
• Sudo User with admin rights

There are different methods through we can assign static ip address on Debian 12.

Method1: Assign Static IP Address on Debian 12 Using GUI

Login to your Debian Desktop environment, From Activity –> Search Settings –> Choose Network

Click on Wired Settings and then we will get the following window,

Note: To disable IPv6, go to IPv6 tab and choose ‘Disable’ option

Click on IPv4 Tab

Above window shows that Automatic DHCP is enabled, so to Assign Static IP choose ‘Manual’ and then specify the IP details like IP address, netmask, gateway and dns server IP.

Important Note: To Specify the dns server IP first disable the automatic dns IP by toggling it.

Click on Apply to save the changes.

Now, disable and enable the interface by toggling it so that new IP address is mapped to the Interface.

Now again click on wired settings to verify whether the new static ip address is assigned or not.

Perfect, above confirms that new static IP address is assigned successfully.

Method2: Assign Static IP Address on Debian 12 From Command Line

Open the terminal, check your current network configuration. You can do this by running the following ip command,

$ ip add show

This will display a list of network interfaces on your system. Note down the name of the interface you want to assign a static IP address to (typically, it’s ‘enp0s3‘ for Ethernet).

Next, run nmcli command to get connection name,

$ nmcli connection

Once we get the connection name, run below nmcli command to assign static ipv4 address,

Syntax:

$ nmcli con mod  ‘connection-name’ ipv4.address  <IP-Address>

$ sudo nmcli connection modify 'Wired connection 1' ipv4.address 192.168.1.240/24

Set the gateway by running below

$ sudo nmcli connection modify 'Wired connection 1' ipv4.gateway 192.168.1.1

Change Configuration from DHCP to Manual , so that IP will be static and persistent, run

$ sudo nmcli connection modify 'Wired connection 1' ipv4.method manual

Set the DNS server IP by running below command,

$ sudo nmcli connection modify 'Wired connection 1' ipv4.dns '8.8.8.8'

Disable and enable the connection so that above changes come into the effect.

$ sudo nmcli connection down 'Wired connection 1'
$ sudo nmcli connection up 'Wired connection 1'

Now run IP Command to check IP address,

$ ip add show enp0s3

Output of above commands would look like below:

Perfect, above output confirms that static IP address has been assigned successfully on enp0s3 interface.

Assign Static IP Address on Minimal Installed Debian 12

Whenever we install minimal Debian 12 then we will have only the CLI console and don’t have any nmcli utility. So, to assin static ip address we must edit the file ‘/etc/network/interfaces’.

$ cat /etc/network/interfaces

Edit the file and set the static IP address as shown below,

$ sudo vi /etc/network/interfaces

Replace the line ‘allow-htplug enp0s3’ with ‘auto enp0s3‘ and change dhcp parameter to static.  Below is my sample file, change interface name and ip details as per your environment.

auto enp0s3
iface enp0s3 inet static
        address 192.168.1.240/24
        network 192.168.1.0
        broadcast 192.168.1.255
        gateway 192.168.1.1
        dns-nameservers 8.8.8.8

save & close the file.

To make above changes into the effect the restart the network service

$ sudo systemctl restart networking.service

Now, run ip command to verify the ip address,

$ ip add show

Output,

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

Conclusion

Assigning a static IP address on Debian 12 is a straightforward process that can greatly benefit your network stability and ease of access. By following the steps outlined in this guide, you can ensure that your Debian 12 system always has a consistent IP address, making it easier to manage and access your resources. Whether you’re configuring a server or just prefer having a stable address for your desktop, Debian 12 provides a user-friendly environment for all your networking needs.

Also Read: How to Install Kubernetes Cluster on Debian 11 with Kubeadm

In this blog post, we will show you how to install VirtualBox Guest Additions on Ubuntu 22.04.

Running Ubuntu 22.04 as a virtual machine within Oracle VirtualBox is a common scenario for many users. While VirtualBox provides a seamless virtualization experience, you can further improve it by installing VirtualBox Guest Additions. These additions offer enhanced functionality and performance, including better display resolution, seamless mouse integration, and improved file sharing between your host and guest OS.

Prerequisites

• Pre-Installed Ubuntu 22.04 VM in VirtualBox
• A Regular User with sudo rights
• Stable Internet connectivity

Without any further delay, let deep dive into VirtualBox Guest Additions on Ubuntu 22.04

1) Start Your Ubuntu Virtual Machine

Before we dive into the installation process, make sure your Ubuntu virtual machine is up and running in VirtualBox.

2) Install Required Packages

Before you can install VirtualBox Guest Additions, you’ll need some essential packages. Run the following command in your terminal to install them:

$ sudo apt update
$ sudo apt install build-essential linux-headers-$(uname -r) -y

These packages are necessary for building and installing the VirtualBox Guest Additions modules.

3) Mount the VirtualBox Guest Additions CD Image

In VirtualBox, go to the “Devices” menu at the top of the virtual machine window and select “Insert Guest Additions CD Image.” This action virtually mount the Guest Additions CD image into your virtual machine.

4) Install VirtualBox Guest Additions

Now, let’s navigate to the directory containing the VirtualBox Guest Additions CD image. In your terminal, run:

$ cd /media/linuxtechi/VBox_GAs_7.0.4/

This command takes you to the mounted CD image directory. Note that the directory name may vary slightly depending on your VirtualBox version.

To install VirtualBox Guest Additions, run the following command:

$ sudo ./VBoxLinuxAdditions.run

This script will compile and install the necessary modules for improved integration between your host and guest systems.

5) Reboot Your Virtual Machine

After the installation is complete, it’s essential to reboot your virtual machine to ensure that the VirtualBox Guest Additions are fully integrated:

$ sudo reboot

6) Verify Guest Additions Installation

Once your virtual machine restarts, you can verify the successful installation of VirtualBox Guest Additions by checking for improved functionality, such as automatic screen resizing and seamless mouse integration.

Conclusion

By installing VirtualBox Guest Additions on your Ubuntu 22.04 virtual machine, you’ve enhanced your virtualization experience, making it more seamless and user-friendly. You can now enjoy features like better display resolution, automatic mouse integration, and improved file sharing between your host and guest systems. These additions make managing and using virtual machines in VirtualBox a more efficient and enjoyable process.

In this post, we will show you how to install Kali Linux on Windows 11 using WSL. 

A while back, running a virtual machine was the only way of running another operating system, such as Linux, inside Windows. The drawback of virtual machines is that they are associated with high resource usage which in most cases slows down applications and services on the host especially if the underlying host has low computing specifications.

The Windows Subsystem for Linux, commonly abbreviated as WSL, is an abstraction layer that lets you run a Linux environment, including its utilities and tools, directly on Windows. It does this without the resource overhead of traditional virtual machines or having to configure a dual-boot setup. WSL was first released in 2016. WSL 2 is the current version and provides performance improvements and other enhancements to boost system performance.

Prerequisites

For this to work, ensure that your system meets the following requirements:

• Virtualization needs to be enabled on your BIOS.
• Must be running x64 system Version 1903 or higher, with Build 18362 or higher.

Without much ado, let’s get started.

1) Enable Windows Subsystem for Linux (WSL)

The first step is to enable the WSL feature on your Windows system. To do this, launch Windows PowerShell as the Administrator.

Next, run the following command on the terminal to enable the WSL feature.

dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart

This takes a minute or two to complete.

2) Enable Virtual Machine Platform Feature

The virtual Machine Platform feature is a feature that allows you to emulate other operating systems and is a prerequisite for specific features to run such as the WSL.

Still on Powershell, run the following command to enable the virtual machine platform feature.

dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart

In addition, (although not a requirement) consider setting WSL version 2 as the default version.

wsl --set-default-version 2

3) Install the Linux Kernel Update package.

To avoid running into errors while running Kali Linux, it’s recommended to install the Linux Kernel Update Package for WSL. Therefore click on this link to download the WSL2 Linux kernel update package for x64 machines.

Once you have downloaded the installer, run it by double-clicking on it.

This opens the WSL setup wizard as shown. Click ‘Next’ and accept the default selections.

4) Install Kali Linux on Windows using WSL

All our ducks are in a row as far as the requisite features needed are concerned. The next step is to install Kali Linux. So, head over to the Microsoft store and search for the ‘Kali Linux’ app.

Click the ‘Get’ button.

The download of the App, which is about 237MB will begin and the progress will be indicated as shown.

Once the download is complete, click ‘Open’.

This opens a terminal window that prompts you to provide a username and password for your user account.  Once you are done, you’ll automatically be logged in and prompted with a bash in Kali Linux.

You can verify the version of Kali Linux using the command:

$ cat /etc/os-release

5) Install Win-Kex Utility to Enable GUI (Optional)

To make the most out of your Kali Linux instance, installing a GUI is recommended. To do so, install the Win-Kex package which provides a desktop experience for Kali Linux in WSL 2.

$ sudo apt update
$ sudo apt install kali-win-kex

The package is quite big (approximately 2.3G) and takes quite some time to install.

Once installed, launch the GUI interface as shown.

$ kex --win -s

Provide the password and confirm it. When prompted to enter a view-only password, type ‘n’ and hit ENTER.

This immediately launches the Kali Linux GUI on your screen as shown.

The Win-Kex utility provides three modes:

• Window mode: Starts Kali Linux in a dedicated window.
• Enhanced session mode: Uses RDP protocol to provide a richer UI experience.
• Seamless mode: Shares the Windows desktop between Windows and Kali applications and menus.

For more information about the Win-Kex utility, check out the Kali Linux Win-Kex documentation.

Conclusion

And there you go. In this guide, we have demonstrated how to install Kali Linux on Windows 11 using WSL 2. Your feedback on this guide is welcome.

In a world where cross-platform connectivity is key, the ability to connect to a remote Windows system from a Linux command line can be a game-changer. Thanks to powerful tools like xfreerdp, this process has become seamless and efficient.

In this guide, we will explore how to connect to a remote Windows system using xfreerdp, empowering Linux users with remote desktop capabilities.

Installing xfreerdp

Before you can use xfreerdp, you need to install it. On most Linux distributions, you can use the package manager to do this. For example, on Ubuntu / Debian and Linux Mint, run following apt command

$ sudo apt update
$ sudo apt install freerdp2-x11 -y

For RHEL based distributions like Rocky Linux, AlmaLinux and Fedora, run

$ sudo dnf install freerdp -y

Connecting Remote Windows System with xfreerdp

Post installation, we can take the RDP of remote windows machine using following xfreerdp command,

$ xfreerdp /u:”username” /v:<Remote-Windows-IP>:3389

Replace <username> with your windows username and <remote_windows_ip> with the IP address or hostname of the Windows system.

Example,

$ xfreerdp /u:"Administrator" /v:54.226.239.0:3389

It prompts you to trust the certificate, Press Y and then enter password of your remote windows systems administrator password. After entering the credentials, we will connect to remote windows system as shown below:

xfreerdp offers a range of advanced options that allow you to customize your remote desktop experience. For instance, you can adjust the screen resolution, enable sound, specify a domain, and much more. Here’s an example:

$ xfreerdp /v:<remote_windows_ip> /u:<username> /p:<password> /w:800 /h:600 /sound /d:<domain>

• /w and /h: Set the desired width and height of the remote desktop window.
• /sound: Enable sound redirection.
• /d: Specify the domain if needed.

Example for customize remote desktop size,

$ xfreerdp /u:"Administrator" /v:18.209.23.239:3389 /w:800 /h:600

Note: Before taking RDP, please make sure remote desktop option is enabled in remote windows system.

That’s all from this guide, I hope you have found it useful and informative. Please don’t hesitate to post your queries and feedback in below comments section.

Conclusion

xfreerdp empowers Linux users to effortlessly connect to remote Windows systems directly from the command line. Whether you’re managing servers, troubleshooting issues, or accessing Windows applications, xfreerdp streamlines the process while ensuring a secure and responsive experience. Embrace the power of cross-platform connectivity and enhance your remote desktop capabilities with xfreerdp today!

Automation is the heart of modern IT infrastructure management, and Ansible is a powerful automation tool that simplifies the automation of complex tasks. Whether you’re managing a single server or a large-scale data center, Ansible can save you time and effort. Ansible works on agent-less architecture, it operates over SSH and does not require any agents to be installed on the target systems. This makes it lightweight and easy to set up.

In this guide, we’ll walk you through the process of installing Ansible on Ubuntu 22.04, ensuring you have this versatile tool at your fingertips.

Prerequisites

• Pre Installed Ubuntu 22.04
• Regular user with sudo rights
• 2 CPU / vCPU
• 2 GB RAM or more
• 20 GB Hard drive
• Internet Connection (In case you don’t have local configured apt repository server)

Lab Details:

• Ansible Control Node – control.example.com (192.168.1.192)
• Ansible Managed Nodes – node1.example.com & node2.example.com
• sysops sudo user on control and managed nodes with privileges.

Note: Here node1 is a Ubuntu System and node2 is a fedora system and control node is the system where we will install ansible. I am assuming sysops is already created on each host.

To configure sudo user (sysops) to run all the commands without prompting for the password then run the following echo and tee command on each managed host

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

Without any further delay, let’s jump into Ansible Installation steps,

1) Apply Updates

Login to your Ubuntu 22.04 system and run below apt commands to apply all available updates.

$ sudo apt update
$ sudo apt upgrade -y

Once all the updates are installed then reboot the system once, run beneath command

$ sudo reboot

2) Add Ansible PPA Repository

Ansible package and it’s dependencies are available in the default package repositories but there are chances that you will not get latest version of Ansible. So, in order to install latest Ansible version, add its ppa repository. Run following commands,

$ sudo apt install -y software-properties-common
$ sudo add-apt-repository --yes --update ppa:ansible/ansible

Now, update repository package index by running beneath apt command.

$ sudo apt update

3) Install Ansible

Now, we are ready to install latest version of Ansible on Ubuntu 22.04 LTS / 20.04, run following apt command.

$ sudo apt install -y ansible

Once the installation is complete, you can verify that Ansible is installed correctly by checking its version:

$ ansible --version

You should see the installed version of Ansible displayed on your terminal.

4) Setup SSH keys and Share it Among Managed Nodes

Configure password-less ssh authentication for sysops user. Generate the SSH keys for sysops user from the control node and share it among managed hosts. Run ssh-keygen command,

$ ssh-keygen

Hit enter when prompting for the input, output is shown below

Note : Add managed host entries in /etc/hosts file on control node. This is only required when you don’t have local DNS server configured.

192.168.1.200 node1.example.com
192.168.1.77  node2.example.com

To share the ssh keys between control to managed hosts, run ssh-copy-id command example is shown below

$ ssh-copy-id node1.example.com
$ ssh-copy-id node2.example.com

Output of above commands would look like below

5) Create Ansible.cfg File and Setup Inventory

It is always recommended to have separate ansible.cfg and inventory file for each project. For the demonstration purpose, I am going to use demo as the project name. So, create the project folder first by running mkdir command.

$ mkdir demo

Download sample ansble.cfg file to ~/demo folder using following wget command

$ cd demo
$ wget https://raw.githubusercontent.com/ansible/ansible/stable-2.11/examples/ansible.cfg

Edit the ~/demo/ansible.cfg file, set the following parameters,

$ vi ~/demo/ansible.cfg

Under the default sections

inventory      = /home/sysops/demo/inventory
remote_user = sysops
host_key_checking = False

Under the privilege_escalation section

become=True
become_method=sudo
become_user=root
become_ask_pass=False

Save and close the file. Now, let’s create the inventory file that we have defined in ~/demo/ansible.cfg file.

$ vi ~/demo/inventory
[dev]
node2.example.com

[prod]
node1.example.com

save and exit the file

Re-run ansible --version command to verify that new config file is set

$ cd demo/
$ ansible --version

Great, ansible is now reading our project’s configuration file. Let’s verify the managed nodes connectivity using ansible ad-hoc command,

$ ansible all -m ping

Note : Make sure run ansible command from demo folder.

Output of above command would look like below:

This output confirms that connectivity is in place from control node to managed hosts.

6) Test Ansible Installation

In order to test ansible installation and configuration, let’s create a sample playbook named as packages.yaml under demo folder. This playbook will install packages on managed nodes.

$ vi packages.yaml
---
- name: Playbook to Install Packages
  hosts:
    - dev
    - prod
  tasks:
  - name: Install php and mariadb
    package:
      name:
        - php
        - mariadb-server
      state: present

save and close the file

Next,  run the playbook using ansible-playbook command,

$ ansible-playbook packages.yaml

Output:

Output above confirms that playbook has been executed successfully. To verify result, run following ad-hoc commands,

$ ansible dev -m shell -a 'dpkg -l | grep -E "php|mariadb"'
$ ansible prod -m shell -a 'rpm -qa | grep -E "php|mariadb"'

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

Conclusion

Installing Ansible on Ubuntu 22.04 is a straightforward process that empowers you to automate system administration tasks efficiently. By following these steps, you’ve laid the foundation for harnessing Ansible’s capabilities in your infrastructure management journey. Whether you’re provisioning servers, deploying applications, or configuring systems, Ansible is your reliable automation companion on Ubuntu.

Read Also : How to Use Handlers in Ansible Playbook

OpenLDAP is a free and open-source implementation of LDAP (Lightweight Directory Access Protocol). It’s a highly customizable LDAP option that comes complete with a software suite for LDAP servers which includes slapd (standalone LDAP daemon), slurpd (standalone LDAP update replication daemon), and other tools, libraries, clients, and utilities used for managing LDAP servers.

In this guide, we focus on how to setup OpenLDAP server on Ubuntu 22.04 step-by-step.

Prerequisites

To follow along in this guide, ensure that you have the following in place:

• An Instance of Ubuntu 22.04
• SSH connection to the server

1) Setup Server Hostname

Right off the bat, you need to configure the hostname or Fully Qualified Doman Name ( FQDN) for your server.  In this guide, we will configure the OpenLDAP server with the hostname ldap.linuxtechi.com and the IP address 172.105.152.235.

Run the following command as root. Be sure to replace ldap.linuxtechi.com with your preferred server domain and hostname

# hostnamectl set-hostname ldap.linuxtechi.com

Next, update the /etc/hosts file with the server hostname and corresponding IP address for hostname resolution within the network.

# echo '172.105.152.235 ldap.linuxtechi.com' >> /etc/hosts

Now ping the server hostname and you will get a positive ping output.

# ping -c 3 ldap.linuxtechi.com

2) Install OpenLDAP Packages

The next step is to install OpenLDAP. To do so run the following command to install the OpenLDAP packages.

# apt install slapd ldap-utils

During the installation, you will be prompted to configure administrator password for your LDAP server. Provide a strong one and hit ENTER.

Next, re-enter the password to confirm your password and hit ENTER.

3)  Configure OpenLDAP Server

Once OpenLDAP is successfully installed, you need to go a step further and reconfigure the main package. This is the slapd package. To accomplish this, run the following command.

# dpkg-reconfigure slapd

The command will generate a series of prompts on your terminal. First, you need to initialize the OpenLDAP server configuration. On the first prompt, Select the ‘No’ option to prevent the omittance of the OpenLDAP server configuration.

Next, provide a DNS domain name. This will be used to construct the base DN of the LDAP directory. In this example, we will use the domain name linuxtechi.com. As such, the DN will be represented as “dc=linuxtechi,dc=com”. The hit ‘ENTER’

Next, provide a name for your organization that will also form part of the base DN. Once again, we will provide the same name as the domain name.

Next, provide the Administrator password for your LDAP directory and hit ‘ENTER’.

Be sure to confirm it and press ‘ENTER’

When prompted to remove the database when slapd is purged, select ‘NO’.

Finally, select ‘Yes’ to remove the old database to create room for a new database.

Finally, you should see the following output.

Next, you need to make changes to the main OpenLDAP configuration file So open it using your preferred editor. Here we are using nano.

$ sudo nano /etc/ldap/ldap.conf

Locate and uncomment the lines beginning with “BASE” and “URI” and provide the domain name for your OpenLDAP server. In our case, the “BASE” is “dc=linuxtechi,dc=com” and the “URI” for the OpenLDAP server is “ldap://ldap.linuxtechi.com“.

BASE dc=linuxtechi,dc=com
URI  ldap://ldap.linuxtechi.com

Save the changes and exit the configuration file. Then restart slapd daemon and check its status as follows.

$ systemctl restart slapd
$ systemctl status slapd

Then run the following command to confirm the OpenLDAP basic configuration. This should give you the following output.

# ldapsearch -Q -LLL -Y EXTERNAL -H ldapi:///

4) Setup Base group for OpenLDAP Users

The next step is to create a new base group for OpenLDAP users. To demonstrate this, we will create two base groups: people and groups. The ‘people’ group will be used for storing regular users while the ‘groups’ group will store the groups on your LDAP server.

Therefore, we will create the base-groups file as follows.

# nano base-groups.ldif

Paste the following lines to the configuration file.

dn: ou=people,dc=linuxtechi,dc=com
objectClass: organizationalUnit
ou: people
dn: ou=groups,dc=linuxtechi,dc=com
objectClass: organizationalUnit
ou: groups

Save the changes and exit.

To add the base groups, run the ‘ldapadd ‘ command against the ‘base-groups.ldif’ file. Provide the OpenLDAP admin password when prompted and press ‘ENTER’.

# ldapadd -x -D cn=admin,dc=linuxtechi,dc=com -W -f base-groups.ldif

The output will display information informing you that the groups have successfully been added.

To confirm that the groups have been added, run the following command.

# ldapsearch -Q -LLL -Y EXTERNAL -H ldapi:///

The command generates a block of output displaying all the details of your LDAP configuration including the groups we have just created.

5) Add a new group to the Base Group

With the base groups already created, in this section, we will proceed to add a new group to the ‘groups’ base group.

To achieve this, we will create a new group file called group.ldif.

# nano group.ldif

Paste the following lines of code. Here, we have specified a new group called support_engineers with a group ID of 5000.

dn: cn=support_engineers,ou=groups,dc=linuxtechi,dc=com
objectClass: posixGroup
cn: support_engineers
gidNumber: 5000

Once done, save the changes and exit the configuration file. Then run the command below to add the ‘support_engineers’ group to the ‘groups’ group.

# ldapadd -x -D cn=admin,dc=linuxtechi,dc=com -W -f group.ldif

The command generates the following output confirming that the support_engineers group was successfully added.

Then execute the following command to verify that the group ‘support_engineers’ is part of the ‘groups’ group with a GID of ‘5000’.

# ldapsearch -x -LLL -b dc=linuxtechi,dc=com '(cn=support_engineers)' gidNumber

5) Create a new OpenLDAP User

The last step is to create an OpenLDAP user and attach the user to a specific base group. But first, you need to generate an encrypted password for the user. To do so, run the following command, and be sure to provide a strong password.

# slappasswd

The password will be printed in an encrypted format. Copy the entire password beginning with {SSHA}to the last character and paste it somewhere as you will need this in the next step.

Next, create a new user file as shown.

# nano user.ldif

Paste the following lines of code. In this configuration, we are creating a new user called ‘Alex’ with a UID of 7000. The default home directory will be “/home/alex” and the default login shell “/bin/bash”. The new user will be a part of the base group called ‘people’ with a GID of 7000.

Paste the encrypted user’s password in the userPassword attribute or parameter.

dn: uid=alex,ou=people,dc=linuxtechi,dc=com
objectClass: inetOrgPerson
objectClass: posixAccount
objectClass: shadowAccount
uid: alex
sn: smith
givenName: alex
cn: alex smith
displayName: alex smith
uidNumber: 7000
gidNumber: 7000
userPassword: {SSHA}uQVjd8MLaJ7AXEd/grqViuKnk9tNojdy
gecos: Alex Smith
loginShell: /bin/bash
homeDirectory: /home/alex

Save and exit the configuration file

To add the user to the ‘people’ group, run the following command:

# ldapadd -x -D cn=admin,dc=linuxtechi,dc=com -W -f user.ldif

You should get the following confirmation output.

To confirm the creation of the user, execute the command.

# ldapsearch -x -LLL -b dc=linuxtechi,dc=com '(uid=alex)' cn uidNumber gidNumber

This prints out all the user details including the canonical name of the user, UID, and GID.

Conclusion

In this guide, we have successfully installed and configured the OpenLDAP server on Ubuntu 22.04. We have gone a notch higher and created base groups, groups, and users and added them to the base groups. That’s all for this guide, your feedback is welcome.

Also Read: How to Install GitLab on Ubuntu 22.04 | 20.04

Minikube is a tool that allows developers and system admins to run a single-node Kubernetes cluster on their local machines. It is an excellent way to experiment, learn, and test Kubernetes applications without the need for a full-scale cluster.

In this post, we will walk you through the process of installing Minikube on RHEL 9, enabling you to embark on your Kubernetes journey seamlessly.

Prerequisites

• Minimal Installed RHEL 9 System
• Sudo User with Admin Rights
• Red Hat Subscriptions or locally Configured Repository
• Internet Connectivity
• Minimum 2 GB RAM or more
•  2 vCPUs or more
• 20 GB Free Disk Space

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

1) Install Podman

Access your RHEL 9 system and run following dnf command to install podman,

$ sudo dnf install -y podman

Post installation, verify the podman version,

$ podman version
Client:       Podman Engine
Version:      4.4.1
API Version:  4.4.1
Go Version:   go1.19.6
Built:        Wed Apr 26 22:20:28 2023
OS/Arch:      linux/amd64
$

Allow your local user to run podman commands with passwordless sudo.

$ echo "linuxtechi ALL=(ALL) NOPASSWD: /usr/bin/podman" | sudo tee /etc/sudoers.d/linuxtechi

Verify above changes by running beneath command

$ sudo -k -n podman version

It should not prompt you to enter local user password.

2)  Install Kubectl 

Kubectl is the Kubernetes command-line tool that allows you to interact with the Kubernetes cluster. Install it with the following commands:

$ curl -LO https://storage.googleapis.com/kubernetes-release/release/\
`curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt`/bin/linux/amd64/kubectl
$ chmod +x kubectl && sudo mv kubectl /usr/local/bin/
$ kubectl version -o yaml

3) Download and Install Minikube Binary

Execute the following commands to download and install minikube,

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

Output above confirms that minikube binary has been installed successfully. In the next step, let’s start the minikube cluster using podman driver.

4) Start Minikube Cluster

As we are using podman as driver for minikube. Run following command to start the cluster,

$ minikube start --driver=podman

Above minikube command will download the necessary Kubernetes components and start the cluster. This process might take a few minutes.

Great, output above shows that cluster has been started successfully.

After the cluster is up and running, you can use kubectl to interact with it. Try the following commands to get the cluster information,

$ kubectl cluster-info
$ kubectl get nodes
$ kubectl get pods -A

5) Manage Minikube Addons

Minikube comes with ready to use addons like Kubernetes dashboard, ingress controller and lot more. By default, they are disabled. So, to enable them, run following minikube command

$ minikube addons list    // This will list available addons 
$ minikube addons enable dashboard   // It will enable k8s dashboard
$ minikube addons enable ingress     // It will enable ingress controller
$ minikube addons list | grep -i -E "dashboard|ingress"

To get Kubernetes dashboard url , run

$ minikube dashboard --url

6) Test Kubernetes Cluster

In order to test Kubernetes cluster, we will deploy a sample nginx based deployment, run following kubectl commands,

$ kubectl create deployment demo --image=nginx --replicas=2
$ kubectl expose deployment demo --type NodePort --port=80
$ kubectl get deployment demo
$ kubectl get pods

Get the url for your application, run

$ minikube service demo --url
http://192.168.49.2:31989$

Now, try to access application using following url

$ curl http://192.168.49.2:31989

Perfect, above confirms that we can access out sample nginx application.

7) Manage Minikube Cluster

To stop and start the cluster run the following minikube command respectively,

$ minikube stop 
$ minikube start

To delete minikube cluster, run

$ minikube delete

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

Conclusion

Minikube provides a fantastic platform to explore Kubernetes in a controlled environment. In this blog post, we walked you through the step-by-step installation of Minikube on RHEL 9, allowing you to experiment with Kubernetes and its features right on your local machine. Now, you can confidently embark on your journey into the world of Kubernetes and container orchestration.

GitLab, an open-source platform, provides a robust and feature-rich solution for managing repositories, issues, CI/CD pipelines, and much more. If you’re an Ubuntu 22.04 or 20.04 user and want to set up your own GitLab instance to streamline your DevOps workflow, you’re in the right place.

This step-by-step guide will walk you through the installation process of GitLab on Ubuntu 22.04 or 20.04. GItlab comes with Enterprise edition (Gitlab EE) and Community edition (Gitlab CE). In this post , we will cover the community edition.

Prerequisites

• A virtual or dedicated server running Ubuntu 22.04 or 20.04 with SSH access.
• Static Hostname ( gitlab.linuxtechi.net)
• Sudo User with admin rights
• 2 GB RAM or more
• 2 vCPUs or more
• Internet Connectivity

1) Update System Packages

Let’s begin by updating the package lists and upgrading any existing packages to their latest versions.

$ sudo apt update
$ sudo apt upgrade -y

Reboot the system after applying updates,

$ sudo reboot.

2) Install Dependencies

GitLab requires some dependencies to function correctly. Install them using the following commands:

$ sudo apt install -y curl openssh-server ca-certificates postfix

During the postfix installation, a configuration window will appear. Choose “Internet Site” and enter your server’s hostname as the mail server name. This will allow GitLab to send email notifications.

,

Choose “Internet Site” and then slect OK.

Check system’s hostname and choose OK.

3) Add GitLab Apt Repository

Now, we’ll add the GitLab repository, run the following curl command. It will automatically detect your Ubuntu version and will set the repository accordingly.

$ curl -sS https://packages.gitlab.com/install/repositories/gitlab/gitlab-ce/script.deb.sh | sudo bash

4) Install Gitlab

Run the beneath command to install and configure gitlab-ce  on your ubuntu system automatically, replace the server’s hostname as your setup,

$ sudo EXTERNAL_URL="http://gitlab.linuxtechi.net" apt install gitlab-ce

Once the above the command is executed successfully, we will get output something like below,

Output above confirms that GitLab has been installed successfully. User name for gitlab web interface is root and password is stored at “/etc/gitlab/initial_root_password”

Note : If OS firewall is enabled on your ubuntu system, then allow 80 and 443 ports.

$ sudo ufw allow http
$ sudo ufw allow https

5) Access GitLab Web Interface

With GitLab installed and configured, open your web browser and enter your server’s IP address or hostname.

http://<Server-IP-Address-or-Hostname>

• User Name: root
• Password : <<Get Password from /etc/gitlab/initial_root_password>>

click on “Sign in”

Great, above confirms that we have successfully login to Gitlab Web interface.

As of now our GitLab Server is working on http (80) protocol, if you want to enable https for your GitLab, then refer the below steps,

6) Setup HTTPS for GitLab Web Interface

For added security, you can configure HTTPS for your GitLab instance using self-signed certificate or Let’s Encrypt. We can use Let’s encrypt only for public domain whose A recorded available on internet. But in our case, we are using a private domain, so we will be using self-signed certificate to secure GitLab.

Now, let’s create following folder and generate self-sign certificates using openssl command

$ sudo mkdir -p /etc/gitlab/ssl
$ sudo chmod 755 /etc/gitlab/ssl

Generate the private key using following openssl command,

$ sudo openssl genrsa -des3 -out /etc/gitlab/ssl/gitlab.linuxtechi.net.key 2048

Enter the passphrase and and remember it

Create the CSR using below command,

$ sudo openssl req -new -key /etc/gitlab/ssl/gitlab.linuxtechi.net.key -out /etc/gitlab/ssl/gitlab.linuxtechi.net.csr

Remove Passphrase from the key, execute the following commands one after the another

$ sudo cp -v /etc/gitlab/ssl/gitlab.linuxtechi.net.{key,original}
$ sudo openssl rsa -in /etc/gitlab/ssl/gitlab.linuxtechi.net.original -out /etc/gitlab/ssl/gitlab.linuxtechi.net.key
$ sudo rm -v /etc/gitlab/ssl/gitlab.linuxtechi.net.original

Create the Certificate file

$ sudo openssl x509 -req -days 1460 -in /etc/gitlab/ssl/gitlab.linuxtechi.net.csr -signkey /etc/gitlab/ssl/gitlab.linuxtechi.net.key -out /etc/gitlab/ssl/gitlab.linuxtechi.net.crt

Remove the CSR file using below rm command,

$ sudo rm -v /etc/gitlab/ssl/gitlab.linuxtechi.net.csr

Set the permissions on key and certificate file

$ sudo chmod 600 /etc/gitlab/ssl/gitlab.linuxtechi.net.key
$ sudo chmod 600 /etc/gitlab/ssl/gitlab.linuxtechi.net.crt

All the important configuration for Gitlab server is controlled by the file “/etc/gitlab/gitlab.rb” So edit this file,  search “external_url” and add the “https://gitlab.linuxtechi.net”

$ sudo vi /etc/gitlab/gitlab.rb
----------------------------------------------------------
external_url 'https://gitlab.linuxtechi.net'
----------------------------------------------------------

Save and exit the file, reconfigure gitlab using beneath command so that it’s web interface start working https.

$ sudo gitlab-ctl reconfigure

Once above command is executed successfully, then your GitLab interface should be accessible over https protocol, In my case url will be: https://gitlab.linuxtechi.net/

When you access it first time, it will say something like your connection is not secure, click on “Accept the Risk and Continue”

Conclusion

Congratulations! You’ve successfully installed GitLab on your Ubuntu 22.04 or 20.04 system. With GitLab up and running, you can now create repositories, collaborate with your team, and enhance your development workflow through GitLab’s impressive features. Enjoy seamless version control, continuous integration, and more, all under your control!

In this guide, we will demonstrate how to install Apache Kafka on Ubuntu 22.04 step-by-step.

In Big data, enormous streams of data records are generated by millions of data sources which include social media platforms, enterprise systems, mobile apps, and IoT devices to mention a few. The main challenges that arise with such an enormous amount of data are two-fold; efficient collection and analysis of the data. To overcome such challenges, you need a reliable and robust messaging system.

Developed by Apache Foundation and written in Java and Scala, Apache Kafka is an open-source distributed pub/sub ( publish-subscribe) event streaming platform that handles enormous amounts of data. It also allows you to transmit messages from one point to another. It works alongside the Zookeeper synchronization service and seamlessly integrates with Apache Spark for analytics and large-scale data processing.

In comparison to other messaging systems, Apache Kafka provides better throughput, inherent fault-tolerance, and replication which makes it an excellent choice for enterprise message processing applications. Top companies using Apache Kafka in their tech stacks include Netflix, Microsoft, and AirBnB.

Prerequisites

• Pre Installed Ubuntu 22.04
• Sudo User with Admin Rights
• Internet Connectivity

1) Install OpenJDK on Ubuntu 22.04

Since Apache Kafka is written in Java, Installation of Java is a prerequisite. So, log in to your server and refresh the local package index.

$ sudo apt update

Next, install OpenJDK which is a free and open-source implementation of the Java Standard Edition Platform. Here, we are installing OpenJDK 11 which is an LTS release.

$ sudo apt install openjdk-11-jdk -y

Once installed, verify the version of Java as shown.

$ java -version

2) Install Apache Kafka on Ubuntu 22.04

With all the prerequisites already in place, let’s proceed and install Apache Kafka. To do so, head over to Apache Kafka main download page and locate the latest binary file in tarball format. At the time of writing down this guide, Apache Kafka 3.5.1 is the latest release.

To download it, use the wget command-line utility.

$ wget https://downloads.apache.org/kafka/3.5.1/kafka_2.13-3.5.1.tgz

Next, extract the tarball file using the tar command-line tool.

$ tar xvf kafka_2.13-3.5.1.tgz

Once extracted, a folder called kafka_2.12-3.5.0 is created. Next, move this folder to the /usr/local directory and rename it kafka.

$ sudo mv kafka_2.13-3.5.1 /usr/local/kafka

3) Create Kafka and ZooKeeper Systemd Unit files

In this step, we will create systemd unit files for Kafka and ZooKeeper services. This will allow you to easily manage the services using the systemctl command.

Let’s start by creating the Zookeeper systemd file using the nano editor as shown.

$ sudo nano  /etc/systemd/system/zookeeper.service

Paste the following lines of code which define Zookeeper’s systemd service.

[Unit]
Description=Apache Zookeeper server
Documentation=http://zookeeper.apache.org
Requires=network.target remote-fs.target
After=network.target remote-fs.target

[Service]
Type=simple
ExecStart=/usr/local/kafka/bin/zookeeper-server-start.sh /usr/local/kafka/config/zookeeper.properties
ExecStop=/usr/local/kafka/bin/zookeeper-server-stop.sh
Restart=on-abnormal

[Install]
WantedBy=multi-user.target

Save the changes and exit.

Next, create Kafka’s systemd file

$ sudo nano /etc/systemd/system/kafka.service

Paste the following lines of code which define Kafka’s systemd service.

[Unit]
Description=Apache Kafka Server
Documentation=http://kafka.apache.org/documentation.html
Requires=zookeeper.service

[Service]
Type=simple
Environment="JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64"
ExecStart=/usr/local/kafka/bin/kafka-server-start.sh /usr/local/kafka/config/server.properties
ExecStop=/usr/local/kafka/bin/kafka-server-stop.sh

[Install]
WantedBy=multi-user.target

Be sure to save the changes and exit.

4) Start Kafka and ZooKeeper Systemd Services

Once all systemd files are in place, notify systemd of the changes made.

$ sudo systemctl daemon-reload

Next, start Kafka and Zookeeper services.

$ sudo systemctl start zookeeper
$ sudo systemctl start kafka

Confirm if the services are running. For Zookeeper, run:

$ sudo systemctl status zookeeper

For Apache Kafka service , execute:

$ sudo systemctl status kafka

5) Create a Kafka Topic

With Kafka and all components installed, we will create a topic and try to send a message. In Kafka, a topic is a fundamental unit used to organize messages. Each topic should have a unique name across a cluster. Topics allow users to send and read data between Kafka servers.

You can create as many clusters as you want in Kafka. That said, Now let’s create a Topic called sampleTopic on localhost port 9092 with a single replication factor.

$ cd /usr/local/kafka
$ bin/kafka-topics.sh --create --bootstrap-server localhost:9092 --replication-factor 1 --partitions 1 --topic sampleTopic

Let us break down the command:

• –create: Creates a new topic
• –replication-factor: Specifies how many copies of data will be created
• –partitions: Specifies the number of partitions as the number of brokers by which your data will be split
• –topic: Specifies the name of the topic. Topics are split into several partitions.

Upon running the command, you will get a confirmation that the topic was successfully created.

Output

Created topic sampleTopic

As mentioned earlier, you can create as many topics as you can using the same syntax. To check or list the topics created, run the command:

$ bin/kafka-topics.sh --list --bootstrap-server localhost:9092

6) Send and Receive a Message in Kafka

In Kafka, a ‘producer’ is an application that writes data into topics across different partitions. Applications integrate a Kafka client library to write a message to Apache Kafka. Kafka client libraries are diverse and exist for a myriad of programming languages including Java, Python among others.

Let us now run the producer and generate a few messages on the console.

$ bin/kafka-console-producer.sh --broker-list localhost:9092 --topic sampleTopic

You will be prompted to type a few messages. In this case, we typed a few lines.

> Hello World!
> Welcome to Apache Kafka
> This is the first topic

Once you are done, you can exit or keep the terminal running. To consume the messages, open a new terminal and run the following command:

$ bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic sampleTopic --from-beginning

The messages you typed will be displayed on the terminal as shown in the output below.

Conclusion

This wraps up our guide today. In this tutorial, we have demonstrated how to install Apache Kafka on Ubuntu 22.04. In addition, we have seen how you can send and receive a message within a Kafka cluster.

Kubernetes, an open-source container orchestration platform, has become the go-to solution for managing containerized applications at scale. While Kubernetes provides powerful command-line tools for managing clusters, sometimes a visual interface can make monitoring and managing your deployments even easier. Kubernetes Dashboard is a web-based user interface that allows you to visualize and interact with your Kubernetes clusters.

In this blog post, we will walk you through the process of installing and using Kubernetes Dashboard step-by-step, empowering you to streamline your Kubernetes management tasks.

Prerequisites

Before installing Kubernetes Dashboard, ensure that you have a running Kubernetes cluster and have the necessary administrative access.

Installing Kubernetes Dashboard

The easy way to install Kubernetes dashboard for your cluster is via helm chart. Kubernetes Dashboard now has a dependency on cert-manager and nginx-ingress-controller. Fortunately, these dependencies can be automatically installed using the Helm chart. However, if you already have these components installed, you can disable their installation by setting the flags –set=nginx.enabled=false and –set=cert-manager.enabled=false when installing the chart.

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

1 ) Install Helm

Access your cluster’s master node using a terminal or command prompt. Install helm if not installed. Run the following commands.

$ curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
$ chmod 700 get_helm.sh
$ ./get_helm.sh

2) Add Kubernetes Dashboard Helm Repository

Run following helm command to add dashboard repository,

$ helm repo add kubernetes-dashboard https://kubernetes.github.io/dashboard/
$ helm repo list

3) Install Kubernetes Dashboard

To install Kubernetes dashboard using helm, run following command,

$ helm upgrade --install kubernetes-dashboard kubernetes-dashboard/kubernetes-dashboard --create-namespace --namespace kubernetes-dashboard

Output above confirms dashboard has been deployed in Kubernetes-dashboard namespace. So, in order to access dashboard, run

$ kubectl -n kubernetes-dashboard port-forward svc/kubernetes-dashboard-nginx-controller 8443:443

Now, open the web browser of system on which you have run above command, type following url

https://localhost:8443

Click on “Accept the Risk and Continue”

As you can see above, we need a token to login. So, let’s generate the required token in the next step.

4)  Generate Token for Kubernetes Dashboard

Open one more ssh session to master node and create a service account and assign required permissions using following yaml file,

$ vi k8s-dashboard-account.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
  name: admin-user
  namespace: kube-system
---
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

Next create service account by running following command

$ kubectl create -f k8s-dashboard-account.yaml
serviceaccount/admin-user created
clusterrolebinding.rbac.authorization.k8s.io/admin-user created
$

Now, generate the token for admin-user, run

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

Copy this token and head back to browser, paste it on “Enter Token” field as shown below,

Click on “Sign in”

5) Access Kubernetes Dashboard

When we click on “Sign in” in above then we will get the following dashboard,

Great, you are now logged in to the Kubernetes Dashboard. Here are a few key features and functionalities to explore:

• Cluster Overview: Gain an overview of your cluster’s health, resource utilization, and running pods.
• Workloads: View and manage your deployments, replica sets, stateful sets, and daemon sets.
• Services: Monitor and manage your services, including load balancers and external endpoints.
• Configurations: Explore your config maps, secrets, and persistent volume claims.
• Storage: Manage persistent volumes and storage classes.
• Namespaces: Switch between namespaces to view and manage resources across different projects or teams.

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

PHP is a recursive acronym for Hypertext Preprocessor. It is a popular and widely used server-side scripting language used in web development and can even be embedded in HTML pages. Although there are other new scripting languages such as Perl and Ruby, PHP still remains popular and powers some of the most popular websites such as Facebook, WordPress, and MailChimp.

Prerequisites

• Pre-installed RHEL 9 or Rocky Linux 9 or Alma Linux 9
• Sudo user with admin rights
• Internet Connectivity

In this post, we look at how to install PHP 8.2 on RHEL 9 / Rocky Linux 9 / AlmaLinux OS 9.

Step 1) Update System Packages

To get started, log into your server instance and be sure to update installed packages to their latest versions as shown below.

$ sudo dnf update -y

To ensure that all changes have come into effect, restart your server instance.

$ sudo reboot

Step 2) Add the Remi repository

In this tutorial, we will install the latest version of PHP which is PHP 8.2 from the Remi repository. This is a third-party repository that provides the latest versions of PHP and other packages for RHEL-based Linux distributions.

To install Remi, first, you need to install EPEL as a prerequisite. EPEL, short for Extra Packages for Enterprise Linux, is a repository maintained by Fedora which contains additional packages for Red Hat Enterprise Linux (RHEL), and RHEL-based distributions such as Alma Linux and Rocky Linux.

Therefore, install EPEL as shown.

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

Once done, confirm that the EPEL repository has been installed.

$ rpm -q epel-release

The next step is to add the Remi repository, and to do so, run the command:

$ sudo dnf -y install http://rpms.remirepo.net/enterprise/remi-release-8.rpm -y

You can verify if Remi is installed using the command:

$ rpm -q remi-release

Additionally, you can list configured repositories on your system as follows. Be sure that you can see EPEL and Remi repository entries.

Step 3) Install PHP 8.2 on RHEL 9 / Rocky 9 / AlmaLinux 9

With both repositories installed, the next step is to install PHP 8.2.  Before proceeding, reset the default PHP module.

$ sudo dnf module reset php -y

Next, enable the PHP Remi 8.2 module that contains the PHP packages to be installed.

$ sudo dnf module install php:remi-8.2

When prompted, hit ‘Y’ and press ENTER to import the GPG key.

Next, install PHP 8.2 and dependency packages

$ sudo dnf -y install php

Once installed, confirm the PHP version as shown

$ php --version
OR
$ php -v

From the output, you can see that we have installed PHP 8.2.7.

Additionally, you can install PHP modules to extend the functionality of PHP. This takes the following syntax:

$ sudo dnf install php-extension_name

If you are installing multiple PHP extensions, you can use the shortened form as shown.

$ sudo dnf install php-{extension1,extension2}

In this example, we are installing a set of PHP extensions as shown.

$ sudo dnf install php-{zip,json,pear,mysqlnd, xml,fpm,curl,opcache,intl,cgi}

When prompted, press ‘y’ and hit ENTER to proceed.

To view all installed modules, run the command:

$ php -modules

Integrating PHP with Apache Web Server

The mod_php module is an Apache module that enables Apache to parse php code and interpret PHP files. When a user requests a PHP page, the web server fetches the requested PHP file, executes the code, and returns HTML content to the client’s web browser. This eliminates the need of having a separate PHP interpreter.

The Apache web server comes with the mod_php module as one of the packages.  So you can go ahead and install Apache as shown.

$ sudo dnf install httpd -y

Next, enable the Apache web server service.

$ sudo systemctl enable httpd
$ sudo systemctl start httpd

Be sure to confirm that Apache is running.

$ sudo systemctl status httpd

Next, create a sample PHP file in the web root directory.

$ sudo nano /var/www/html/info.php

Add the following code

<?php
phpinfo()
?>

Save the changes and exit the file. To confirm that the web server is ready to serve PHP pages, browse your URL as shown.

http://server-ip/info.php

This displays what you can see below, a confirmation that your web server is able to parse PHP code.

Integrating PHP with Nginx Web Server

When running the Nginx web server, PHP-FPM (FastCGI Process Manager) is the recommended way of processing PHP pages. It’s faster than mod_php and other traditional CGI-based avenues. It consumes less computing resources such as CPU and memory compared with other methods. In addition, it allows you to run PHP as a daemon, which can be managed using systemd.

To demonstrate how to use PHP with Nginx, we will install Nginx alongside PHP-FPM as shown.

$ sudo dnf install nginx php-fpm -y

If you have Apache installed, be sure to stop the service since t runs on port 80 which Nginx will use.

$ sudo systemctl stop httpd

Next, enable and start Nginx and PHP-FPM.

$ sudo systemctl enable --now nginx php-fpm

Be sure to confirm that Nginx and PHP-FPM services are running.

$ sudo systemctl status nginx

$ sudo systemctl status php-fpm

Next, edit the www.conf file as shown:

$ sudo vim /etc/php-fpm.d/www.conf

Add the following lines.

user = nginx
group = nginx
listen = /var/run/php-fpm.sock
listen.owner = nginx
listen.group = nginx
listen.mode = 0660

Save and exit the configuration file. Next, we need to configure Nginx to forward requests to PHP-FPM. To accomplish this, access the Nginx main configuration file.

$ sudo vim /etc/nginx/nginx.conf

Add the following line under the root directive.

index index.php index.html;

Next, add the following lines to forward requests to PHP-FPM

location ~ \.php$ {
        include /etc/nginx/fastcgi_params;
        fastcgi_pass unix:/var/run/php-fpm.sock;
    }

Save the changes and exit the configuration file. To apply the changes made, restart Nginx and PHP-FPM.

$ sudo systemctl restart nginx
$ sudo systemctl restart php-fpm

Next, verify if the Nginx configuration is sound

$ sudo nginx -t

Next, we will create a sample info.php file

$ sudo nano /usr/share/nginx/html/info.php

Add the following code

<?php
phpinfo()
?>

Save the changes and exit the file. To confirm that Nginx is ready to serve PHP pages, once again, browse your URL as shown.

http://server-ip/info.php

Conclusion

In this guide, we have shown you how to install PHP 8.2 on RHEL 9 and RHEL-9-based distros such as Rocky Linux 9 and AlmaLinux 9. We have also demonstrated how you can configure PHP to work with Apache and Nginx web browsers.

PHP 8, the latest major release of the popular server-side scripting language, comes with numerous exciting features and performance enhancements. If you’re running RHEL 8 or Rocky Linux 8 or CentOS 8 and want to take advantage of PHP 8, you’re in the right place. In this step-by-step guide, we will walk you through the process of installing PHP 8 on your RHEL 8 or Rocky Linux 8 or CentOS 8 system.

Prerequisites for PHP 8

1. A running instance of RHEL 8 or Rocky Linux 8 or CentOS 8
2. Administrative privileges or sudo user with admin rights
3. A reliable internet connection.

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

1) Apply Updates

Login to your RHEL 8 / Rocky Linux 8 / CentOS 8 system and apply the updates using dnf commands,

$ sudo dnf update

Once all the updates are applied successfully then take a reboot of your system once.

$ sudo reboot

2) Enable EPEL & Remi Repository

PHP 8 is available in the Remi repository, which is not enabled by default in RHEL 8 / Rocky Linux 8 / CentOS 8. Let’s enable it using the following command:

$ sudo dnf install -y https://dl.fedoraproject.org/pub/epel/epel-release-latest-8.noarch.rpm
$ sudo dnf install -y https://rpms.remirepo.net/enterprise/remi-release-8.rpm 
$ sudo dnf install -y dnf-utils

Run below command to list the available versions of PHP,

$ sudo dnf module list php -y

Output of above command would be:

4) Install latest PHP 8.2 using Remi Module

Run the following commands to reset PHP module and install PHP 8.2 from remi-8.2 module.

$ sudo dnf module reset php
$ sudo dnf module install -y php:remi-8.2

Once the PHP packages are installed successfully then execute below command to verify PHP version,

[linuxtechi@rhel8 ~]$ php -v
PHP 8.2.7 (cli) (built: Jun 6 2023 21:28:56) (NTS gcc x86_64)
Copyright (c) The PHP Group
Zend Engine v4.2.7, Copyright (c) Zend Technologies
[linuxtechi@rhel8 ~]$

Great, above output confirms that PHP 8.2 has been installed. This PHP is for http web server.

To Install PHP 8.2 for NGINX web server, we have to install php 8.2 fpm package.

$ sudo dnf install -y php-fpm

Once php-fpm package is installed then start and enable its services by executing following command,

$ sudo systemctl enable php-fpm --now

To verify the status of php-fpm service, run

$ systemctl status php-fpm

PHP 8 extensions can also be installed via dnf command, some of the php 8 extensions installation example are listed below:

$ sudo dnf install -y php-{mysqlnd,xml,xmlrpc,curl,gd,imagick,mbstring,opcache,soap,zip}

5) Configure PHP 8 for HTTPD & NGINX

To configure the PHP 8 for web servers, edit its configuration file and tweak the parameters that suits to your setup.

$ sudo vi /etc/php.ini
………
upload_max_filesize = 32M 
post_max_size = 48M 
memory_limit = 256M 
max_execution_time = 600 
max_input_vars = 3000 
max_input_time = 1000
………

Save & close the file and then restart web server’s service to make above changes into the effect.

For NGINX Web server, php-fpm is configured via its configuration file ‘/etc/php-fpm.d/www.conf’. you can tweak user and group information that suits to your setup. After making the changes, restart the php-fpm service.

That’s all from this post. I hope above step by step procedure helps you to install latest PHP 8.2 on your RHEL 8 / Rocky Linux 8 / CentOS 8 system. Kindly do post your queries and feedback in below comments section.

Also Read : 8 Stat Command Examples in Linux

Hello techies, in this post we will cover how to install and use wireshark in Ubuntu 22.04.

Wireshark is free and open source, cross platform, GUI based Network packet analyzer that is available for Linux, Windows, MacOS, Solaris etc. It captures network packets in real time & presents them in human readable format. It allows us to monitor the network packets up to microscopic level. It also has a command line utility called ‘tshark‘ that performs the same functions as Wireshark but through terminal & not through GUI.

Wireshark can be used for network troubleshooting, analyzing, software & communication protocol development & also for education purposed. Wireshark uses a library called ‘pcap‘ for capturing the network packets.

Wireshark Features

• Support for a hundreds of protocols for inspection,
• Ability to capture packets in real time & save them for later offline analysis,
• A number of filters to analyzing data,
• Data captured can be compressed & uncompressed on the fly,
• Various file formats for data analysis supported, output can also be saved to XML, CSV, plain text formats,
• data can be captured from a number of interfaces like ethernet, wifi, bluetooth, USB, Frame relay , token rings etc.

Prerequisites

• Pre Installed Ubuntu 22.04
• Local User with sudo rights
• Internet Connectivitiy

Wireshark Installation Steps

Wireshark package is available with default Ubuntu repositories & can be simply installed using the following commands. But there might be chances that you will not get the latest version of wireshark.

$ sudo apt update
$ sudo apt install wireshark

Choose Yes to allow non-superusers to capture packets using wireshare

Post successfull installation, access Wireshare UI. Search wireshark from Activities and then click on its icon.

Above confirms that your wireshark installation is completed successfully.

In order to install latest version of wireshark, we must enable official wireshark repository using following apt commands.

$ sudo add-apt-repository ppa:wireshark-dev/stable
$ sudo apt update

Now, Install latest version of wireshark, run

$ sudo apt install wireshark -y

Once the Wireshark is installed, verify its version,

$ wireshark --version

To allow your regular user to use and capture packets using wireshark, run following command

$ sudo dpkg-reconfigure wireshark-common

Choose ‘Yes’  and hit enter

Add your local user to wireshark group using usermod command

$ sudo usermod -aG wireshark $USER
$ newgrp wireshark

To make above changes into the affect, reboot your system once.

$ sudo reboot

Capture Packets Using Wireshark

Start the wireshark, from Activities –> Search Wireshark

Click on Wireshark icon,

All these are the interfaces from where we can capture the network packets. Based on the interfaces you have on your system, this screen might be different for you.

We are selecting ‘enp0s3’  for capturing the network traffic for that inteface. After selecting the inteface, network packets for all the devices on our network start to populate (refer to screenshot below)

First time we see this screen we might get overwhelmed by the data that is presented in this screen & might have thought how to sort out this data but worry not,  one the best features of Wireshark is its filters.

We can sort/filter out the data based on IP address, Port number, can also used source & destination filters, packet size etc & can also combine 2 or more filters together to create more comprehensive searches. We can either write our filters in ‘Apply a Display Filter’ tab , or we can also select one of already created rules. To select pre-built filter, click on ‘flag’ icon , next to ‘Apply a Display Filter’ tab,

We can also filter data based on the color coding, By default, light purple is TCP traffic, light blue is UDP traffic, and black identifies packets with errors , to see what these codes mean, click View  -> Coloring Rules, also we can change these codes.

After we have the results that we need, we can then click on any of the captured packets to get more details about that packet, this will show all the data about that network packet.

To stop capruring the packet, click on Red button and then save the captured packets to a file.

Concusion

Wireshark is an extremely powerful tool takes some time to getting used to & make a command over it, this post will help you get started. Please feel free to drop in your queries or suggestions in the comment box below.

In our previous post, we have already covered how to install Debian 12 step by step. Whether you are a beginner or an experienced user, there are some essential tasks you should consider after the installation. In this post, we’ll explore the top 10 things you can do to optimize your Debian 12 experience and make the most out of this powerful operating system.

1) Disable CD/DVD Package Repository

Whenever we install Debian 12 using DVD / ISO file, installer automatically configure cdrom package repository in /etc/apt/sources.list file. Post installation when we run apt command it will throw an error because cdrom repo does not have a release file. So, to fix this, open the terminal, switch to the root user and comment out the line cdrom entry in /etc/apt/sources.list file.

$ su - root
# vi /etc/apt/sources.list

Save and close the file. Refresh the repository index using following apt command,

# apt update

2) Sudo Rights to Local User

During the installation, we have created a local user but that user that does not have rights to perform any administrative tasks on the system. So, to assign sudo rights to the local user run following usermod command from root user console

$ su - root

# usermod -aG sudo <username>

# usermode -aG sudo linuxtechi

Reboot the system to make above changes into the affect.

After reboot, we can use local user and perform all the administrative tasks just appending sudo in front of each command.

3) Install All available Updates

Run the following apt command to install all the available updates,

$ sudo apt update
$ sudo apt upgrade -y

4) Customize Desktop with Tweak Tool

Using the tweak tool, we change the look and feel of desktop screen.

From the Activity, search Tweak tool and click on it icon

5) Install GNOME Extensions Manager

GNOME extensions manager provides additional functionality to desktop environment. So, to install GNONE extension manager, run beneath command

$ sudo apt install gnome-shell-extension-manager -y

Post installation, access it from the Activity and click on its icon

Click on its icon

From the Browse the window, search the extension that you want to install, for the demonstration purpose, I am going to install Dash to panel.

Click on Install. After the installation, panel will move to bottom of the screen as shown below,

6) Install TimeShift Backup Tool

By default, there is no backup tool for Debian 12, but we can easily install and configure free and opensource Timeshift backup tool.

From Software Center, Search TimeShift,

Click on Timeshift Icon and then click on Install.

7) Enable Night Light Feature

When we enable nigh light feature then it adds yellow-orange light to our desktop screen at night which reduce the eye strain. Even medical studies confirm that the blue light, which is emitted by desktop screen affect our vision, so it is highly recommend enabling night light feature.

So, to enable this feature, Go to Settings –>Display –> Night Light (Disable by default)

8) Enable Firewall

To secure a linux system, it is highly recommended to enable OS firewall. In Debain 12, we have ufw, so enable it, run following commands,

$ sudo apt install ufw -y
$ sudo ufw enable
$ sudo ufw default deny incoming
$ sudo ufw allow outgoing
$ sudo ufw allow ssh

Using above commands, we have blocked all the incoming traffic except ssh and allowed all outgoing traffic.

9) Install Snapd, VLC, FileZilla and thunderbird

Install day to day software that we generally use on our desktop, some of them are like snapd, vlc media player, filezilla and thunderbird email client. So, to install these software run following command,

$ sudo apt install snapd vlc filezilla thunderbird -y

10) Install Slack, Skpe, Google Chrome & Flatpack

Software like slack, skype and google chrome are not available in the default Debian 12 package repositories. In order to install slack, run following snap command,

$ sudo snap install slack

To Install Skype, run following set of commands,

$ wget https://go.skype.com/skypeforlinux-64.deb
$ sudo apt install ./skypeforlinux-64.deb -y

In order to Install Google Chrome Web Browser, run following commands,

$ wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
$ sudo dpkg -i google-chrome-stable_current_amd64.deb

As we know flatpak is  framework for distributing desktop applications across various Linux distributions. So it install and enable it on Debian 12, run following commands,

$ apt install flatpak gnome-software-plugin-flatpak -y
$ sudo flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo

That’s all from this post. I hope you have it informative. Please don’t hesitate to post your queries and feedback in below comments section.

Hello techies, in this post, we will show you how to install Debian 12 desktop edition step-by-step.

Debian 12, code name Bookworm has been released on 10th June 2023 with lot of new features and improvements. Some of the new features are listed below:

• Linux Kernel 6.1
• Support for pipewire
• New wallpapers
• Updated Installer
• Updated Software Packages

Minimum System Requirements for Debian 12

• 2 GB RAM or more
• Dual Core Processor or higher
• 20 GB Disk Space or more
• Bootable Media (USB or DVD)
• Internet Connectivity (Optional)

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

1) Download Debian 12 ISO File

From the following Debian official portal, download the ISO file,

• Download Debian 12 ISO File

Once the ISO file is downloaded then burn it into a flash drive (USB) or DVD and make it bootable. On windows, use Rufus tools to create a bootable media and on Linux use following,

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

2) Boot the System with bootable media

Boot the target system with bootable media (USB or DVD), we will be presented the following screen.

Choose “Graphical Install” and press enter,

3) Select Preferred Language for Debian 12 Installation

Select your preferred language and then click on ‘Continue’

4) Choose Your Location

In this step, choose your preferred location and then click Continue

5) Configure Keyboard

Based on your location, choose your keyboard layout accordingly.

6) Set Hostname and Domain Name

Set the hostname for your system as per your choice,

Click Continue and then you will be prompted to set domain name for your system, so set it accordingly.

7) Set Password for Root User

In this step, you will be asked to set password for the root user,

Click Continue to proceed further.

8) New Local User Details

At this step, you will be asked to fill in the new local user details like Full Name, username, password. So, specify the details according to your installation.

Full Name of User: LinuxTechi

User Name: linuxtechi

password: xxxxxxxx

Click Continue to proceed further,

9) Select Partitioning Scheme

In Debian 12, installer offers following partitioning scheme,

• Guided – use entire disk (This will create partition automatically on the whole disk)
• Guided – use entire disk and setup LVM (This will create LVM based partitions automatically on the whole disk)
• Guided – use entire disk and set up encrypted LVM (This will create LVM based partitions and will encrypt the disk)
• Manual – This will allow you to create manual custom partitions.

In this post, we will go with 2nd option,

Choose the 2nd option and then click on Continue,

In the next screen, select the disk and click on continue,

In the following window, you will be asked to choose partitioning disk scheme. So choose accordingly that suits your installation.

Choose “Separate /home partition” option and click Continue.

Select “Yes” to write changes to disk in the beneath screen,

In the following screen, specify the size of disk that you want to use for Debian 12 installation. I am going to use whole disk.

Click on Continue to proceed further with installation

Choose “Yes” in the following window to format the LVM partitions for Debian 12 installation.

Click Continue

10) Debian 12 Installation Started

At this step, Debian 12 installation has been started and is in progress,

Select “No” to skip scanning media

In the following window, choose “Yes” to configure network mirror

Select the archive mirror country and urls in following window and click continue

In case your system is running behind any proxy server then specify the proxy details in the following screen else skip it.

Click on Continue to proceed further with installation,

Choose “No” in the following screen to skip participation in package survey.

Now, select the Desktop environment and packages that you want to install.

Click Continue to proceed further with installation

In the following window, select “Yes” to install Grub on primary hard drive.

\

Click Continue

Click on Continue to install Grub on /dev/sda drive,

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

Click on Continue to reboot the system as installation is completed.

11) Login Screen and Desktop Post Installation

When system boots up post Debian 12 installation, we will get following login screen, use the same username and its credentials that we have created during the installation.

After entering the credentials, hit enter

Open the terminal and run the following commands,

$ lsb_release -a
$ cat /etc/os-release

Great, this confirms that we have successfully installed Debian 12.

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

Debian 12, code name Bookworm, has been released on June 10th, 2023. It ships with a myriad of new features and improvements over Debian 11.

The latest release of Debian bundles over 11089 new packages, coming to a total of over 64419 packages. Over 67% of the packages in Debian ( this is about 43254 packages)  have been updated, and a further 10% ( about  6,296 packages) that were in Bullseye have been removed and marked as obsolete.

In this post, we look at how to upgrade Debian 11 to Debian 12 via cli step by step. But before we do so, let’s check out some of the key highlights of Debian 12:

What’s new in Debian 12 ?

Here are some of the key highlights of Debian 12:

1.    Linux Kernel 6.1

Debian 12 is powered by Linux kernel 6.1 which is an LTS version that includes numerous enhancements such as improved support for AMD CPUs, experimental support for Rust, and ARM SoC support among many others.

2.    Updated Installer

A new installer is included with Debian 12. It has received several enhancements and other features.

3.    New Wallpaper

As with any other Linux distribution release, Debian 12 includes a new and artistic wallpaper known as ‘Emerald’. It’s quite elegant and polished just like the emerald gemstone from which its name is derived.

4.    Support for Pipewire

Debian 12 provides support for Pipewire out-of-the-box which replaces PulseAudio as the default audio and service.

5.    Newer Software Versions

The latest release of Debian provides the latest software releases which include:

• MariaDB 10.11
• PHP 8.2
• Python 3.11.2
• Nginx 1.22
• OpenJDK 17
• LibreOffice 7.4
• GNOME 43
• Perl 5.36
• Vim 9.0
• Samba 4.17

And many more.  Those are just a few highlights of what to expect in Debian 12. Check out the release notes for more information on what to expect.

Let’s now see how to upgrade Debian 11 to Debian 12.

Step 1: Update the Local Package Index

To get started, it’s a good idea to refresh the package lists on your system as follows:

$ sudo apt update

Step 2: Install All Available Updates

Run the following apt commands one after the another to install all the available updates,

$ sudo apt upgrade
$ sudo apt full-upgrade
$ sudo apt --purge autoremove

Post installing the updates, reboot the system,

$ sudo reboot

Note: Any package which is marked in hold status may cause issue while upgrading so it is recommended to unhold such package before proceeding upgrade.

$ sudo apt-mark showhold | more
$ sudo apt-mark unhold <pkg-name>

Step 3: Update the sources.list file

Since the mission is to upgrade from Debian 11 ( Bullseye) to Debian 12 ( Bookworm) you need to update the /etc/apt/sources.list file by substituting every instance of bullseye with bookworm.

Before making the changes, take the backup of debian 11 sources.list file using beneath cp command,

$ sudo cp -v /etc/apt/sources.list /opt/sources.list-bakup-debian11

Now run sed command to replace every instance of bullseye with bookworm in sources.list file.

$ sudo sed -i 's/bullseye/bookworm/g' /etc/apt/sources.list

Once again, update the package lists to apply the changes made to the package lists.

$ sudo apt update

Step 4: Upgrade to Debian 12

Now upgrade the system by running the following command:

$ sudo apt full-upgrade

We will be prompted the following screen, press ‘q’ to proceed further.

When prompted, Choose “Yes” and press ENTER to proceed. You will most likely run into a few prompts. For example, you might be asked whether to restart services. Choose any option that you deem fit by pressing ENTER.

You will also get prompted to select the version of sshd_config file. Here, we have selected to keep the local version installed.

Similarly, you will get the same message about the GRUB configuration file.

Post upgrade, reboot the system once using following reboot command.

$ sudo reboot

Step 5: Verify Debian 12 After Upgrade

Once the system is back online after reboot, open the terminal and run the following command to check Debian version,

$ lsb_release -a

$ cat /etc/os-release

You can also confirm the kernel version as shown.

$ uname -rms

It is recommended to remove the outdated packages post upgrade using following apt command,

$ sudo apt --purge autoremove

Conclusion

This brings us to the end of this guide. In this tutorial, we showed you how to upgrade to Debian 12 (Bookworm) from Debian 11 (Bulleye).

In this post, we will show you how to setup dynamic nfs provisioning in Kubernetes (k8s) cluster.

Dynamic NFS storage provisioning in Kubernetes allows you to automatically provision and manage NFS (Network File System) volumes for your Kubernetes applications on-demand. It enables the creation of persistent volumes (PVs) and persistent volume claims (PVCs) without requiring manual intervention or pre-provisioned storage.

The NFS provisioner is responsible for dynamically creating PVs and binding them to PVCs. It interacts with the NFS server to create directories or volumes for each PVC.

Prerequisites

• Pre-installed Kubernetes Cluster
• A Regular user which has admin rights on Kubernetes cluster
• Internet Connectivity

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

Step1) Prepare the NFS Server

In my case, I am going to install NFS server on my Kubernetes master node (Ubuntu 22.04). Login to master node and run following commands,

$ sudo apt update
$ sudo apt install nfs-kernel-server -y

Create the following folder and share it using nfs,

$ sudo mkdir /opt/dynamic-storage
$ sudo chown -R nobody:nogroup /opt/dynamic-storage
$ sudo chmod 777 /opt/dynamic-storage

Add the following entries in /etc/exports file

$ sudo vi /etc/exports
/opt/dynamic-storage 192.168.1.0/24(rw,sync,no_subtree_check)

Save and close the file.

Note: Don’t forget to change network in exports file that suits to your deployment.

To make above changes into the effect, run

$ sudo exportfs -a
$ sudo systemctl restart nfs-kernel-server
$ sudo systemctl status nfs-kernel-server

On the worker nodes, install nfs-common package using following apt command.

$ sudo apt install nfs-common -y

Step 2) Install and Configure NFS Client Provisioner

NFS subdir external provisioner deploy the NFS client provisioner in your Kubernetes cluster. The provisioner is responsible for dynamically creating and managing Persistent Volumes (PVs) and Persistent Volume Claims (PVCs) backed by NFS storage.

So, to install NFS subdir external provisioner, first install helm using following set of commands,

$ curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
$ chmod 700 get_helm.sh
$ ./get_helm.sh

Enable the helm repo by running following beneath command,

$ helm repo add nfs-subdir-external-provisioner https://kubernetes-sigs.github.io/nfs-subdir-external-provisioner

Deploy provisioner using following helm command

$ helm install -n nfs-provisioning --create-namespace nfs-subdir-external-provisioner nfs-subdir-external-provisioner/nfs-subdir-external-provisioner --set nfs.server=192.168.1.139 --set nfs.path=/opt/dynamic-storage

Above helm command will automatically create nfs-provisioning namespace and will install nfs provisioner pod/deployment, storage class with name (nfs-client) and will created the required rbac.

$ kubectl get all -n nfs-provisioning
$ kubectl get sc -n nfs-provisioning

Perfect, output above confirms that provisioner pod and storage class is created successfully.

Step 3) Create Persistent Volume Claims (PVCs)

Let’s a create PVC to request storage for your pod or deployment. PVC will request for a specific amount of storage from a StorageClass (nfs-client).

$ vi demo-pvc.yml
kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: demo-claim
  namespace: nfs-provisioning
spec:
  storageClassName: nfs-client
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 10Mi

save & close the file.

Run following kubectl command to create pvc using above created yml file,

$ kubectl create -f demo-pvc.yml

Verify whether PVC and PV are created or not,

$ kubectl get pv,pvc -n nfs-provisioning

Great, above output shows that pv and pvc are created successfully.

Step 4) Test and Verify Dynamic NFS Provisioning

In order to test and verify dynamic nfs provisioning, spin up a test pod using following yml file,

$ vi test-pod.yml
kind: Pod
apiVersion: v1
metadata:
  name: test-pod
  namespace: nfs-provisioning
spec:
  containers:
  - name: test-pod
    image: busybox:latest
    command:
      - "/bin/sh"
    args:
      - "-c"
      - "touch /mnt/SUCCESS && sleep 600"
    volumeMounts:
      - name: nfs-pvc
        mountPath: "/mnt"
  restartPolicy: "Never"
  volumes:
    - name: nfs-pvc
      persistentVolumeClaim:
        claimName: demo-claim

Deploy the pod using following kubectl command,

$ kubectl create -f test-pod.yml

Verify the status of test-pod,

$ kubectl get pods -n nfs-provisioning

Login to the pod and verify that nfs volume is mounted or not.

$ kubectl exec -it test-pod -n nfs-provisioning /bin/sh

Great, above output from the pod confirms that dynamic NFS volume is mounted and accessible.

In the last, delete the pod and PVC and check whether pv is deleted automatically or not.

$ kubectl delete -f test-pod.yml
$ kubectl delete -f demo-pvc.yml
$ kubectl get pv,pvc -n  nfs-provisioning

That’s all from this post, I hope you have found it informative. Feel free to post your queries and feedback in below comments section.

Also Read: How to Install Ansible AWX on Kubernetes Cluster