How to Write Your First Bash Automation Script

Bash scripting is one of the most valuable skills for Linux system administrators, DevOps engineers, and IT professionals. Whether you’re automating repetitive tasks, managing system configurations, or processing data, learning to write bash automation scripts will dramatically increase your productivity and efficiency.

This comprehensive guide will walk you through creating your first bash automation script from scratch, covering everything from basic syntax to practical real-world examples that you can implement immediately.

Table of Contents

• What is Bash and Why Automate?
• Getting Started with Your First Script
• Understanding Basic Bash Syntax
• Working with Variables
• Control Structures and Conditionals
• Implementing Loops for Automation
• Creating Reusable Functions
• Practical Automation Examples
• Best Practices and Error Handling

What is Bash and Why Automate?

Bash (Bourne Again Shell) is the default command-line interpreter on most Linux distributions and macOS systems. It allows you to execute commands, manipulate files, and control system processes through a powerful scripting language.

Automation through bash scripts offers several key advantages:

• Time savings: Eliminate repetitive manual tasks that consume hours each week
• Consistency: Execute tasks the same way every time, reducing human error
• Scalability: Perform operations across multiple servers or files simultaneously
• Documentation: Scripts serve as executable documentation of your processes

If you’re looking to expand your scripting skills beyond bash, DataCamp offers excellent interactive courses on shell scripting and data automation that can take your skills to the next level.

Getting Started with Your First Script

Creating a bash script begins with a simple text file. You can use any text editor like nano, vim, or even a graphical editor. Let’s create your first script:

Step 1: Create the Script File

Open your terminal and create a new file:

nano my_first_script.sh

Step 2: Add the Shebang Line

Every bash script should start with a shebang line that tells the system which interpreter to use:

#!/bin/bash

This line must be the very first line in your script. It directs the system to execute the script using the bash interpreter located at /bin/bash.

Step 3: Make Your Script Executable

After saving your script, you need to give it execute permissions:

chmod +x my_first_script.sh

Now you can run your script with:

./my_first_script.sh

Understanding Basic Bash Syntax

Bash scripts consist of commands that you would normally type in a terminal, along with programming constructs like variables, loops, and conditionals. Here’s a simple example:

#!/bin/bash

echo "Hello, World!"
echo "Today's date is: $(date)"
echo "Current user: $USER"

The echo command prints text to the screen. The $(date) syntax executes the date command and inserts its output into the string. Variables like $USER are prefixed with a dollar sign.

Working with Variables

Variables store data that your script can use and manipulate. In bash, you assign variables without spaces around the equals sign:

#!/bin/bash

# Define variables
name="John"
age=30
directory="/home/user/backups"

# Use variables
echo "Name: $name"
echo "Age: $age"
echo "Backup directory: $directory"

# Command substitution
current_date=$(date +%Y-%m-%d)
echo "Script executed on: $current_date"

Variables can store strings, numbers, or command output. Use meaningful variable names and consider adding comments (lines starting with #) to explain your code.

Control Structures and Conditionals

Conditional statements allow your scripts to make decisions based on conditions. The basic structure uses if, then, else, and fi:

#!/bin/bash

file="/etc/passwd"

if [ -f "$file" ]; then
    echo "File exists"
    line_count=$(wc -l < "$file")
    echo "Number of lines: $line_count"
else
    echo "File does not exist"
fi

Common test conditions include:

• -f file: True if file exists and is a regular file
• -d directory: True if directory exists
• -z string: True if string is empty
• -n string: True if string is not empty
• num1 -eq num2: True if numbers are equal

Implementing Loops for Automation

Loops enable you to perform repetitive tasks efficiently. The two most common loops in bash are for and while:

For Loop Example

#!/bin/bash

# Loop through files
for file in *.txt; do
    echo "Processing: $file"
    # Add your processing commands here
done

# Loop through a range of numbers
for i in {1..5}; do
    echo "Iteration $i"
done

While Loop Example

#!/bin/bash

counter=1

while [ $counter -le 5 ]; do
    echo "Count: $counter"
    counter=$((counter + 1))
done

Creating Reusable Functions

Functions help you organize code into reusable blocks. They make your scripts more maintainable and easier to understand:

#!/bin/bash

# Define a function
backup_directory() {
    local source=$1
    local destination=$2
    
    if [ -d "$source" ]; then
        tar -czf "$destination/backup_$(date +%Y%m%d).tar.gz" "$source"
        echo "Backup completed successfully"
    else
        echo "Error: Source directory does not exist"
        return 1
    fi
}

# Call the function
backup_directory "/home/user/documents" "/home/user/backups"

Practical Automation Examples

System Monitoring Script

#!/bin/bash

echo "=== System Monitoring Report ==="
echo "Date: $(date)"
echo "Hostname: $(hostname)"
echo ""

echo "CPU Usage:"
top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1

echo ""
echo "Memory Usage:"
free -h | grep Mem | awk '{print "Used: " $3 " / Total: " $2}'

echo ""
echo "Disk Usage:"
df -h / | tail -1 | awk '{print "Used: " $3 " / Total: " $2 " (" $5 " full)"}'

Automated Backup Script

#!/bin/bash

SOURCE_DIR="/home/user/important_files"
BACKUP_DIR="/home/user/backups"
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="backup_$DATE.tar.gz"

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

# Create compressed backup
tar -czf "$BACKUP_DIR/$BACKUP_FILE" "$SOURCE_DIR"

# Keep only the last 7 backups
cd "$BACKUP_DIR"
ls -t | tail -n +8 | xargs -r rm

echo "Backup completed: $BACKUP_FILE"

When running automation scripts on production systems, consider using a reliable cloud infrastructure provider like Kamatera, which offers flexible virtual private servers perfect for testing and deploying your bash automation workflows.

Best Practices and Error Handling

Professional bash scripts incorporate proper error handling and follow best practices:

Enable Strict Mode

#!/bin/bash

set -euo pipefail

# -e: Exit on error
# -u: Exit on undefined variable
# -o pipefail: Exit on pipe failure

Check Command Success

#!/bin/bash

if ! command -v rsync &> /dev/null; then
    echo "Error: rsync is not installed"
    exit 1
fi

# Proceed with rsync operations

Use Proper Quoting

Always quote variables to prevent word splitting and globbing issues:

file="my document.txt"
cat "$file"  # Correct
cat $file    # Wrong - will fail with spaces

Add Logging

#!/bin/bash

LOG_FILE="/var/log/my_script.log"

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
}

log "Script started"
# Your script operations
log "Script completed"

Validate Input

#!/bin/bash

if [ $# -eq 0 ]; then
    echo "Usage: $0 "
    exit 1
fi

filename=$1

if [ ! -f "$filename" ]; then
    echo "Error: File '$filename' not found"
    exit 1
fi

Writing your first bash automation script is a crucial step in becoming proficient with Linux system administration. Start with simple scripts that solve real problems in your daily work, then gradually add complexity as you become more comfortable with the syntax and concepts. Remember that the best way to learn is through practice—take these examples, modify them for your needs, and experiment with new commands and structures.

With consistent practice and attention to best practices, you'll soon be creating sophisticated automation solutions that save time and reduce errors across your infrastructure.