How to Build Bash Automation Scripts

Introduction

Shell scripting is a critical skill for Linux system administrators and developers seeking to automate repetitive tasks and improve workflow efficiency. This comprehensive tutorial provides a deep dive into bash scripting fundamentals, covering everything from basic script structure to advanced automation techniques that can transform your Linux system management approach.

Shell Scripting Basics

Introduction to Linux Shell Scripting

Shell scripting is a powerful method of automating tasks in Linux systems. As a fundamental skill in linux shell scripting, bash programming enables system administrators and developers to create efficient command-line solutions.

Basic Shell Script Structure

A typical bash script follows a specific structure:

#!/bin/bash
## This is a comment
echo "Hello, Linux Shell!"

Key Components of Shell Scripts

Variables and Data Types

Shell scripts support various variable types:

## String variable
name="Ubuntu"

## Integer variable
count=10

## Array example
servers=("web01" "db01" "app01")

Control Structures

Conditional Statements

if [ $count -gt 5 ]; then
  echo "Count is greater than 5"
else
  echo "Count is less than or equal to 5"
fi

Loops

for server in "${servers[@]}"; do
  ping -c 1 $server
done

Function Definition

system_info() {
  echo "Hostname: $(hostname)"
  echo "Operating System: $(uname -o)"
}

system_info

Practical Workflow Visualization

graph TD
    A[Start Script] --> B{Check Conditions}
    B -->|True| C[Execute Commands]
    B -->|False| D[Exit Script]
    C --> E[Return Results]

Script Development Techniques

Advanced Function Design

Functions enhance script modularity and reusability:

validate_input() {
  local input=$1
  [[ -z "$input" ]] && return 1
  [[ "$input" =~ ^[0-9]+$ ]] || return 1
  return 0
}

process_data() {
  local data=$1
  if validate_input "$data"; then
    echo "Valid input: $data"
  else
    echo "Invalid input"
  fi
}

Input and Output Handling

Command-Line Arguments

#!/bin/bash
if [ $## -eq 0 ]; then
  echo "Usage: $0 <parameter>"
  exit 1
fi

first_argument=$1
echo "First argument: $first_argument"

Input Validation Techniques

Error Handling and Logging

log_error() {
  local message=$1
  echo "[ERROR] $(date): $message" >> error.log
  exit 1
}

backup_files() {
  rsync -avz /source/ /backup/ || log_error "Backup failed"
}

Script Execution Flow

graph TD
    A[Start Script] --> B{Input Validation}
    B -->|Valid| C[Process Data]
    B -->|Invalid| D[Display Error]
    C --> E[Generate Output]
    D --> F[Exit Script]

Conditional Statement Patterns

check_system_resources() {
  local cpu_usage=$(top -bn1 | grep "Cpu(s)" | awk '{print $2 + $4}')
  local memory_usage=$(free | grep Mem | awk '{print $3/$2 * 100.0}')

  if (($(echo "$cpu_usage > 80" | bc -l))); then
    echo "High CPU usage detected"
  fi

  if (($(echo "$memory_usage > 90" | bc -l))); then
    echo "High memory consumption"
  fi
}

Debugging Techniques

#!/bin/bash
set -x ## Enable debug mode
set -e ## Exit immediately if a command exits with non-zero status

complex_operation() {
  ## Debugging-friendly function
}

Practical Automation Projects

System Backup Automation

#!/bin/bash
BACKUP_DIR="/backup/$(date +%Y-%m-%d)"
SOURCES=("/etc" "/home" "/var/log")

create_backup() {
  mkdir -p "$BACKUP_DIR"
  for source in "${SOURCES[@]}"; do
    rsync -avz "$source" "$BACKUP_DIR"
  done
  echo "Backup completed: $BACKUP_DIR"
}

cleanup_old_backups() {
  find /backup -type d -mtime +30 -exec rm -rf {} \;
}

create_backup
cleanup_old_backups

Server Monitoring Script

#!/bin/bash
monitor_system() {
  local cpu_usage=$(top -bn1 | grep "Cpu(s)" | awk '{print $2 + $4}')
  local memory_usage=$(free | awk '/Mem:/ {printf "%.2f", $3/$2 * 100.0}')
  local disk_usage=$(df -h / | awk '/\// {print $5}')

  cat << EOF > /var/log/system_health.log
System Health Report: $(date)
CPU Usage: $cpu_usage%
Memory Usage: $memory_usage%
Disk Usage: $disk_usage
EOF
}

Automated Log Management

#!/bin/bash
LOG_DIR="/var/log/custom_logs"
MAX_LOG_SIZE=10M

rotate_logs() {
  find "$LOG_DIR" -type f -size +$MAX_LOG_SIZE | while read -r log; do
    gzip "$log"
    mv "${log}.gz" "${log}.$(date +%Y%m%d).gz"
  done
}

Network Connectivity Checker

#!/bin/bash
check_network_status() {
  local servers=("8.8.8.8" "1.1.1.1" "github.com")
  local report="/tmp/network_status.txt"

  > "$report"
  for host in "${servers[@]}"; do
    if ping -c 3 "$host" &> /dev/null; then
      echo "$host: ONLINE" >> "$report"
    else
      echo "$host: OFFLINE" >> "$report"
    fi
  done
}

Automation Workflow Visualization

graph TD
    A[Start Automation Script] --> B{Check System Conditions}
    B -->|Healthy| C[Execute Tasks]
    B -->|Issues Detected| D[Generate Alert]
    C --> E[Log Results]
    D --> F[Notify Administrator]

User Management Automation

#!/bin/bash
create_project_users() {
  local project_name=$1
  local team_members=("alice" "bob" "charlie")

  for user in "${team_members[@]}"; do
    useradd -m -g "$project_name" "$user"
    echo "Created user: $user for project $project_name"
  done
}

create_project_users "devops"

Summary

By mastering shell scripting techniques, you'll gain the ability to create powerful, modular scripts that automate complex system tasks, validate inputs, handle data processing, and streamline administrative workflows. The skills learned in this tutorial will enable you to write more efficient, maintainable, and robust bash scripts that can significantly enhance your productivity in Linux environments.