Bash Automation: A Step-by-Step Linux Tutorial

Table of Contents

1. What is Bash and Bash Automation?
2. Setting Up Your Environment
3. Your First Bash Script
4. Variables in Bash
5. Control Structures: Conditionals (If-Else)
6. Loops in Bash (For & While)
7. Functions in Bash
8. Input/Output Redirection
9. Error Handling in Scripts
10. Scheduling Scripts with Cron
11. Real-World Example: Automated Backup Script
12. Best Practices for Bash Scripting
13. Conclusion
14. References

1. What is Bash and Bash Automation?

Bash is a command-line shell and scripting language used to interact with the Linux operating system. It processes commands entered by the user or stored in a script (a text file with a sequence of commands).

Bash automation involves writing such scripts to automate tasks that would otherwise require manual execution. Common use cases include:

• Backing up files/databases
• Rotating log files
• Monitoring system resources (CPU, memory)
• Installing/updating software
• Renaming/moving files in bulk

2. Setting Up Your Environment

Before writing scripts, ensure your environment is ready:

Check if Bash is Installed

Most Linux systems (Ubuntu, Fedora, Debian) come with Bash preinstalled. Verify with:

echo $SHELL  # Output: /bin/bash (if Bash is your default shell)
bash --version  # Displays Bash version

Choose a Text Editor

Use a text editor to write scripts. Popular options:

• nano (simple, beginner-friendly)
• vim/neovim (powerful, terminal-based)
• VS Code (graphical, with Bash extensions)

Make Scripts Executable

Bash scripts are plain text files, but to run them directly, you need to mark them as executable with chmod +x scriptname.sh.

Shebang Line

Every script should start with a shebang line (#!/bin/bash) to tell the system to use Bash to interpret the script.

3. Your First Bash Script

Let’s start with a simple “Hello World” script to get comfortable.

Step 1: Create the Script File

Open your text editor and create a file named hello.sh:

nano hello.sh

Step 2: Add the Shebang and Commands

Paste the following into hello.sh:

#!/bin/bash
# This is a comment (ignored by Bash)
echo "Hello, Bash Automation!"

Step 3: Make It Executable

Run:

chmod +x hello.sh

Step 4: Run the Script

Execute the script with:

./hello.sh  # Output: Hello, Bash Automation!

Explanation:

• #!/bin/bash: Shebang line (required).
• # This is a comment: Comments help explain the script (optional but recommended).
• echo "...": Prints text to the terminal.

4. Variables in Bash

Variables store data (text, numbers) for reuse in scripts. They make scripts dynamic and flexible.

Declaring Variables

Variables are declared without spaces:

name="Alice"  # Correct (no spaces around =)
# name = "Alice"  # Incorrect (spaces cause errors)

Accessing Variables

Use $ to access a variable’s value:

echo "Hello, $name!"  # Output: Hello, Alice!

Environment Variables

Bash provides built-in environment variables (e.g., $HOME for your home directory, $USER for your username). Example:

echo "Your home directory is: $HOME"  # Output: /home/alice
echo "You are logged in as: $USER"    # Output: alice

User Input with read

Use read to get input from the user. Example script (greet_user.sh):

#!/bin/bash
read -p "Enter your name: " name  # -p prompts the user
echo "Hello $name! Your home directory is $HOME."

Run it:

chmod +x greet_user.sh
./greet_user.sh
# Enter your name: Bob
# Output: Hello Bob! Your home directory is /home/bob.

5. Control Structures: Conditionals (If-Else)

Conditionals let scripts make decisions based on criteria (e.g., “if a file exists, do X; else do Y”).

Basic If-Else Syntax

if [ condition ]; then
  # Code to run if condition is true
else
  # Code to run if condition is false
fi

Common Conditions

Example: Check if a File Exists

Create check_file.sh:

#!/bin/bash
read -p "Enter a filename: " filename

if [ -f "$filename" ]; then
  echo "File $filename exists!"
else
  echo "Error: File $filename not found."
fi

Test it with an existing file (e.g., hello.sh) and a non-existent file (e.g., missing.txt).

6. Loops in Bash (For & While)

Loops repeat a block of code multiple times (e.g., “process all .txt files in a folder”).

For Loops

Iterate over a list (files, numbers, strings):

Example 1: Iterate Over Files

#!/bin/bash
echo "Files in current directory:"
for file in *; do  # * matches all files in the current directory
  echo "- $file"
done

Example 2: Range of Numbers

#!/bin/bash
echo "Counting from 1 to 5:"
for i in {1..5}; do  # {1..5} is a range (1,2,3,4,5)
  echo $i
done

While Loops

Repeat code as long as a condition is true:

Example: Countdown Timer

#!/bin/bash
count=5
while [ $count -ge 0 ]; do
  echo "Countdown: $count"
  count=$((count - 1))  # Decrement count by 1
  sleep 1  # Pause for 1 second
done
echo "Blast off!"

Run it:

chmod +x countdown.sh
./countdown.sh
# Output: Countdown: 5, 4, 3, 2, 1, 0, Blast off!

7. Functions in Bash

Functions group reusable code into a single block, making scripts cleaner and easier to maintain.

Function Syntax

function_name() {
  # Code here
  echo "This is a function"
}

Passing Arguments to Functions

Functions access arguments with $1, $2, etc. (like scripts):

#!/bin/bash
greet() {
  local name=$1  # "local" limits variable scope to the function
  echo "Hello $name!"
}

greet "Alice"  # Output: Hello Alice!
greet "Bob"    # Output: Hello Bob!

Returning Values

Bash functions return exit codes (0 = success, non-zero = error), but you can “return” strings/numbers using echo and capture them with $(function_name):

#!/bin/bash
add_numbers() {
  local a=$1
  local b=$2
  echo $((a + b))  # Echo the result to "return" it
}

sum=$(add_numbers 5 3)
echo "5 + 3 = $sum"  # Output: 5 + 3 = 8

8. Input/Output Redirection

Redirect script output to files or read input from files instead of the terminal.

Common Redirection Operators

Example: Logging Script Output

Modify hello.sh to log to a file:

#!/bin/bash
echo "Hello, Bash Automation!" > script.log  # Overwrites script.log
echo "Current time: $(date)" >> script.log   # Appends to script.log

Run it and check script.log:

./hello.sh
cat script.log
# Output:
# Hello, Bash Automation!
# Current time: Wed Oct 11 14:30:00 2023

9. Error Handling in Scripts

Poorly handled errors can break scripts or cause unintended behavior. Use these techniques to make scripts robust:

Exit on Error with set -e

Add set -e at the top of your script to exit immediately if any command fails:

#!/bin/bash
set -e  # Exit on error
echo "This line runs."
false  # This command fails (exit code 1)
echo "This line will NOT run (script exits after 'false')."

Treat Unset Variables as Errors with set -u

set -u prevents scripts from using undefined variables (avoids silent failures):

#!/bin/bash
set -u
echo "Hello $name"  # Error: name is unset (script exits)

Cleanup with trap

Use trap to run commands when the script exits (e.g., delete temporary files):

#!/bin/bash
temp_file="temp.txt"
trap "rm -f $temp_file; echo 'Cleanup done.'" EXIT  # Runs on script exit

echo "Creating temp file..."
touch $temp_file
sleep 5  # Press Ctrl+C to test; cleanup still runs!

10. Scheduling Scripts with Cron

To run scripts automatically (e.g., daily backups at 2 AM), use cron—Linux’s task scheduler.

Crontab Syntax

Cron jobs are defined in a crontab (cron table) file with the format:

* * * * * command_to_run
- - - - -
| | | | |
| | | | +-- Day of the week (0=Sun, 6=Sat)
| | | +---- Month (1-12)
| | +------ Day of the month (1-31)
| +-------- Hour (0-23)
+---------- Minute (0-59)

Common Cron Examples

Edit Crontab

To add/modify cron jobs:

crontab -e  # Opens the crontab file in your default editor

Save and exit—the cron daemon will automatically pick up changes.

11. Real-World Example: Automated Backup Script

Let’s build a script to back up a directory (e.g., ~/Documents) to a compressed .tar.gz file with a timestamp.

Step 1: Write the Script (backup_docs.sh)

#!/bin/bash
set -euo pipefail  # Exit on error, unset variables, or pipe failures

# Configuration
SOURCE_DIR="$HOME/Documents"
BACKUP_DIR="$HOME/Backups"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)  # e.g., 20231011_143000
BACKUP_FILENAME="docs_backup_$TIMESTAMP.tar.gz"

# Create backup directory if it doesn't exist
mkdir -p "$BACKUP_DIR"

# Backup and compress the directory
echo "Backing up $SOURCE_DIR to $BACKUP_DIR/$BACKUP_FILENAME..."
tar -czf "$BACKUP_DIR/$BACKUP_FILENAME" -C "$SOURCE_DIR" .

# Verify backup success
if [ $? -eq 0 ]; then
  echo "Backup completed successfully!"
  echo "Backup file: $BACKUP_DIR/$BACKUP_FILENAME"
else
  echo "Error: Backup failed!" >&2  # Redirect error to stderr
  exit 1
fi

Step 2: Test the Script

chmod +x backup_docs.sh
./backup_docs.sh
# Output: Backing up /home/user/Documents to /home/user/Backups/docs_backup_20231011_143000.tar.gz...
# Backup completed successfully!
# Backup file: /home/user/Backups/docs_backup_20231011_143000.tar.gz

Step 3: Schedule with Cron

Add a cron job to run daily at 3 AM:

crontab -e
# Add: 0 3 * * * /home/user/backup_docs.sh >> /home/user/backup_logs.txt 2>&1

Now your Documents folder will back up automatically every day!

12. Best Practices for Bash Scripting

To write maintainable, reliable scripts:

1. Use the Shebang Line: Always start with #!/bin/bash.
2. Comment Liberally: Explain why (not just what) the code does.
3. Test in Stages: Test small sections before combining them.
4. Handle Errors: Use set -euo pipefail and trap for cleanup.
5. Avoid Hardcoding Paths: Use variables (e.g., $HOME) instead of /home/user.
6. Make Scripts Idempotent: Ensure running the script multiple times is safe (e.g., mkdir -p instead of mkdir).
7. Version Control: Store scripts in Git for tracking changes.

13. Conclusion

Bash automation is a cornerstone of Linux productivity. With the skills learned here—variables, conditionals, loops, functions, and cron—you can automate almost any repetitive task. Start small (e.g., a script to rename photos) and gradually tackle more complex projects (e.g., system monitoring).

The key is practice: experiment with scripts, break things, and fix them. Bash scripting is a skill that pays dividends for years to come!

14. References

• GNU Bash Manual
• Cron How-To (Ubuntu)
• Bash Scripting Tutorial (ShellScript.sh)
• Advanced Bash-Scripting Guide
• man bash (Bash manual page, accessible via terminal)