"Simplify Bash Scripting : Beginner to Pro with 50 Essential Scripts" 🧑‍💻

Hey there! 👋 Ever heard of Bash? It's like the "cool kid" of the command-line world, similar to the Windows Command Prompt (CMD), but with a twist! 🔄 If you haven't delved into it yet, you're in for a treat!

🚀 Bash is "Simplify Your Life with Bash: 50 Scripts to Boost Prodyour trusty sidekick for controlling your computer via text commands. Used by major tech companies worldwide, it's simple yet powerful. With just a few keystrokes, you can zip through tasks faster than clicking around with a mouse and GUI.

💻 Even if you're on Windows, fear not! You can tap into Bash's power through Windows Subsystem for Linux (WSL). Suddenly, daunting tasks become effortless! So, dive in and discover how Bash can supercharge your computing experience. It's worth it!

Here's a list of 50 common Bash scripts with explanations:

Hello World: Prints "Hello, World!" to the terminal.

Title: "Hello, Bash World: Your First Step into Scripting Brilliance"

Script:
```
 #!/bin/bash
 echo "Hello, World!"
```
Explanation: "This script serves as your initiation into the realm of Bash scripting brilliance. With a simple 'echo' command, it prints the timeless message 'Hello, World!' to the terminal, marking the beginning of your journey into the world of scripting mastery."
Script Title: File Backup
```
 #!/bin/bash
 source_dir="/path/to/source"
 backup_dir="/path/to/backup"
 timestamp=$(date +%Y%m%d%H%M%S)
 backup_file="backup_$timestamp.tar.gz"
 tar -czvf "$backup_dir/$backup_file" "$source_dir"
```
Explanation:
This script creates a timestamped backup of a directory using tar compression. It specifies the source directory and backup directory paths, generates a timestamp, and creates a backup file with the timestamp appended to its name using tar compression.

Script Title: Directory Listing
```
 #!/bin/bash
 ls -l
```
Explanation:
This script lists files and directories in the current directory with details, including permissions, ownership, size, and modification time.

Script Title: File Count
```
 #!/bin/bash
 file_count=$(ls | wc -l)
 echo "Number of files: $file_count"
```
Explanation:
This script counts the number of files in the current directory using the ls command piped into wc -l, which counts the lines. It then echoes the count with an informative message.

Script Title: Disk Usage
```
 #!/bin/bash
 df -h
```
Explanation:
This script displays disk usage information, including total, used, and available disk space, and usage percentage for all mounted filesystems.

Script Title: System Info
```
 #!/bin/bash
 uname -a
```
Explanation:
This script prints system information, including the kernel version, hostname, architecture, and operating system.

Script Title: File Rename
```
 #!/bin/bash
 old_name="old.txt"
 new_name="new.txt"
 mv "$old_name" "$new_name"
```
Explanation:
This script renames a file from "old.txt" to "new.txt" using the mv command.

Script Title: File Permissions
```
 #!/bin/bash
 file="file.txt"
 chmod +x "$file"
```
Explanation:
This script grants execute permission to a file named "file.txt" using the chmod command.

Script Title: User Info
```
 #!/bin/bash
 username=$(whoami)
 echo "Current user: $username"
```
Explanation:
This script retrieves the current user's username using the whoami command and echoes it with an informative message.

Script Title: Process List
```
 #!/bin/bash
 ps aux
```
Explanation:
This script lists all running processes along with detailed information, including the process ID, CPU usage, memory usage, and command.

Script Title: Process Kill
```
 #!/bin/bash
 process_id=12345
 kill -9 "$process_id"
```
Explanation:
This script kills a process by its process ID using the kill command with the -9 signal, which forces termination.

Script Title: Check Internet Connection
```
 #!/bin/bash
 ping -c 5 google.com
```
Explanation:
This script checks internet connectivity by pinging Google five times and displaying the results.

Script Title: Disk Cleanup
```
 #!/bin/bash
 du -sh /var/log/*
 rm -rf /var/log/*
```
Explanation:
This script displays disk usage of log files in the "/var/log" directory and then deletes them using the rm command with the -rf options.Conclusion: These scripts cover various tasks, from basic file operations to advanced tasks like JSON parsing and PDF conversion. Start with simpler scripts and gradually move to complex ones as you gain familiarity with Bash. 📝

Script Title: System Shutdown
```
 #!/bin/bash

 # Shutdown the system immediately
 shutdown -h now
```
Explanation: This script utilizes the shutdown command with the -h option to initiate an immediate system shutdown. The -h option specifies a halt action, causing the system to shut down completely. By using the now parameter, the shutdown process begins immediately without any delay. This script is useful for quickly shutting down the system when needed.

Script Title: System Reboot
```
 bashCopy code#!/bin/bash

 # Reboot the system
 reboot
```
Explanation: This script simply initiates a system reboot using the reboot command. When executed, the system will be restarted, causing all processes to terminate, and the operating system to reload, resulting in a full system reboot.

Script Title: File Search
```
 bashCopy code#!/bin/bash

 # Define search directory and search term
 search_dir="/path/to/search"
 search_term="pattern"

 # Search for specified pattern recursively in files within the search directory
 grep -r "$search_term" "$search_dir"
```
Explanation: This script facilitates file searching by utilizing the grep command with the -r option, which recursively searches for the specified pattern ($search_term) within files located in the designated search directory ($search_dir). This script is helpful for quickly locating files containing specific content or patterns within a directory structure.

Script Title: Disk Space Alert
```
 #!/bin/bash

 # Set disk space threshold (percentage)
 threshold=90

 # Get current disk usage percentage for root filesystem
 current_usage=$(df -h / | awk 'NR==2 {print $5}' | tr -d '%')

 # Check if current disk usage exceeds the threshold
 if [ "$current_usage" -ge "$threshold" ]; then
     echo "Disk space is running low!"
 else
     echo "Disk space is okay."
 fi
```
Explanation: This script monitors disk space usage by retrieving the percentage of disk space used on the root filesystem (/). It compares this usage with a predefined threshold (threshold). If the current usage exceeds the threshold, an alert message indicating low disk space is displayed; otherwise, a message confirming sufficient disk space is printed.

Script Title: Check Service Status
```
 #!/bin/bash

 # Specify the service name to check
 service_name="nginx"

 # Check if the service is active
 if systemctl is-active --quiet "$service_name"; then
     echo "$service_name is running."
 else
     echo "$service_name is not running."
 fi
```
Explanation: This script checks the status of a specified system service (nginx in this case) using the systemctl is-active command. If the service is active, a message confirming that the service is running is displayed. Otherwise, a message indicating that the service is not running is printed. This script is useful for monitoring the status of critical system services.

Script Title: System Backup Script
```
 #!/bin/bash

 # Define source and backup directories
 source_dir="/path/to/source"
 backup_dir="/path/to/backup"

 # Generate timestamp
 timestamp=$(date +%Y%m%d%H%M%S)

 # Define backup file name with timestamp
 backup_file="backup_$timestamp.tar.gz"

 # Create timestamped backup using tar compression
 tar -czvf "$backup_dir/$backup_file" "$source_dir"
```
Explanation: This script automates the process of creating a timestamped backup of a directory specified by $source_dir. It generates a timestamp using the date command and constructs a backup file name incorporating this timestamp. The tar command is then used to compress and archive the contents of the source directory, creating the backup file in the specified backup directory ($backup_dir).

Script Title: Log Rotation
```
 #!/bin/bash

 # Specify log file and maximum log size
 log_file="/path/to/logfile.log"
 max_log_size=10M

 # Check if log file exists
 if [ -f "$log_file" ]; then
     # Get current size of log file
     current_size=$(du -b "$log_file" | awk '{print $1}')

     # Check if current size exceeds maximum log size
     if [ "$current_size" -ge "$max_log_size" ]; then
         # Rotate log file by renaming it
         mv "$log_file" "$log_file.old"

         # Create a new empty log file
         touch "$log_file"
     fi
 fi
```
Explanation: This script implements log rotation by checking the size of the specified log file ($log_file). If the log file exists and its size exceeds the maximum log size ($max_log_size), it renames the existing log file by appending ".old" to its name and creates a new empty log file in its place. This ensures that log files do not grow indefinitely and helps manage disk space usage.

Script Title: User Management
```
 #!/bin/bash

 # Define username and password
 username="newuser"
 password="password123"

 # Create a new user
 useradd "$username"

 # Set password for the new user
 echo "$username:$password" | chpasswd
```
Explanation: This script automates user management tasks by creating a new user ($username) and setting their password ($password). It uses the useradd command to create the user and the chpasswd command to set the password for the user. This script simplifies the process of user creation and password assignment.

Script Title: File Encryption
```
 #!/bin/bash

 # Specify the file to encrypt
 file_to_encrypt="file.txt"

 # Encrypt the file using GPG
 gpg -c "$file_to_encrypt"
```
Explanation: This script encrypts a specified file ($file_to_encrypt) using GPG (GNU Privacy Guard). The -c option is used with gpg to perform symmetric encryption, which requires a passphrase to encrypt and decrypt the file.

Script Title: File Decryption
```
 #!/bin/bash

 # Specify the encrypted file
 encrypted_file="file.txt.gpg"

 # Decrypt the encrypted file and save as decrypted_file.txt
 gpg -d "$encrypted_file" > "decrypted_file.txt"
```
Explanation: This script decrypts an encrypted file ($encrypted_file) using GPG. The -d option is used with gpg to decrypt the file. The decrypted content is then redirected (>) to a new file named decrypted_file.txt.

Script Title: File Compression
```
 #!/bin/bash

 # Specify the compressed file
 compressed_file="compressed_file.tar.gz"

 # Decompress the file using tar and gzip
 tar -xzvf "$compressed_file"
```
Explanation: This script decompresses a specified compressed file ($compressed_file) using the tar command with options -x (extract), -z (use gzip), and -v (verbose). The file is decompressed and its contents are extracted to the current directory.

Script Title: File Decompression
```
 #!/bin/bash

 # Specify the compressed file
 compressed_file="compressed_file.tar.gz"

 # Decompress the file using tar and gzip
 tar -xzvf "$compressed_file"
```
Explanation: This script decompresses a specified compressed file ($compressed_file) using the tar command with options -x (extract), -z (use gzip), and -v (verbose). The file is decompressed and its contents are extracted to the current directory.

Script Title: CSV File Processing
```
 #!/bin/bash

 # Specify the input CSV file and output text file
 input_csv="data.csv"
 output_file="output.txt"

 # Extract specific columns from the CSV file and save them to a new file
 awk -F ',' '{print $1,$2}' "$input_csv" > "$output_file"
```
Explanation: This script processes a CSV file ($input_csv) and extracts specific columns using awk command. The -F ',' option specifies that the fields are separated by commas. Columns 1 and 2 are extracted and saved to a new text file ($output_file).

Script Title: Log Analysis
```
 #!/bin/bash

 # Specify the log file
 log_file="access.log"

 # Count unique IP addresses and total error occurrences
 unique_ips=$(awk '{print $1}' "$log_file" | sort -u | wc -l)
 error_count=$(grep -c 'ERROR' "$log_file")

 # Display analysis results
 echo "Unique IPs: $unique_ips"
 echo "Total Errors: $error_count"
```
Explanation: This script analyzes an access log file ($log_file) to count unique IP addresses and occurrences of errors. It uses awk to extract IP addresses from the log file, sort -u to filter out duplicate IP addresses, and wc -l to count the number of unique IP addresses. It also uses grep -c to count the occurrences of 'ERROR' in the log file. Finally, it displays the analysis results.

Script Title: Send Email Alert
```
 #!/bin/bash

 # Define email parameters
 email="user@example.com"
 subject="Alert"
 message="Disk space is running low!"

 # Send email alert
 echo "$message" | mail -s "$subject" "$email"
```
Explanation: This script sends an email alert to a specified email address ($email) with a subject ($subject) and message ($message). It utilizes the mail command to send the email with the provided subject and message.

Script Title: Database Backup
```
 #!/bin/bash

 # Define database name and backup file name
 db_name="mydb"
 backup_file="backup.sql"

 # Create MySQL database backup
 mysqldump -u username -p$password "$db_name" > "$backup_file"
```
Explanation: This script creates a backup of a MySQL database ($db_name) using mysqldump command with specified username and password. The backup is then saved to a file named $backup_file.

Script Title: SSH Key Generation
```
 #!/bin/bash

 # Generate an SSH key pair
 ssh-keygen -t rsa -b 4096 -f ~/.ssh/mykey
```
Explanation: This script generates an SSH key pair using the ssh-keygen command with RSA encryption, 4096-bit key size, and the specified file path (~/.ssh/mykey).

Script Title: SSH Key Copy
```
 #!/bin/bash

 # Copy SSH public key to a remote server for passwordless login
 ssh-copy-id user@hostname
```
Explanation: This script copies the SSH public key to a remote server (user@hostname) using the ssh-copy-id command, enabling passwordless login to the remote server using the generated SSH key pair.

Script Title: File Comparison
```
 #!/bin/bash

 # Define file paths
 file1="file1.txt"
 file2="file2.txt"

 # Compare two files and print result
 if cmp -s "$file1" "$file2"; then
     echo "Files are identical."
 else
     echo "Files are different."
 fi
```
Explanation: This script compares two files ($file1 and $file2) using the cmp command. If the files are identical, it prints "Files are identical." Otherwise, it prints "Files are different."

Script Title: Cron Job Example
```
 #!/bin/bash

 # Define backup directory and timestamp
 backup_dir="/path/to/backup"
 timestamp=$(date +%Y%m%d%H%M%S)

 # Create backup file with timestamp
 backup_file="backup_$timestamp.tar.gz"

 # Perform backup using tar
 tar -czvf "$backup_dir/$backup_file" /path/to/source
```
Explanation: This script creates a timestamped backup file using tar command and compresses it using gzip. It is suitable for scheduling as a cron job to automate backups at regular intervals.

Script Title: Folder Synchronization
```
 #!/bin/bash

 # Define source and destination directories
 source_dir="/path/to/source"
 destination_dir="/path/to/destination"

 # Synchronize contents of source directory to destination directory using rsync
 rsync -av "$source_dir/" "$destination_dir/"
```
Explanation: This script synchronizes the contents of two directories ($source_dir and $destination_dir) using the rsync command with options -av (archive mode and verbose output), ensuring that the destination directory matches the source directory's contents.

Script Title: URL Download
```
 #!/bin/bash

 # Define URL and output file name
 url="https://example.com/file.txt"
 output_file="downloaded_file.txt"

 # Download file from URL using wget
 wget "$url" -O "$output_file"
```
Explanation: This script downloads a file from a specified URL ($url) using the wget command and saves it to a file with the specified output file name ($output_file).

Script Title: Input Validation
```
 #!/bin/bash

 # Prompt user to enter a number
 read -p "Enter a number: " number

 # Validate input to ensure it is a number
 if [[ ! "$number" =~ ^[0-9]+$ ]]; then
     echo "Invalid input. Please enter a number."
 else
     echo "You entered: $number"
 fi
```
Explanation: This script prompts the user to enter a number and validates the input using a regular expression. If the input is not a number (i.e., it does not consist entirely of digits), it displays an error message. Otherwise, it confirms the input.

Script Title: String Manipulation
```
 #!/bin/bash

 # Define the input string
 string="Hello, World!"

 # Convert the string to uppercase
 uppercase_string=$(echo "$string" | tr '[:lower:]' '[:upper:]')

 # Print the uppercase string
 echo "$uppercase_string"
```
Explanation: This script demonstrates how to manipulate strings in Bash by converting a given string to uppercase using the tr command.

Script Title: File Watcher
```
 #!/bin/bash

 # Specify the directory to watch
 directory="/path/to/watch"

 # Watch the directory for file changes using inotifywait
 inotifywait -m -r -e create,modify,delete "$directory" |
 while read path action file; do
     echo "File $file was $action."
 done
```
Explanation: This script utilizes inotifywait to monitor a specified directory for file creation, modification, or deletion events. It continuously listens for such events and prints a message indicating the action performed on the file.

Script Title: JSON Parsing
```
 #!/bin/bash

 # Define the JSON string
 json_string='{"name": "John", "age": 30}'

 # Extract specific fields from the JSON string using jq
 name=$(echo "$json_string" | jq -r '.name')
 age=$(echo "$json_string" | jq -r '.age')

 # Print the extracted fields
 echo "Name: $name, Age: $age"
```
Explanation: This script demonstrates parsing JSON data and extracting specific fields (name and age) using the jq command-line JSON processor.

Script Title: Zip File Compression
```
 #!/bin/bash

 # Specify the file to compress
 file_to_compress="file.txt"

 # Compress the file using ZIP compression
 zip "compressed_file.zip" "$file_to_compress"
```
Explanation: This script compresses a specified file using ZIP compression.

Script Title: Zip File Extraction
```
 #!/bin/bash

 # Specify the ZIP file to extract
 zip_file="compressed_file.zip"

 # Extract files from the ZIP archive
 unzip "$zip_file"
```
Explanation: This script extracts files from a specified ZIP archive.

Script Title: PDF Conversion
```
 #!/bin/bash

 # Specify the input document and output PDF file
 input_file="document.docx"
 output_file="document.pdf"

 # Convert the document to PDF using LibreOffice
 libreoffice --headless --convert-to pdf "$input_file"
```
Explanation: This script converts a document to PDF format using LibreOffice.

Script Title: CSV to Excel
```
 #!/bin/bash

 # Specify the input CSV file and output Excel file
 input_csv="data.csv"
 output_xlsx="data.xlsx"

 # Convert the CSV file to an Excel (XLSX) file using ssconvert
 ssconvert "$input_csv" "$output_xlsx"
```
Explanation: This script converts a CSV file to an Excel (XLSX) file using Gnumeric’s ssconvert.

Script Title: File Splitting
```
 #!/bin/bash

 # Specify the input file to split
 input_file="large_file.txt"

 # Split the input file into smaller parts
 split -b 1M "$input_file" "split_file"
```
Explanation: This script splits a large file into smaller parts of 1MB each using the split command.

Script Title: File Joining
```
 #!/bin/bash

 # Concatenate split files to reconstruct the original file
 cat split_file* > "large_file.txt"
```
Explanation: This script joins split files (with names starting with "split_file") to reconstruct the original file. It uses the cat command to concatenate the contents of split files into a single file named "large_file.txt".

Script Title: IP Address Validation
```
 #!/bin/bash

 # Prompt user to enter an IP address
 read -p "Enter an IP address: " ip_address

 # Validate input as an IP address
 if [[ $ip_address =~ ^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
     echo "Valid IP address: $ip_address"
 else
     echo "Invalid IP address."
 fi
```
Explanation: This script validates user input as an IP address using a regular expression. It prompts the user to enter an IP address and checks if the input matches the pattern of four numbers separated by periods.

Script Title: URL Validation
```
 #!/bin/bash

 # Prompt user to enter a URL
 read -p "Enter a URL: " url

 # Validate input as a URL
 if [[ $url =~ ^(http|https)://[A-Za-z0-9.-/]+$ ]]; then
     echo "Valid URL: $url"
 else
     echo "Invalid URL."
 fi
```
Explanation: This script validates user input as a URL using a regular expression. It prompts the user to enter a URL and checks if the input matches the pattern of a URL starting with "http://" or "https://" followed by alphanumeric characters, periods, hyphens, and slashes.

Script Title: File Permissions Report
```
 #!/bin/bash

 # Generate a report of file permissions for all files in a directory
 find /path/to/files -type f -exec ls -l {} \; > permissions_report.txt
```
Explanation: This script creates a report of file permissions for all files in a specified directory (/path/to/files). It uses the find command to locate files, -type f to filter regular files, -exec ls -l {} \; to list detailed permissions for each file, and redirects the output to a file named "permissions_report.txt".

Script Title: Password Generator
```
 #!/bin/bash

 # Specify password length and characters to use
 length=12
 characters="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()"

 # Generate a random password
 password=$(head /dev/urandom | tr -dc "$characters" | head -c "$length")

 # Print the generated password
 echo "Generated Password: $password"
```
Explanation: This script generates a random password of specified length ($length) using characters from a predefined set ($characters). It reads random data from /dev/urandom, filters characters using tr -dc, and selects the specified length using head -c. Finally, it prints the generated password.

Enjoy scripting! 🚀

Conclusion:

Mastering Bash scripting opens up a world of possibilities, streamlining your workflow and saving you countless hours. 💡 Whether you're a seasoned pro or just starting out, these scripts will be invaluable tools in your arsenal. So, roll up your sleeves, dive into the world of Bash, and experience the true power of automation! 🚀

Thank you for joining me on this journey through the world of cloud computing! Your interest and support mean a lot to me, and I'm excited to continue exploring this lfascinating field together. Let's stay connected and keep learning and growing as we navigate the ever-evolving landscape of technology.

LinkedIn Profile: https://www.linkedin.com/in/prasad-g-743239154/

Feel free to reach out to me directly at spujari.devops@gmail.com. I'm always open to hearing your thoughts and suggestions, as they help me improve and better cater to your needs. Let's keep moving forward and upward!

If you found this blog post helpful, please consider showing your support by giving it a round of applause👏👏👏. Your engagement not only boosts the visibility of the content, but it also lets other DevOps and Cloud Engineers know that it might be useful to them too. Thank you for your support! 😀

Thank you for reading and happy deploying! 🚀

Best Regards,

Sprasad

"Simplify Bash Scripting : Beginner to Pro with 50 Essential Scripts" 🧑‍💻

Script Title: File Backup

Script Title: Directory Listing

Script Title: File Count

Script Title: Disk Usage

Script Title: System Info

Script Title: File Rename

Script Title: File Permissions

Script Title: User Info

Script Title: Process List

Script Title: Process Kill

Script Title: Check Internet Connection

Script Title: Disk Cleanup

Script Title: System Shutdown

Script Title: System Reboot

Script Title: File Search

Script Title: Disk Space Alert

Script Title: Check Service Status

Script Title: System Backup Script

Script Title: Log Rotation

Script Title: User Management

Script Title: File Decryption

Script Title: File Compression

Script Title: File Decompression

Script Title: CSV File Processing

Script Title: Log Analysis

Script Title: Send Email Alert

Script Title: Database Backup

Script Title: SSH Key Generation

Script Title: SSH Key Copy

Script Title: File Comparison

Script Title: Cron Job Example

Script Title: Folder Synchronization

Script Title: URL Download

Script Title: Input Validation

Script Title: String Manipulation

Script Title: File Watcher

Script Title: JSON Parsing

Script Title: Zip File Compression

Script Title: Zip File Extraction

Script Title: PDF Conversion

Script Title: CSV to Excel

Script Title: File Splitting

Script Title: File Joining

Script Title: IP Address Validation

Script Title: URL Validation

Script Title: File Permissions Report

Script Title: Password Generator