Forem: Muhammad Hanzala Ali

BashBlaze Day 4: Building a System Monitoring Script with Bash

Muhammad Hanzala Ali — Fri, 15 Nov 2024 17:11:16 +0000

Welcome to Day 4 of the BashBlaze - 7 Days of Bash Scripting Challenge! Today, we’re tackling an essential skill in the DevOps toolkit: creating a script to monitor system metrics. This task will help you build a deeper understanding of Bash scripting, system monitoring, and user interaction. Ready to take your scripting game up a notch? Let’s dive in!

The Goal: A Robust Monitoring Script

The mission for today’s challenge is to develop a Bash script that:

Monitors CPU usage, memory usage, and disk space.
Provides a simple, interactive menu.
Continuously displays metrics with user-defined intervals.
Monitors the status of specific services like Nginx.
Handles errors gracefully.

Task Breakdown

Task 1: Basic Metrics Monitoring

Start by writing a basic script to display CPU, memory, and disk space information:

#!/bin/bash

# Function to display system metrics
show_metrics() {
    echo "\n---- System Metrics ----"
    echo "CPU Usage: $(top -bn1 | grep 'Cpu(s)' | awk '{print $2 + $4}')%"
    echo "Memory Usage: $(free -m | awk '/Mem:/ {printf("%d/%dMB (%.2f%%)", $3, $2, $3*100/$2)}')"
    echo "Disk Space: $(df -h / | awk 'NR==2 {print $5}')"
    echo "\nPress Enter to continue..."
    read
}

Task 2: User-Friendly Interface

Enhance the script by creating a menu that allows users to select different options:

while true; do
    clear
    echo "---- Monitoring Metrics Script ----"
    echo "1. View System Metrics"
    echo "2. Monitor a Specific Service"
    echo "3. Exit"
    read -p "Choose an option (1-3): " choice

    case $choice in
        1) show_metrics;;
        2) monitor_service;;
        3) echo "Exiting..."; break;;
        *) echo "Invalid option. Please try again."; sleep 2;;
    esac
done

Task 3: Continuous Monitoring with Sleep

To enable continuous monitoring, add a loop with a sleep mechanism that pauses between each refresh:

read -p "Enter sleep interval in seconds: " sleep_interval
while true; do
    show_metrics
    sleep $sleep_interval
done

Task 4: Monitor Specific Services
Expand the script to check the status of services such as Nginx:

monitor_service() {
    read -p "Enter the service name to monitor: " service
    if systemctl is-active --quiet $service; then
        echo "$service is running."
    else
        echo "$service is not running. Do you want to start it? (Y/N)"
        read start_choice
        if [[ $start_choice == "Y" || $start_choice == "y" ]]; then
            sudo systemctl start $service
            echo "$service started."
        else
            echo "$service was not started."
        fi
    fi
    echo "\nPress Enter to continue..."
    read
}

Task 5: Allow User to Choose Different Services

Add flexibility by letting users input any service they wish to monitor.

Task 6: Error Handling

Ensure the script includes error handling to manage command failures and invalid inputs. Use conditional checks and meaningful error messages to enhance user experience.

Conclusion

This Day 4 challenge empowers you with the knowledge to create a monitoring script that’s both practical and versatile. With user-friendly features and a touch of DevOps flair, this project is an excellent addition to your Bash scripting portfolio.

What creative name did you give your script? Share your progress and feedback in the comments!

BashBlaze Day 3: Tackling User Management with Bash (And a Few Laughs!)

Muhammad Hanzala Ali — Mon, 11 Nov 2024 17:17:23 +0000

Day 3 of my Bash Blaze challenge has arrived, and it’s packed with user management commands. It was all fun and games until I realized I was the Bash overlord controlling accounts on my system. Here’s how I conquered this challenge and wrote a script so slick that even my cat looked impressed (or maybe it was just yawning).

Challenge Overview: User Management Bash Script

The task: create a Bash script that handles user accounts like a pro—or at least like a DevOps engineer trying to impress HR.😀

The Game Plan:

Account Creation: Add users and make sure they’re not already on the list (because cloning is creepy).
Account Deletion: Remove users (with their home directories for bonus cleanup points).
Password Reset: Reset passwords while pretending I’m a hacker in a movie montage.
User Listing: Display all users like it’s a roll call at school.
Help Command: Because every good script should offer unsolicited advice.

The Code That Makes the Magic Happen

#!/bin/bash

<<note
Usage: ./user_management.sh [Options]
note

# Displaying usage information like a helpful Bash superhero
function display_usage {
        echo "Usage: ./user_management.sh [Options]"
        echo "Options:"
        echo "-c, --create      Create a new user account."
        echo "-d, --delete      Delete an existing user account."
        echo "-r, --reset       Reset password for an existing user account."
        echo "-l, --list        List all user accounts on the system."
        echo "-h, --help        Display this help and exit."
}

# Creating a new user account (because why not play God?)
function create_user {
        read -p "Enter the new username: " new_user

        if id "$new_user" &>/dev/null; then
                echo "Error: The username '$new_user' already exists. Maybe try 'user2.0'?"
                exit 1
        else
                read -sp "Enter password for $new_user: " password
                sudo useradd -m -p "$(openssl passwd -1 "$password")" "$new_user"
                echo -e "\nUser '$new_user' created successfully. They owe you big time."
        fi
}

# Deleting a user account (peace out, user!)
function delete_user {
        read -p "Enter the username to delete: " username

        if id "$username" &>/dev/null; then
                sudo userdel -r "$username"
                echo "User '$username' deleted. Gone, but not forgotten (unless you use rm -rf)."
        else
                echo "Error: The username '$username' does not exist. Did they ghost us?"
        fi
}

# Resetting passwords (because 'password123' is so last season)
function reset_passwd {
        read -p "Enter the username to reset password for: " reset_user

        if id "$reset_user" &>/dev/null; then
                read -sp "Enter new password for '$reset_user': " password
                echo "$reset_user:$password" | sudo chpasswd
                echo -e "\nPassword for '$reset_user' reset. Use wisely, young Padawan."
        else
                echo "Error: '$reset_user' not found. Check your spelling or your luck."
        fi
}

# Listing user accounts (because we're nosy)
function list_users {
        echo "Here are the current VIPs (Very Important Password-holders):"
        awk -F: '{ print "- " $1 " (UID: " $3 ")" }' /etc/passwd
}

# Script begins here
if [ $# -eq 0 ] || [[ "$1" == "-h" ]] || [[ "$1" == "--help" ]]; then
        display_usage
        exit 0
fi

while [ $# -gt 0 ]; do
        case "$1" in
                -c | --create)
                        create_user
                        ;;
                -d | --delete)
                        delete_user
                        ;;
                -r | --reset)
                        reset_passwd
                        ;;
                -l | --list)
                        list_users
                        ;;
                *)
                        echo "Error: Invalid option '$1'. Try '--help' for better luck."
                        exit 1
                        ;;
        esac
        shift
done

Key Bash Commands for User Management

1. Creating Users
sudo useradd -m username
Explanation: The -m flag ensures a home directory is created for the new user. This simple command is a must for adding users quickly.

2. Setting Passwords
sudo passwd username
This command lets you set or change a password for a user, essential for maintaining secure access.

3. Deleting Users
sudo userdel -r username
The -r flag removes the user's home directory along with their profile, ensuring a complete cleanup.

4. Adding Users to Groups
sudo usermod -aG groupname username
The -aG option appends the user to an existing group without removing them from other groups.

Pro Tip:

Always double-check user permissions with:

groups username
This helps you verify that the user is part of the correct groups and has the appropriate access.

Challenges Faced and How I Overcame Them

During Day 3, I encountered scenarios where user permissions needed to be fine-tuned for specific scripts. Here’s how I tackled these challenges:

Error: User already exists
Solution: Use id username to check user existence before creation.
Permissions Denied
Solution: Apply chmod and chown commands to fix permissions on directories.

Real-World Application

User management is not just theoretical; it plays a significant role in CI/CD pipelines, ensuring only authorized users can deploy code or make changes. Integrating these Bash skills into your daily tasks can simplify user access management and enhance security protocols.

Conclusion

Day 3 of my Bash Blaze challenge was both insightful and practical. Learning these user management commands has empowered me to be more confident in my DevOps journey. As I move on to Day 4, which promises even more exciting concepts, I invite you to follow along and join me in mastering Bash scripting.

BashBlaze Day 2: Directory Backup with Rotation (Part-2)

Muhammad Hanzala Ali — Thu, 31 Oct 2024 17:40:33 +0000

Introduction

Welcome back to Day 2 of the BashBlaze - 7 Days of Bash Scripting Challenge!
For this challenge, we’ll create a bash script to automate directory backups with rotation, ensuring that only the most recent versions are stored. This is especially useful in real-world scenarios where storage space matters, and we need to manage backup files efficiently.

Challenge Description

Our goal is to:

Create a bash script that accepts a directory path as a command-line argument.
Generate timestamped backups for the specified directory.
Implement a rotation mechanism to keep only the last three backups, removing the oldest ones automatically.

The script will backup all files in the specified directory and ensure we retain only the three latest backups by removing older ones, keeping our backup folder clutter-free and manageable.

Solution Code

Here’s the bash script that accomplishes our goal:

#!/bin/bash

<<note
This script creates a timestamped backup with rotation, keeping only the last 3 backups.

Usage:
./backup_with_rotation.sh <source_directory> <backup_directory>
note

# Function to display usage information
function display_usage {
    echo "Usage: ./backup_with_rotation.sh <source_directory> <backup_directory>"
}

# Validate command-line arguments
if [ $# -ne 2 ] || [ ! -d "$1" ]; then
    echo "Error: Please provide a valid source directory path and a backup directory."
    display_usage
    exit 1
fi

# Define source and backup directories
source_dir=$1
backup_dir=$2
timestamp=$(date '+%Y-%m-%d-%H-%M-%S')

# Function to create a timestamped backup
function create_backup {
    zip -r "${backup_dir}/backup_${timestamp}.zip" "${source_dir}" > /dev/null
    if [ $? -eq 0 ]; then
        echo "Backup created successfully: ${backup_dir}/backup_${timestamp}.zip"
    fi
}

# Function to keep only the last 3 backups
function perform_rotation {
    # List backups in reverse chronological order
    backups=($(ls -t "${backup_dir}/backup_"*.zip 2>/dev/null))

    # If there are more than 3 backups, delete the oldest ones
    if [ "${#backups[@]}" -gt 3 ]; then
        echo "Performing rotation to keep only the last 3 backups..."
        backups_to_remove=("${backups[@]:3}")
        for backup in "${backups_to_remove[@]}"; do
            rm -f "${backup}"
            echo "Removed old backup: $backup"
        done
    fi
}

# Main script execution
create_backup
perform_rotation

How It Works

Here’s a breakdown of the main components of the script:

## Usage Information:

The script begins by providing a usage note to guide users on the command format.

## Command-Line Argument Validation:

Ensures that both source and backup directories are provided.
Displays an error message if the arguments are missing or invalid.

## Timestamped Backup Creation:

Uses the create_backup function to generate a compressed .zip backup of the source directory.
Names the backup using the current timestamp for easy tracking.

## Backup Rotation:

The perform_rotation function checks if there are more than three backups.

If so, it removes the oldest backups, keeping only the latest three, thus saving space and maintaining recent copies.

Example Usage

Here’s what the script looks like in action:

First Execution

$ ./backup_with_rotation.sh /home/user/documents /home/user/backups
Output:
Backup created successfully: /home/user/backups/backup_2023-07-30_12-30-45.zip

Second Execution with Rotation

When there are more than three backups, the oldest one is removed automatically:

$ ./backup_with_rotation.sh /home/user/documents /home/user/backups
Output:
Backup created successfully: /home/user/backups/backup_2023-08-01_09-15-30.zip
Performing rotation to keep only the last 3 backups...
Removed old backup: /home/user/backups/backup_2023-07-30_12-30-45.zip

Conclusion

Today’s script covers essential automation for backup management with a focus on storage efficiency. By using rotation to retain only the most recent backups, this solution is practical and scalable, especially for servers and personal systems that require regular backups.

Submission Instructions

Push your backup_with_rotation.sh script to your GitHub repository and share your progress with the community! Looking forward to hearing about your experience and any creative ways you apply this script!

BashBlaze Day 2: Building an Interactive File and Directory Explorer (Part-1)

Muhammad Hanzala Ali — Wed, 30 Oct 2024 18:16:35 +0000

Introduction

*Welcome to Day 2 of the BashBlaze - 7 Days of Bash Scripting Challenge! *
Today, we’re stepping up our bash scripting skills by creating an Interactive File and Directory Explorer that not only lists files and directories in the current path but also provides a character counting feature for any text entered by the user.

This challenge is a hands-on approach to working with loops, command-line interaction, and command chaining in bash. Let’s dive into the tasks and explore how each part of this interactive script works!

Challenge Breakdown

Our script has two main functions:

Part 1: File and Directory Exploration
Part 2: Character Counting
Let’s go over each of these parts in detail with code examples.

Part 1: File and Directory Exploration

In the first part of this challenge, we’re building an interactive explorer that displays all files and directories in the current path in a human-readable format.

Here's the solution for Part 1:

#!/bin/bash

# Part1: Files & Directory Exploration
echo "Welcome to the Interactive File and Directory Explorer!"

while true; do
    # List all files and directories in the current path
    echo "Files and Directories in the Current Path:"
    ls -lh

The ls -lh command lists all files and directories in the current path. The -l flag shows detailed information, and -h makes sizes human-readable (KB, MB, etc.).

Part 2: Character Counting

After displaying files and directories, the script moves to character counting for user input. It prompts the user to enter a line of text and counts the characters in each line until the user presses Enter without entering text, which exits the script.

Here’s the solution for Part 2:

  # Part2: Character Counting
    read -p "Enter a line of text (Press Enter without text to exit): " input

    # Exit if the input is empty
    if [[ -z "$input" ]]; then
          echo "Exiting the Interactive Explorer. Goodbye!"
          break
    fi

    # Calculate and print the character count for the input line
    char_count=$(echo -n "$input" | wc -m)
    echo "Character count: $char_count"
done

Explanation:

read -p prompts the user for input.
if [[ -z "$input" ]]; then ... checks if the input is empty and breaks the loop if so.
echo -n "$input" | wc -m counts the characters in the input without counting the newline.

Full Solution

Here’s the complete solution for Day 2:

#!/bin/bash

# Part1: Files & Directory Exploration
echo "Welcome to the Interactive File and Directory Explorer!"

while true; do
    # List all files and directories in the current path
    echo "Files and Directories in the Current Path:"
    ls -lh

    # Part2: Character Counting
    read -p "Enter a line of text (Press Enter without text to exit): " input

    # Exits when the input is empty
    if [[ -z "$input" ]]; then
          echo "Exiting the Interactive Explorer. Goodbye!"
          break
    fi

    # Calculate and print the character count for the input line
    char_count=$(echo -n "$input" | wc -m)
    echo "Character count: $char_count"
done

Example Interaction:

$ ./explorer.sh
Welcome to the Interactive File and Directory Explorer!

Files and Directories in the Current Path:
- file1.txt (100 KB)
- dir1 (2 MB)
- script.sh (3 KB)

Enter a line of text (Press Enter without text to exit): Hello, this is a sample line.
Character Count: 27

Enter a line of text (Press Enter without text to exit): Another line to count.
Character Count: 25

Enter a line of text (Press Enter without text to exit):
Exiting the Interactive Explorer. Goodbye!

Conclusion

Today’s challenge was all about building an interactive experience using bash scripting. We learned how to:

Use loops to maintain an interactive session.
Display files and directories with human-readable sizes.
Capture and count characters in user input. This exercise has shown the power of bash scripting for real-world tasks. Stay tuned for Day 3, where we’ll explore even more advanced topics in bash scripting.

BashBlaze Day 1: Mastering the Basics of Bash Scripting

Muhammad Hanzala Ali — Sun, 20 Oct 2024 13:58:09 +0000

Introduction

Welcome to Day 1 of the BashBlaze - 7 Days of Bash Scripting Challenge! Whether you're new to scripting or just brushing up, this day is all about the fundamentals of bash scripting. We'll cover comments, echo commands, variables, built-in variables, and wildcards to get you started. Each task is designed to give you hands-on experience with essential bash scripting features.

Let’s dive in and go through each task with a solution so you can follow along and implement them yourself!

Task 1: Comments in Bash

Comments are essential for making your scripts readable and maintainable. They help you and others understand what the script is doing at a glance.

Solution:

# Task 1: Comments
<< comment
    This script demonstrates how to use comments in bash.
comment

In this script, we used both single-line comments (using #) and multi-line comments (using a here-document << comment). Adding comments to your code is a great way to provide context and make your scripts easy to understand.

Task 2: Using Echo in Bash

The echo command is one of the simplest yet most powerful commands for outputting text in bash scripts. You can use it to print any message to the terminal.

Solution:

# Task 2: Echo
echo "Hello World!"

This script prints "Hello World!" to the terminal, a classic first step in learning any programming language. The echo command can be used in combination with variables and complex expressions, which we will explore in later tasks.

Task 3: Declaring Variables

Variables allow us to store and reuse data throughout our scripts. Let’s declare a variable and print its value.

Solution:

# Task 3: Variables
text="Declare Variable"
echo "$text"

In this example, we store the string "Declare Variable" in the variable text and print its value using echo. Remember to use $ when referencing the value of a variable in bash.

Task 4: Using Variables to Perform Arithmetic

Variables are not just for strings; you can also use them for numerical operations. Let's use variables to calculate the sum of two numbers.

Solution:

# Task 4: Using Variables
a=5
b=3
sum=$((a+b))
echo "The sum is $sum"

Here, we declare two variables a and b with the values 5 and 3, respectively. We then use the $(( ... )) syntax to perform arithmetic and print the result.

Task 5: Working with Built-in Variables

Bash comes with several built-in variables that provide useful information about the environment. Let's explore some of them.

Solution:

# Task 5: Using Built-in Variables
echo "Exit status of the last command: $?"
echo "Process ID of the current script: $$"
echo "Current working directory: $PWD"
echo "Home directory: $HOME"

$? returns the exit status of the last executed command.
$$ gives the process ID of the current script.
$PWD displays the current working directory.
$HOME shows the home directory path. These built-in variables are very useful in real-world scripting scenarios.

Task 6: Using Wildcards in Bash

Wildcards are used for pattern matching, making it easy to work with files and directories. Let’s use a wildcard to list all files with a specific extension.

Solution:

# Task 6: Wildcards
echo "List all .sh files in the current directory:"
ls *.sh

The *.sh wildcard matches all files with the .sh extension in the current directory. Wildcards are extremely handy when working with multiple files, especially for tasks like file manipulation and searching.

Conclusion

Congratulations on completing Day 1 of the BashBlaze Challenge! Today we covered the basics of bash scripting, from comments and echo commands to variables, built-in variables, and wildcards. These foundational skills will set you up for success as we move on to more advanced topics in the coming days. Stay tuned for Day 2, where we'll dive deeper into conditional statements and loops!

Make sure to commit your script to GitHub and share your progress. Happy scripting!

My GitHub repository link: Click Here

Key Takeaways

*Comments * help in explaining your code.
The echo command is used to print messages.
Variables store data that can be reused.
Built-in Variables provide useful information like the process ID, current directory, and more.
Wildcards allow you to match file patterns efficiently. If you found this helpful, be sure to check back for Day 2 of the BashBlaze Challenge, where we’ll take things up a notch!