DEV Community: Syam SV

Unveiling Linux Command's - sar

Syam SV — Mon, 28 Aug 2023 05:08:57 +0000

In the world of computers, the SAR (System Activity Reporter) command is like a magic tool. It helps us understand how our computer is doing and where it might need some help. In this article, we'll take a look at the SAR command and see how it can tell us interesting things about our computer.

What is SAR?

SAR stands for System Activity Reporter. It's like a detective that watches over our computer and takes notes about what it's doing. It looks at what's happening on our computer and makes reports about it. It can tell us things like how busy our computer is, how much memory it's using, how the network is behaving, and much more. It's like a data historian that keeps track of what our computer has been up to.

For detailed matrix information, please refer to here* and here

sar [ options ] [ <interval> [ <count> ] ]

example:

sar -b 1 10

sar -r 1

SAR can do many helpful jobs for us. Let's look at some of them and see what they mean

Checking I/O and Transfer Rate

Imagine your computer is sending and receiving data. SAR can tell us how busy it is doing that. It can count how many times it's doing these jobs and how much data is being sent and received every second.

sar -b [ <interval> [ <count> ] ]

example:

sar -b 1 10

Paging Statistics

Sometimes, our computer needs to get information from the hard drive. This is called paging. SAR can tell us how often this happens and how much data is being moved between the hard drive and the computer's memory.

sar -B [ <interval> [ <count> ] ]

example:

sar -B 1 10

Network Numbers

If our computer is connected to the internet, SAR can tell us how much data is going in and out. It can show us how many packets of data are being sent and received. This helps us understand if our internet connection is fast or slow.

sar -n [options] [ <interval> [ <count> ] ]

example:

sar -n DEV 1 10
sar -n TCP,UDP 1 10

Load and Queue

When our computer is doing many things at once, it has a "load." SAR can tell us how heavy this load is. It can also tell us how many things are waiting to be done. This is like knowing how many people are waiting in line at a store.

sar -q [ <interval> [ <count> ] ]

example:

sar -q 1 10

Memory and Swap Info

Our computer uses memory to work. SAR can show us how much of this memory is being used. It can also tell us if the computer is using "swap space," which is like extra memory.

sar -r [ <interval> [ <count> ] ]

example:

sar -r 1 10

CPU Usage

The "brain" of our computer is called the CPU. SAR can tell us how busy the CPU is. It can say if it's mostly being used by programs, or if it's waiting for something to happen.

sar -u [ <interval> [ <count> ] ]

example:

sar -u 1 10

Page Swapping

Sometimes, the computer needs to exchange data quickly. This is called "swapping." SAR can tell us if this is happening a lot and if it's causing any problems.

sar -W [ <interval> [ <count> ] ]

example:

sar -W 1 10

Conclusion

SAR is like a helpful friend that watches over our computer. It tells us all sorts of things about what's happening inside. Whether it's how busy our computer is, how much memory it's using, or how well the internet is working, SAR gives us answers. So, the next time you're curious about how your computer is performing, remember to ask SAR! Keep in mind that this article provides a simplified overview of SAR, and if you're interested in diving deeper, be sure to refer back to the detailed explanations above.

Unveiling Linux Command's - dmesg

Syam SV — Thu, 24 Aug 2023 12:03:42 +0000

dmesg, short for "diagnostic messages" is a command-line utility in Linux that provides access to the kernel's ring buffer. This buffer stores messages generated by the Linux kernel during the boot process and while the system is running. These messages encompass a wide range of information, including device driver status, hardware initialization, and error messages. Users can rely on the dmesg command for several key reasons:

Boot Process Analysis: When a Linux system boots up, a plethora of hardware components and device drivers are initialized. In case of any failures or warnings during this process, dmesg becomes your go-to tool. Running dmesg immediately after boot can help you identify hardware issues, driver failures, and other critical information.
Kernel Error Diagnosis: Kernel messages displayed by dmesg include errors, warnings, and information about kernel modules. When something goes wrong at the kernel level, dmesg can provide insights into the root cause of the issue, helping you diagnose and rectify the problem promptly
Driver Debugging: dmesg allows you to examine the interaction between your drivers and the kernel, aiding in debugging and improving driver performance.
and more ...

Basic Usage

The simplest way to use dmesg is by running the command without any options

dmesg

This will display the most recent kernel messages, starting from the end of the ring buffer

Severity based filtering

You can filter messages based on their severity levels using the -l or --leveloption. The severity levels include emerg (emergency), alert, crit (critical), err (error), warn (warning), notice, info, and debug.

dmesg -l err,warn

Continuous monitoring

To monitor the kernel messages in real-time as new messages are logged, you can use the -w or --follow option

dmesg -w

Clearing the kernel ring buffer

Sometimes, you might want to clear the ring buffer, such as after diagnosing an issue and wanting to start with a clean slate. This can be done using the -c or --clear

dmesg -c

The dmesg command is a versatile tool that empowers system administrators to gain insights into the inner workings of the Linux kernel. By mastering its various options, you can effectively diagnose issues, analyze system behavior, and ensure the stability and reliability of your Linux systems. Whether you're troubleshooting boot failures, managing devices and drivers, or debugging kernel-level problems, dmesg remains an invaluable asset in your system administration toolkit

Formatting & Mounting Storage Volumes

Syam SV — Thu, 24 Aug 2023 04:48:56 +0000

Listing and Identifying Storage Devices

let's begin by learning how to list and identify the storage devices attached to your system. Using the lsblk command, you can get a comprehensive list of all the block devices, such as hard drives and USB flash drives, connected to your machine.

lsblk

Each storage device is uniquely identified by a device name like sda, sdb, etc., which will help you interact with them.

Creating a Partition Table and Partitions with fdisk

fdisk is a powerful command-line tool that allows you to create and manage partition tables on your storage devices. In this section, it'll walk you through the process of creating a partition table, creating partitions, and writing the changes to the disk.

Be cautious when using fdisk as it directly modifies the disk's partition table. Any incorrect actions may lead to data loss. Make sure you have a backup of your important data before proceeding.

Identify the Disk Device
Before using fdisk, you need to identify the disk device you want to partition. To list all available disks, use the lsblk command:

lsblk

Identify the disk you want to partition, such as /dev/sdX (e.g., /dev/sda, /dev/sdb, etc.), where "X" is the specific letter assigned to the disk by the system.

Launching fdisk

To start partitioning the disk, run fdisk with the chosen disk device:

sudo fdisk /dev/sdX

Replace /dev/sdX with the appropriate disk identifier.

Creating a New Partition Table

If the disk is not yet partitioned or you want to create a new partition table, follow these steps:
a. Press g to create a new GPT (GUID Partition Table) or m to create a new MSDOS (MBR) partition table.

Creating Partitions

To create a new partition, follow these steps:

Press n to start creating a new partition.
Specify the partition number (e.g., 1, 2, etc.).
Specify the starting sector (press Enter for the default).
Specify the ending sector. You can either:
Use a specific size (e.g., +1G for 1 gigabyte) or
Press Enter to use the remaining space on the disk.

Formatting a Storage Device

After creating partitions, you'll typically need to format them with a file system before using them. Once you've identified the storage device you want to utilize, you might need to format it with a specific file system type before you can use it. For Linux, the most common file system types are ext4, while for cross-platform compatibility with Windows, you can use exFAT. Here are the commands to format the partition:

sudo mkfs.ext4 /dev/<device_partition>

sudo mkfs.exfat -n "label" /dev/<device_partition>

Replace with the appropriate partition identifier, such as /dev/sdb1, for your device.

Mounting the Storage Volume

After formatting the partition, you can mount it to make it accessible within the file system. You have the flexibility to mount the partition to any folder you like, but commonly used mount points are /mnt for permanent volumes and /media for temporary ones.

Here's how you can mount the partition:

sudo mount /dev/<device_partition> /<mount_path>

Here, we can see each option can be supplied along with a value when mounting the device.

sudo mount -o uid=<uid>,gid=<group_id> /dev/<device_partition> /<mount_path>

Replace with the directory where you want to access the storage volume.

Analyzing Disk Usage with ncdu

Now, let's introduce you to a powerful storage management tool called ncdu. In case it's not already installed, you might need to install it first. For Fedora and Centos use:

sudo dnf install ncdu

For Debian-based systems, use apt instead of dnf.

Once installed, you can use ncdu to analyze disk usage on your system. This tool provides a detailed breakdown of files and directories consuming the most space. To use ncdu, simply run:

sudo ncdu

It will display the disk usage starting from your current directory. You can navigate through the results, drill down into directories, and identify which files are taking up the most space. This tool is incredibly handy when you need to reclaim storage space on your system.

Automating Mounts with /etc/fstab

For those looking to automate the process of mounting storage volumes during system boot, the /etc/fstab file comes to the rescue. However, editing this file requires caution, as mistakes can prevent your system from booting correctly.

The /etc/fstab file allows you to specify the devices and mount points you want to mount automatically at startup, using UUIDs or device names to identify the storage volumes. Please note that editing this file requires an understanding of the correct syntax and should be approached carefully. If you're unsure, it's best to seek expert guidance or create proper backups before making any changes.

Firewalld Basics and Usage with firewall-cmd:

Syam SV — Mon, 21 Aug 2023 05:54:09 +0000

Firewalld is a robust firewall management tool available for various Linux distributions. It provides a user-friendly interface for managing iptables, the packet filtering system within the Linux kernel. we will walk the fundamentals of setting up and configuring Firewalld using the firewall-cmd command-line utility.

Detailed documentation about Firewalld can be found at the provided link.

Basic Concepts in Firewalld

Firewalld introduces the concept of "zones," which dictate the behavior of the firewall based on the level of trust associated with the networks your system is connected to. Zones provide flexibility, enabling you to tailor rules depending on your environment. For instance, a laptop might need stricter rules on a public WiFi network while being more relaxed on a trusted home network. Predefined zones range from least trusted (e.g., drop, block) to most trusted (trusted, internal). The firewall-cmd utility facilitates the management of these zones.

Zones in Firewalld

In Firewalld, zones are a crucial concept that dictates how the firewall treats network traffic based on the level of trust associated with the networks your system is connected to. Each zone defines a set of rules that determine which traffic is allowed and which is denied. Firewalld allows you to assign different interfaces to different zones, allowing for a flexible approach to network security. Zones are particularly useful for systems that might move between different networks, such as laptops, and for segmenting trust levels on servers.

Default Zones

Firewalld comes with a set of predefined zones, each with a different level of trust. Here are the default zones provided by Firewalld, listed from least trusted to most trusted:

drop : This is the lowest level of trust. All incoming connections are dropped without a reply, and only outgoing connections are possible.
block : Similar to "drop," incoming connections are rejected with an ICMP message. Outgoing connections are allowed.
public : Represents public, untrusted networks. You allow selected incoming connections on a case-by-case basis. This zone is useful for public Wi-Fi networks.
external : Designed for external networks when your system is acting as a gateway. It configures NAT masquerading to keep your internal network private yet reachable.
internal : Used for the internal side of a gateway. This zone assumes more trustworthiness for the computers and allows some additional services.
dmz : Used for computers located in a DMZ (isolated computers that won't access the rest of your network). Only certain incoming connections are allowed.
work : Meant for work machines. You trust most computers on the network, and a few more services might be allowed.
home : Suitable for home environments. It implies a higher level of trust among computers, and more services will be accepted.
trusted : The most open option, to be used sparingly. It trusts all machines in the network.

Targets

Within each zone, there's a concept called "target." A target defines the default behavior of the firewall for incoming traffic. These targets are used to specify what happens when an incoming connection matches the rules of the zone. Here are the common targets used in Firewalld:

default : This is the default target. It allows the default behavior for the zone, which can be controlled further through rule definitions.
accept : Incoming traffic is accepted without restrictions.
drop : Incoming traffic is dropped without any response.
reject : Similar to "drop," but the system responds with an ICMP error message.
masquerade : Used for source NAT (Network Address Translation) to modify the source IP address of outgoing packets.
redirect : Used for destination NAT to redirect incoming packets to a different IP address and port.

Rule Permanence

Firewalld rules can be immediate (active during the current session) or permanent (persist after reboot). The --permanent flag designates permanent rules that apply across reboots. This separation allows testing rules in the current session before making them permanent.

Installing and Enabling Firewalld

To install Firewalld, use your package manager (e.g., sudo apt install firewalld). After installation, enable the service to start at boot:

sudo systemctl enable firewalld

It's recommended to configure your firewall rules and test them before enabling this behavior to avoid potential issues.

Verifying Firewalld Status

Check if Firewalld is up and running:

sudo firewall-cmd --state

A "running" status indicates that the firewall is operational with the default configuration.

Exploring Current Firewall Rules

Get the default zone:

firewall-cmd --get-default-zone

List active zones:

firewall-cmd --get-active-zones

View rules for a zone (e.g., "public"):

sudo firewall-cmd --zone=public --list-all

To move an interface to a different zone during the current session:

sudo firewall-cmd --zone=new-zone --change-interface=interface-name

Adjusting Default Zone

Change the default zone:

sudo firewall-cmd --set-default-zone=new-default-zone

Adding Services to Zones

List available services:

firewall-cmd --get-services

Add a service to a zone (e.g., "public"):

sudo firewall-cmd --zone=public --add-service=service-name

Make the change permanent:

sudo firewall-cmd --zone=public --permanent --add-service=service-name

Opening Ports for Specific Applications

Open a port for a zone (e.g., "public"):

sudo firewall-cmd --zone=public --add-port=port/protocol

Open a port range:

sudo firewall-cmd --zone=public --add-port=start-end/protocol

Defining Custom Services

Copy an existing service definition (e.g., SSH) to create a custom service:

sudo cp /usr/lib/firewalld/services/ssh.xml /etc/firewalld/services/custom-service.xml

Modify the custom service definition in /etc/firewalld/services/custom-service.xml.

Reload the firewall to apply changes:

sudo firewall-cmd --reload

Creating Your Own Zones

Create a new zone (e.g., "custom-zone"):

sudo firewall-cmd --permanent --new-zone=custom-zone

Reload the firewall to activate the new zone:

sudo firewall-cmd --reload

Assign interfaces to the new zone (if interface is not already assigned ):

sudo firewall-cmd --zone=custom-zone --add-interface=interface-name

Firewalld provides an effective way to manage firewall rules using zones and services. By understanding these concepts and the usage of the firewall-cmd utility, you can create tailored firewall configurations that cater to your network environment. Additionally, the installation of Firewalld with nftables enhances your firewall capabilities, contributing to improved security and network management.

Unveiling Linux Command's - rsync

Syam SV — Mon, 21 Aug 2023 05:42:15 +0000

Rsync (Remote Sync) is a command-line utility used for efficiently transferring and synchronizing files and directories between local and remote systems. It uses an algorithm to minimize the amount of data copied by only moving the portions of files that have changed.

Basic Syntax:

The basic syntax of the rsync command is as follows:

rsync [options] source destination

source: The source directory or file you want to transfer.
destination: The target directory or location where you want to copy the source.

Commonly Used Options:

-a or --archive: This option enables archive mode, which preserves file permissions, ownership, timestamps, and more. It's often used for full data synchronization.
-v or --verbose: Enables verbose output, showing details about the files being transferred.
-r or --recursive: Enables recursive mode, ensuring that all subdirectories and their contents are transferred.
--dry-run: Simulates the transfer without actually performing it. Useful for previewing what would be copied.
--delete: Deletes files at the destination that are not present in the source. Useful for maintaining exact synchronization.
-z or --compress: Compresses files during transfer, which can improve transfer speed over slow connections.

Use Cases and Examples:

Local Copy:

To copy files or directories locally, use the basic syntax:

rsync -av source_directory/ destination_directory/

Remote Copy:

To copy files or directories from a local system to a remote server:

rsync -av source_directory/ user@remote_server:/path/to/destination/

Remote Copy with SSH:

To copy files or directories from a local system to a remote server over SSH:

rsync -av -e "ssh -i /path/to/key.pem" source_directory/ user@remote_server:/path/to/destination/

rsync -av -e ssh source_directory/ user@remote_server:/path/to/destination/

Exclude Files or Directories:

To exclude specific files or directories from the transfer:

rsync -av --exclude="file_to_exclude" source_directory/ destination_directory/

Dry Run:

To preview the transfer without actually copying:

rsync -av --dry-run source_directory/ destination_directory/

Delete Unwanted Files:

To remove files at the destination that are not in the source:

rsync -av --delete source_directory/ destination_directory/

Compressed Transfer:

To enable compression during transfer:

rsync -avz source_directory/ user@remote_server:/path/to/destination/

Maintain Metadata:

To ensure metadata consistency during transfers:

rsync -av source_directory/ destination_directory/

Synchronize Remote Directory:

To synchronize a remote directory with a local one:

rsync -av user@remote_server:/path/to/source_directory/ local_destination/

Copying Remote to Local:

To copy files from a remote server to a local machine:

rsync -av user@remote_server:/path/to/source_directory/ local_destination/

Backup option in Rsync

Rsync’s --backup option can be used to store backups of important files. It’s used in along with the --backup-dir option, which specifies the directory where the backup files should be stored

rsync -a --delete --backup --backup-dir=/path/to/backups /path/to/source destination

Conclusion:

Rsync is a versatile tool for efficiently transferring and synchronizing files between local and remote systems. It provides various options that allow you to control the behavior of the transfer, maintain metadata consistency, exclude files, and even simulate transfers before executing them. Its ability to work over SSH ensures secure data transfers across networks, making it an essential tool for managing and backing up data in a Linux environment.

Unveiling Linux Command's - usermod

Syam SV — Mon, 21 Aug 2023 05:39:30 +0000

The usermod command in Linux is a powerful tool that helps system administrators modify various attributes of user accounts. These attributes include user groups, home directories, usernames, and more. It's like a tool that lets you change how a user works with the system.

Adding Users to Groups

Imagine you have a Linux server where you need to give specific users special permissions. This is where usermod comes in handy. You can add a user to an existing group using this command:

sudo usermod -aG <group-name> <username>

For instance, if you want to add a user named "alice" to the "developers" group, the command would look like this:

sudo usermod -aG developers alice

Moving User Home Directories

Home directories are where users store their personal files and settings. If you need to move a user's home directory to a different location, usermod can help:

sudo usermod -d <new-directory> <username>

Suppose you want to move the home directory of the user "bob" to "/newhome":

sudo usermod -d /newhome bob

Changing Usernames

Usernames might need to be changed for various reasons, like rebranding or making usernames consistent across systems. Usermod makes this process simple:

sudo usermod -l <new-username> <old-username>

For example, if you want to change the username "olduser" to "newuser":

sudo usermod -l newuser olduser

User Expiration

Security is crucial in user management. With usermod, you can set an expiration date for a user to enhance security:

sudo usermod -e <expiration-date> <username>

Suppose you want the password for the user "jane" to expire on January 1, 2024:

sudo usermod -e 2024-01-01 jane

Locking and unlocking user

Locking a user account prevents the user from accessing the system. Locking can be helpful in certain situations. To lock a user account using the usermod command:

sudo usermod -L <username>

Unlocking a user account is equally important, as you may need to restore access after resolving a situation. To unlock a user account:

sudo usermod -U <username>

Conclusion

In the world of Linux system administration, the usermod command plays a crucial role in managing user accounts effectively. Its ability to modify user attributes like groups, home directories, usernames, and password expiration dates empowers administrators to maintain a secure and organized system.

Unveiling Linux Command's - scp (Secure Copy)

Syam SV — Mon, 21 Aug 2023 05:37:11 +0000

SCP (Secure Copy) is a command-line utility in Unix-like operating systems that enables secure and efficient file transfers between a local and remote host or between two remote hosts. It is built on top of the SSH protocol, ensuring data confidentiality and integrity during the transfer process. SCP is widely used for transferring files and directories in a secure manner.

Basic Syntax:

scp [options] source destination

Common Options:

-r: Recursively copy directories and their contents.
-p: Preserve modification times, access times, and modes from the original files.
-P port: Specify a different port for SSH. Default is 22.
-i identity_file: Use an identity file (private key) for authentication.

Some common usecases

Copying a File from Local to Remote:

scp file.txt user@remotehost:/path/to/destination/

This copies the local file file.txt to the remote server at the specified path.

Copying a File from Remote to Local:

scp user@remotehost:/path/to/source/file.txt /local/destination/

This copies the remote file file.txt to the local machine at the specified path.

Copying a Directory Recursively:

scp -r directory/ user@remotehost:/path/to/destination/

The -r option allows you to copy the entire directory and its contents.

Copying with a Different Port:

scp -P 2222 file.txt user@remotehost:/path/to/destination/

This command specifies a non-default SSH port (2222) for the transfer.

Preserving File Metadata:

scp -p file.txt user@remotehost:/path/to/destination/

The -p option maintains the original modification times and permissions of the file.

Copying Between Two Remote Hosts:

scp user1@remotehost1:/file.txt user2@remotehost2:/path/to/destination/

This copies a file from one remote host to another.

Using Identity File for Authentication:

scp -i ~/.ssh/my_private_key.pem file.txt user@remotehost:/path/to/destination/

The -i option specifies the private key for SSH authentication.

Comparison with Other Tools:

SCP vs. rsync : SCP is suitable for simple one-time transfers, while rsync is more versatile for syncing and incremental transfers.

Conclusion:

The SCP command provides a secure and efficient way to transfer files and directories between local and remote hosts. Its use cases include simple file transfers, recursive directory transfers, specifying custom SSH ports, preserving file metadata, and more. By leveraging the SSH protocol, SCP ensures data security and integrity during the transfer process.

Unveiling Linux Command's - useradd & adduser

Syam SV — Mon, 21 Aug 2023 05:32:11 +0000

When it comes to managing user accounts on a Linux system, two commonly used commands are useradd and adduser. While both commands are used to create user accounts, they have distinct differences in terms of flexibility, user-friendliness, and functionalities. In this blog post, we'll delve into the nuances of each command and provide step-by-step guides on how to use them.

`useradd` Command

The useradd command is a fundamental utility for creating user accounts on Linux systems. It's a low-level command that allows system administrators to create new users with specific configurations. However, using useradd requires you to set various options manually, which can be more complex and time-consuming, especially for beginners.

To create a user named "newuser," use the following command

sudo useradd newuser

Set a password for the new user

sudo passwd newuser

To specify the home directory for the user, use the -d option

sudo useradd -d /home/customdir newuser

Assign a specific user ID (UID) using the -u option (replace UID with the desired ID):

sudo useradd -u UID newuser

To set an expiration date for the user account, use the -e option followed by the date in YYYY-MM-DD format

sudo useradd -e 2023-12-31 newuser

`adduser` Command

The adduser command is a higher-level utility designed to simplify the process of adding new user accounts. It prompts the user with a series of questions, allowing for interactive configuration. This makes it more user-friendly and suitable for those who are less familiar with command-line options

To start the interactive user creation process, type

sudo adduser newuser

The command will prompt you to set a password, full name, phone number, etc., for the new user. You can specify additional information such as the home directory, user groups, and expiration date for the account

Conclusion

In summary, both the useradd and adduser commands serve the purpose of creating user accounts on Linux systems. The choice between them depends on your level of familiarity with command-line options and the degree of user interaction you desire. If you're comfortable with configuring options manually, useradd offers fine-grained control. On the other hand, if you prefer a more user-friendly and interactive approach, adduser is a better choice.

Regardless of the command you choose, managing user accounts is a critical aspect of Linux system administration. Select the command that aligns with your needs and expertise to efficiently create and manage user accounts on your system.

Unveiling Linux Command's - find

Syam SV — Sat, 19 Aug 2023 14:28:13 +0000

Searching for files on your Linux system can sometimes feel like searching for a needle in a haystack. The find command is here to make your file-finding tasks easy. In this post, we'll walk you through various scenarios where the find command becomes very useful.

Finding files by name

Ever found yourself hunting for a file but forgetting where you stashed it? The find command can help you pinpoint it. When you're in your terminal, type

find /path/to/search -name "filename"

Just replace /path/to/search with your starting directory and filename with the elusive file's name.

Finding files by size

Sometimes you're dealing with large files, and sometimes it's the tiny ones causing a stir. find can help with that too! To locate files based on their size, use

find /path/to/search -size +size_unit

Replace/path/to/search with your directory and size_unit with the size you're after (like 10M for 10 megabytes). To find small files, use - instead of +.

Finding files by user

Who's the owner of that file? find can answer that. To discover files owned by a specific user or group

find /path/to/search -user username

Replace /path/to/search with your directory and username with the owner's name. Similar to the user scenario, you can also use -group groupname to find files owned by a particular group.

Finding files by permission

Permissions can be quite the puzzle. But findcan help you unravel it. To identify files with specific permissions, type:

find /path/to/search -perm permissions

Here, /path/to/search is your directory, and permissions are the numeric values (like 755 for read, write, and execute). If you want files with any of the specified permission bits, use -perm /permissions.

Finding files by date and time

The find command help you to navigate through time and locate files based on their access, modification, or change times.

find /path/to/search -atime/-ctime/-mtime +/-time_unit

Replace /path/to/search with your directory, pick atime, ctime, or mtime, and adjust +/-time_unit to specify the time frame.

Following are some example cases to understand

Find Recently Modified Files in the a directory

Imagine you've made some recent changes to your system configuration files in a directory, and you want to identify files that have been modified within the last 10 minutes

find /path/to/search  -mmin -10

This command will provide you with a list of files in the /etc directory that have been modified within the last 10 minutes.

Locate Recently Changed files

To find files that have been changed within the last 2 days across multiple important directories, use this find command

find /usr/bin /usr/sbin -ctime -2

By executing this command, you'll obtain a list of files that have undergone changes in the specified time frame.

Identify Unused Files in Web Directories

When managing websites, it's important to keep track of files that haven't been accessed for a while. For instance, let's say you want to find files in the /var/www directory that haven't been accessed for over 300 days. Here's the find command to achieve that:

find /var/www -atime +300

Upon executing this command, you'll receive a list of files within the specified directories that meet the time-based criteria.

Finding files and executing commands

The find command is not just about discovering files; it's also about taking action on them. This is where the -exec flag comes into play. With it, you can execute a command on each file that matches your search criteria.

find /path/to/search -name "filename" -exec command {} \;

For example, find text files and print their contents

find /home/user/documents -name "*.txt" -exec cat {} \;

Interactively Approve Actions

Sometimes, before making changes to files, you want to be sure. The -ok flag in find enables an interactive mode that asks for your confirmation before executing a command on each file.

find /path/to/search -name "filename" -ok command {} \;

For example safely deleting files

find /home/user/trash_files -name "*~" -ok rm {} \;

With these scenarios, find becomes a tool not only for locating files but also for performing actions on them, whether you're printing file contents or confirming deletions. It adds a layer of efficiency and control to your file management tasks

Logical Volume Manager (LVM) in Linux - A Walkthrough - Part 2

Syam SV — Fri, 18 Aug 2023 18:55:28 +0000

Logical Volume Manager (LVM) provides several benefits such as dynamic resizing, volume snapshots, and simplified disk management. In this Part, we'll walk through how to achieve these tasks.

Remember to exercise caution as these commands can affect your storage and preferably use a virtual machine and virtual disks to test around as example shown below.

You can use the lsblk command to check the disk layout of your system

lsblk

Creating Physical Volumes

To create physical volumes on existing partitions, use the following pvcreate command. This will erase any data in the respective disks :

pvcreate <...list of block devices...>

example:

pvcreate /dev/sdb1 /dev/sdb2 /dev/sdc1

List the created physical volumes

pvdisplay

Creating Volume Groups

Create a volume group with the vgcreate command

vgcreate volume_group_name <...list of physical volumes... >

example

vgcreate vgvolume /dev/sdb1 /dev/sdb2 /dev/sdc1

Display information about the volume group

vgdisplay

Creating Logical Volumes

Create logical volumes using lvcreate:

lvcreate -n name -L size[G,M] volume_group_name

example

lvcreate -n LV_main -L 7G vgvolume
lvcreate -n LV_secondary -L 1G vgvolume

Display information about the logical volumes

lvdisplay

we can mount the logical volume's by using the mount command

 mount /dev/vgvolume/LV_main /mnt/my_mount_point

Extending LVM

Extending Logical Volumegives a flexible way to manage storage by dynamically resizing logical volumes and effectively utilizing newly added physical storage.

Adding New Physical Volumes:

When additional physical storage is available, connect a new drive to the system. Create a new physical volume on this drive using the pvcreate command

example:

pvcreate /dev/sdd

Extending the Volume Group:

Extend the existing volume group to incorporate the newly created physical volume

vgextend vgvolume /dev/sdd

Replace vgvolume with the name of your volume group and the physical volume with appropriate name .

Extending Logical Volumes:

Extend the size of the desired logical volume to utilize the added space. In following example command, where LV_main is the name of the logical volume and i am adding 10GB to LV_main

lvextend -L +10G LV_main

Resizing the Filesystem:

After extending the logical volume, the filesystem within it needs to be resized to utilize the additional space. For ext2/3/4 filesystems, use the resize2fs command or xfs_growfs for XFS filesystems

resize2fs /dev/vgvolume/LV_main

Snapshots with LVM

Snapshots in Logical Volume Management (LVM) offer a powerful way to capture a point-in-time copy of a logical volume, allowing for data preservation, testing, and recovery.

LVM allows you to create a snapshot of a logical volume. In the following example command, you can see how to create a snapshot named snapshot_name of the LV_main logical volume, with a size of 1GB

lvcreate -L 1G -s -n snapshot_name /dev/vgvolume/LV_main

To see the used space of all snapshots, run

lvs

This command provides information about logical volumes, including snapshots and the orgin of the snapshot (ie. the orginal logical volume)

You can mount a snapshot like any other block device. Use this command to mount the snapshot at a specified mount point

mount /dev/vgvolume/snapshot_name /mnt/snapshot_mount_point

And to restore a snapshot, first unmount the original logical volume if it's currently mounted

umount /mnt/snapshot_mount_point

Then, restore the snapshot back to the original logical volume using

lvconvert --merge /dev/vgvolume/snapshot_name

This operation merges the changes made to the snapshot back into the original volume. After restoring a snapshot, you may need to deactivate and reactivate the logical volume to ensure proper functioning

lvchange -an /dev/vgvolume/LV_main
lvchange -ay /dev/vgvolume/LV_main

Using LVM snapshots can provide a safety net when making changes to data or systems, allowing you to experiment without fear of losing critical information. However, keep in mind that snapshots consume space, and frequent or large snapshots can affect overall storage performance. Always monitor your storage usage and consider proper management strategies

Conclusion

In conclusion, Logical Volume Manager (LVM) is a versatile tool that offers dynamic storage management capabilities, making it an indispensable asset for system administrators, DevOps professionals, and anyone involved in managing storage resources efficiently. With LVM, you can resize volumes on the fly, create snapshots for data safety, and simplify disk management tasks. Remember that while LVM is a powerful tool, proper management practices are essential.

Logical Volume Manager (LVM) in Linux - Introduction - Part 1

Syam SV — Fri, 18 Aug 2023 18:02:44 +0000

Logical Volume Manager (LVM) is a technology and system for managing disk storage in Linux and other Unix-like operating systems. It provides a layer of abstraction between physical storage devices and the operating system, allowing for more flexible and dynamic management of storage resources. LVM offers several advantages over traditional disk partitioning, making it a popular choice for managing storage in modern Linux systems.

Physical Volumes (PVs)

Physical Volumes are actual storage devices, such as hard drives or solid-state drives.
LVM abstracts these physical devices into PVs, which are the building blocks of logical storage management.
PVs can span entire disks or only specific partitions.

Volume Groups (VGs)

Volume Groups are created by grouping one or more physical volumes together.
VGs act as a pool of storage space that can be used to create logical volumes.
They provide a level of isolation between physical devices and logical volumes.

Logical Volumes (LVs)

Logical Volumes are the virtual partitions created within volume groups.
LVs provide the filesystems and storage space that the operating system and applications use.
They can be easily resized, extended, or shrunk without affecting other logical volumes.

Snapshots

Snapshots are read-only copies of logical volumes at a specific point in time.
They are useful for creating backups or testing changes without affecting the original data.
Snapshots are created quickly and consume minimal additional space.

Advantages of LVM

Dynamic Resizing: LVM allows you to resize logical volumes and filesystems while the system is running, avoiding the need to unmount or reboot.
Flexibility: LVM provides a way to abstract and pool physical storage, making it easier to manage and allocate space as needed.
Storage Management: LVM simplifies storage management tasks such as adding new disks, extending volumes, and managing storage space across multiple drives.
Volume Snapshots: LVM enables the creation of read-only snapshots of logical volumes, facilitating data backups and recovery.
Data Striping and Mirroring: LVM allows you to configure data striping (RAID 0) and data mirroring (RAID 1) for improved performance and redundancy.
Logical Volume Migration: LVM enables the migration of data between physical volumes, helping to optimize storage performance.
Less Risky: Unlike traditional partitions, where resizing or changing requires significant effort and can be risky, LVM offers safer and more flexible alternatives.

Use Cases

LVM is beneficial in various scenarios:

Server environments where storage needs are dynamic and may change over time.
Virtualization environments where logical volumes can be allocated to virtual machines.
Database servers that require flexible storage for growing data.
Systems where data protection is crucial, thanks to mirroring and snapshot

Conclusion

Logical Volume Manager (LVM) provides an efficient and flexible way to manage storage in Linux systems. By abstracting physical storage into logical volumes, LVM simplifies tasks such as resizing, extending, and managing storage space. Its dynamic resizing capabilities, support for snapshots, and data protection features make it a powerful tool for modern storage management needs.

Exploring Vagrant: Snapshots - Part 6

Syam SV — Fri, 18 Aug 2023 12:12:02 +0000

A snapshot is a saved state of a virtual machine at a specific point in time. This allows you to capture the current state of the virtual machine and return to it later if needed. Snapshots are useful for various scenarios, such as testing different configurations, rolling back changes, and isolating development environments.

Creating a Snapshot

To create a snapshot of a running virtual machine, use the vagrant snapshot save command followed by the snapshot name:

vagrant snapshot save <VM Name> <Snapshot Name>

Example :

vagrant snapshot save my-vm snapshot1

Vagrant snapshots invoke the "snapshots" method of the provider. In the case of using Vagrant snapshot with VirtualBox, it triggers VirtualBox's snapshot functionality and the snapshots will be stored in the same location where the virtual machine was created.

Listing Snapshots

To list all the snapshots associated with a virtual machine, use the vagrant snapshot list
command:

vagrant snapshot list

or to list snapshots of a specific VM

vagrant snapshot list <VM Name>

Roll Back or Restoring a Snapshot

You can roll back a virtual machine to a snapshot by restoring it. This is particularly useful when you want to revert to a known state before making changes. To restore a virtual machine to a specific snapshot, use the vagrant snapshot restore command.

vagrant snapshot restore <VM Name> <Snapshot Name>

Example:

vagrant snapshot restore default snap1

Deleting a Snapshot

To delete a snapshot, use the vagrant snapshot delete command:

vagrant snapshot delete <VM Name> <Snapshot Name>

Example :

vagrant snapshot delete default snap1

Remember that snapshots consume disk space, and managing them is important to avoid excessive disk usage. Also, snapshots might not capture every aspect of the system, such as network configurations, so be aware of potential limitations.

DEV Community: Syam SV

Unveiling Linux Command's - sar

What is SAR?

Checking I/O and Transfer Rate

Paging Statistics

Network Numbers

Load and Queue

Memory and Swap Info

CPU Usage

Page Swapping

Conclusion

Unveiling Linux Command's - dmesg

Basic Usage

Severity based filtering

Continuous monitoring

Clearing the kernel ring buffer

Formatting & Mounting Storage Volumes

Listing and Identifying Storage Devices

Creating a Partition Table and Partitions with fdisk

Launching fdisk

Creating a New Partition Table

Creating Partitions

Formatting a Storage Device

Mounting the Storage Volume

Analyzing Disk Usage with ncdu

Automating Mounts with /etc/fstab

Firewalld Basics and Usage with firewall-cmd:

Basic Concepts in Firewalld

Zones in Firewalld

Default Zones

Targets

Rule Permanence

Installing and Enabling Firewalld

Verifying Firewalld Status

Exploring Current Firewall Rules

Adjusting Default Zone

Adding Services to Zones

Opening Ports for Specific Applications

Defining Custom Services

Reload the firewall to apply changes:

Creating Your Own Zones

Unveiling Linux Command's - rsync

Basic Syntax:

Commonly Used Options:

Use Cases and Examples:

Local Copy:

Remote Copy:

Remote Copy with SSH:

Exclude Files or Directories:

Dry Run:

Delete Unwanted Files:

Compressed Transfer:

Maintain Metadata:

Synchronize Remote Directory:

Copying Remote to Local:

Backup option in Rsync

Conclusion:

Unveiling Linux Command's - usermod

Adding Users to Groups

Moving User Home Directories

Changing Usernames

User Expiration

Locking and unlocking user

Conclusion

Unveiling Linux Command's - scp (Secure Copy)

Basic Syntax:

Common Options:

Some common usecases

Copying a File from Local to Remote:

Copying a File from Remote to Local:

Copying a Directory Recursively:

Copying with a Different Port:

Preserving File Metadata:

Comparison with Other Tools:

Conclusion:

Unveiling Linux Command's - useradd & adduser

useradd Command

adduser Command

Conclusion

Unveiling Linux Command's - find

`useradd` Command

`adduser` Command