Real-World Examples

Advanced ~35 min read

Theory becomes powerful when applied to real problems. This final lesson presents complete, production-ready scripts that demonstrate everything you've learned. Study these examples, adapt them to your needs, and use them as references for your own projects!

Example 1: Backup Script

A complete backup system with rotation, compression, and verification.

#!/usr/bin/env bash
#
# backup.sh - Simple backup script demonstration
#
# This is a simplified demo version that runs in the tutorial.
# A full production version would have more features.
#

set -euo pipefail

echo "=== Backup Script Demo ==="
echo ""

# Configuration
BACKUP_DIR="/tmp/backup_demo"
SOURCE_DIR="/tmp/backup_source"
RETENTION_DAYS=7

# Logging
log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*"
}

log_error() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] ERROR: $*" >&2
}

# Cleanup handler
cleanup() {
    rm -rf "$SOURCE_DIR" "$BACKUP_DIR" 2>/dev/null || true
}
trap cleanup EXIT

# Setup demo environment
setup_demo() {
    log "Setting up demo environment..."

# Create source files
    mkdir -p "$SOURCE_DIR"
    echo "Important data file 1" > "$SOURCE_DIR/data1.txt"
    echo "Important data file 2" > "$SOURCE_DIR/data2.txt"
    echo "Configuration settings" > "$SOURCE_DIR/config.conf"
    mkdir -p "$SOURCE_DIR/subdir"
    echo "Nested file" > "$SOURCE_DIR/subdir/nested.txt"

# Create backup directory
    mkdir -p "$BACKUP_DIR"

log "Created source files:"
    find "$SOURCE_DIR" -type f -exec echo "  {}" \;
}

# Create backup
create_backup() {
    local source="$1"
    local dest="$2"
    local timestamp=$(date +%Y%m%d_%H%M%S)
    local backup_name="backup_${timestamp}.tar.gz"
    local backup_path="$dest/$backup_name"

log "Creating backup: $backup_name"

# Create compressed archive
    tar -czf "$backup_path" -C "$(dirname "$source")" "$(basename "$source")"

# Verify backup
    if tar -tzf "$backup_path" &>/dev/null; then
        local size=$(du -h "$backup_path" | cut -f1)
        log "Backup created successfully: $backup_name ($size)"
    else
        log_error "Backup verification failed!"
        return 1
    fi

echo "$backup_path"
}

# List existing backups
list_backups() {
    local backup_dir="$1"

log "Existing backups in $backup_dir:"

if [[ -d "$backup_dir" ]]; then
        local count=0
        for backup in "$backup_dir"/backup_*.tar.gz; do
            [[ -f "$backup" ]] || continue
            local size=$(du -h "$backup" | cut -f1)
            local name=$(basename "$backup")
            echo "  - $name ($size)"
            ((count++))
        done

[[ $count -eq 0 ]] && echo "  (no backups found)"
        echo "  Total: $count backup(s)"
    else
        echo "  (backup directory does not exist)"
    fi
}

# Cleanup old backups
cleanup_old_backups() {
    local backup_dir="$1"
    local keep="$2"

log "Cleaning up old backups (keeping newest $keep)..."

local backups=($(ls -1t "$backup_dir"/backup_*.tar.gz 2>/dev/null || true))
    local count=${#backups[@]}

if [[ $count -gt $keep ]]; then
        local to_delete=$((count - keep))
        log "Removing $to_delete old backup(s)"

for ((i=keep; i<count; i++)); do
            log "  Deleting: $(basename "${backups[$i]}")"
            rm -f "${backups[$i]}"
        done
    else
        log "No old backups to remove"
    fi
}

# Restore from backup
restore_backup() {
    local backup_file="$1"
    local restore_dir="$2"

log "Restoring from: $(basename "$backup_file")"
    log "Restoring to: $restore_dir"

mkdir -p "$restore_dir"
    tar -xzf "$backup_file" -C "$restore_dir"

log "Restore complete"
    log "Restored files:"
    find "$restore_dir" -type f -exec echo "  {}" \;
}

# Main demo
main() {
    # Setup
    setup_demo
    echo ""

# Create a backup
    log "--- Creating First Backup ---"
    backup1=$(create_backup "$SOURCE_DIR" "$BACKUP_DIR")
    echo ""

# Wait a moment and create another backup
    sleep 1
    log "--- Creating Second Backup ---"
    # Modify a file first
    echo "Updated content" >> "$SOURCE_DIR/data1.txt"
    backup2=$(create_backup "$SOURCE_DIR" "$BACKUP_DIR")
    echo ""

# List backups
    log "--- Listing Backups ---"
    list_backups "$BACKUP_DIR"
    echo ""

# Demonstrate restore
    log "--- Demonstrating Restore ---"
    restore_dir="/tmp/restored_demo"
    restore_backup "$backup2" "$restore_dir"
    rm -rf "$restore_dir"
    echo ""

# Cleanup old backups (keep 1)
    log "--- Cleanup Old Backups (keep 1) ---"
    cleanup_old_backups "$BACKUP_DIR" 1
    echo ""

# Final list
    log "--- Final Backup List ---"
    list_backups "$BACKUP_DIR"

echo ""
    log "=== Backup Demo Complete ==="
}

main "$@"

Output

Click Run to execute your code

Key Features

Configurable via environment or command-line
Compression with gzip
Automatic rotation of old backups
Verification of backup integrity
Logging with timestamps
Error handling and cleanup

Cron Setup: Schedule daily backups with:

# /etc/cron.d/backup
0 2 * * * root /opt/scripts/backup.sh -s /var/data -d /backup -r 7 >> /var/log/backup.log 2>&1

Example 2: System Monitoring

Monitor system resources and send alerts when thresholds are exceeded.

#!/usr/bin/env bash
#
# monitor.sh - System monitoring script demonstration
#
# This is a simplified demo that shows monitoring concepts.
#

set -euo pipefail

echo "=== System Monitoring Demo ==="
echo ""

# Configuration
WARN_CPU=80
CRIT_CPU=90
WARN_MEM=80
CRIT_MEM=90
WARN_DISK=80
CRIT_DISK=90

# Status codes
readonly STATUS_OK=0
readonly STATUS_WARN=1
readonly STATUS_CRIT=2

# Logging
timestamp() {
    date '+%Y-%m-%d %H:%M:%S'
}

log() {
    echo "[$(timestamp)] $*"
}

# Get CPU usage (simplified)
get_cpu_usage() {
    # This is a simplified demo - real implementation would use /proc/stat
    # For demo purposes, generate a random value
    local usage=$((RANDOM % 100))
    echo "$usage"
}

# Get memory usage
get_memory_usage() {
    # Try to get real memory info, fall back to demo value
    if command -v free &>/dev/null; then
        free | awk '/^Mem:/ {printf "%.0f", $3/$2 * 100}'
    else
        # Demo fallback
        echo $((RANDOM % 100))
    fi
}

# Get disk usage
get_disk_usage() {
    local path="${1:-/}"
    if df "$path" &>/dev/null; then
        df "$path" | awk 'NR==2 {gsub(/%/,""); print $5}'
    else
        # Demo fallback
        echo $((RANDOM % 100))
    fi
}

# Check threshold and return status
check_threshold() {
    local value="$1"
    local warn="$2"
    local crit="$3"

if [[ $value -ge $crit ]]; then
        echo $STATUS_CRIT
    elif [[ $value -ge $warn ]]; then
        echo $STATUS_WARN
    else
        echo $STATUS_OK
    fi
}

# Format status for display
format_status() {
    local status="$1"
    case $status in
        $STATUS_OK)   echo "OK" ;;
        $STATUS_WARN) echo "WARNING" ;;
        $STATUS_CRIT) echo "CRITICAL" ;;
        *)            echo "UNKNOWN" ;;
    esac
}

# Get status color (for terminals that support it)
status_indicator() {
    local status="$1"
    case $status in
        $STATUS_OK)   echo "[OK]" ;;
        $STATUS_WARN) echo "[WARN]" ;;
        $STATUS_CRIT) echo "[CRIT]" ;;
        *)            echo "[????]" ;;
    esac
}

# Monitor CPU
monitor_cpu() {
    local usage=$(get_cpu_usage)
    local status=$(check_threshold "$usage" "$WARN_CPU" "$CRIT_CPU")

echo "CPU Usage: ${usage}% $(status_indicator $status)"
    return $status
}

# Monitor memory
monitor_memory() {
    local usage=$(get_memory_usage)
    local status=$(check_threshold "$usage" "$WARN_MEM" "$CRIT_MEM")

echo "Memory Usage: ${usage}% $(status_indicator $status)"
    return $status
}

# Monitor disk
monitor_disk() {
    local path="${1:-/tmp}"
    local usage=$(get_disk_usage "$path")
    local status=$(check_threshold "$usage" "$WARN_DISK" "$CRIT_DISK")

echo "Disk Usage ($path): ${usage}% $(status_indicator $status)"
    return $status
}

# Monitor running processes
monitor_processes() {
    echo "--- Top Processes by Memory ---"

if command -v ps &>/dev/null; then
        ps aux --sort=-%mem 2>/dev/null | head -6 | awk '
            NR==1 {printf "  %-10s %5s %5s  %s\n", "USER", "%MEM", "%CPU", "COMMAND"}
            NR>1  {printf "  %-10s %5s %5s  %s\n", $1, $4, $3, $11}
        ' 2>/dev/null || echo "  (ps command not available in this environment)"
    else
        echo "  (ps command not available)"
    fi
}

# Generate report
generate_report() {
    echo "========================================"
    echo "       SYSTEM MONITORING REPORT"
    echo "========================================"
    echo "Timestamp: $(timestamp)"
    echo "Hostname:  ${HOSTNAME:-$(hostname 2>/dev/null || echo 'unknown')}"
    echo ""

echo "--- Resource Usage ---"
    local overall_status=$STATUS_OK

monitor_cpu || overall_status=$?
    monitor_memory || { [[ $? -gt $overall_status ]] && overall_status=$?; }
    monitor_disk "/tmp" || { [[ $? -gt $overall_status ]] && overall_status=$?; }

echo ""
    monitor_processes

echo ""
    echo "========================================"
    echo "Overall Status: $(format_status $overall_status)"
    echo "========================================"

return $overall_status
}

# Alert function (simplified)
send_alert() {
    local level="$1"
    local message="$2"

log "ALERT [$level]: $message"

# In production, this would:
    # - Send email: mail -s "Alert: $message" admin@example.com
    # - Send to Slack: curl -X POST -d '{"text":"'$message'"}' $SLACK_WEBHOOK
    # - Page on-call: curl -X POST pagerduty.com/...
}

# Main monitoring loop (demo runs once)
main() {
    log "Starting system monitoring..."
    echo ""

# Generate report
    generate_report
    local status=$?

echo ""

# Check if alerts needed
    if [[ $status -eq $STATUS_CRIT ]]; then
        send_alert "CRITICAL" "System resources critical!"
    elif [[ $status -eq $STATUS_WARN ]]; then
        send_alert "WARNING" "System resources warning"
    else
        log "All systems nominal"
    fi

echo ""
    log "Monitoring complete"

# In production, you might:
    # - Run in a loop with sleep
    # - Write metrics to a time-series database
    # - Expose metrics endpoint for Prometheus
}

main "$@"

Output

Click Run to execute your code

Example 3: Deployment Script

Deploy applications with rollback capability.

#!/usr/bin/env bash
#
# deploy.sh - Application deployment with rollback
#
set -euo pipefail

readonly SCRIPT_NAME="$(basename "$0")"
readonly DEPLOY_DIR="/var/www/app"
readonly RELEASES_DIR="$DEPLOY_DIR/releases"
readonly CURRENT_LINK="$DEPLOY_DIR/current"
readonly SHARED_DIR="$DEPLOY_DIR/shared"
readonly KEEP_RELEASES=5

# Logging
log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*"; }
die() { log "ERROR: $*" >&2; exit 1; }

# Create new release directory
create_release() {
    local release_id="$(date +%Y%m%d%H%M%S)"
    local release_dir="$RELEASES_DIR/$release_id"

    log "Creating release: $release_id"

    mkdir -p "$release_dir"
    echo "$release_dir"
}

# Deploy code to release directory
deploy_code() {
    local release_dir="$1"
    local source="${2:-.}"

    log "Deploying code to $release_dir"

    # Copy application code
    rsync -av --exclude='.git' --exclude='node_modules' \\
        "$source/" "$release_dir/"

    # Link shared directories
    ln -sf "$SHARED_DIR/logs" "$release_dir/logs"
    ln -sf "$SHARED_DIR/.env" "$release_dir/.env"
}

# Switch current symlink to new release
switch_release() {
    local release_dir="$1"

    log "Switching to release: $(basename "$release_dir")"

    ln -sfn "$release_dir" "$CURRENT_LINK"
}

# Cleanup old releases
cleanup_old_releases() {
    log "Cleaning up old releases (keeping $KEEP_RELEASES)"

    local releases=($(ls -1t "$RELEASES_DIR"))
    local to_delete=("${releases[@]:$KEEP_RELEASES}")

    for release in "${to_delete[@]}"; do
        log "Removing old release: $release"
        rm -rf "$RELEASES_DIR/$release"
    done
}

# Rollback to previous release
rollback() {
    local releases=($(ls -1t "$RELEASES_DIR"))

    [[ ${#releases[@]} -lt 2 ]] && die "No previous release to rollback to"

    local previous="${releases[1]}"
    log "Rolling back to: $previous"

    switch_release "$RELEASES_DIR/$previous"
    log "Rollback complete"
}

# Main deployment
deploy() {
    local source="${1:-.}"

    log "Starting deployment..."

    # Create release
    local release_dir
    release_dir=$(create_release)

    # Deploy code
    deploy_code "$release_dir" "$source"

    # Run build/install commands
    log "Installing dependencies..."
    (cd "$release_dir" && npm install --production 2>/dev/null || true)

    # Switch to new release
    switch_release "$release_dir"

    # Restart service
    log "Restarting application..."
    systemctl restart myapp 2>/dev/null || true

    # Cleanup
    cleanup_old_releases

    log "Deployment complete!"
}

# Parse arguments
case "${1:-deploy}" in
    deploy)   deploy "${2:-.}" ;;
    rollback) rollback ;;
    *)        echo "Usage: $SCRIPT_NAME {deploy|rollback} [source]" ;;
esac

Example 4: Log Processing

Analyze and report on log files.

#!/usr/bin/env bash
#
# log-analyzer.sh - Analyze access logs and generate reports
#
set -euo pipefail

readonly LOG_FILE="${1:-/var/log/nginx/access.log}"

log() { echo "[$(date '+%H:%M:%S')] $*"; }

analyze_logs() {
    [[ -f "$LOG_FILE" ]] || { echo "Log file not found: $LOG_FILE"; exit 1; }

    echo "=== Log Analysis Report ==="
    echo "File: $LOG_FILE"
    echo "Generated: $(date)"
    echo ""

    # Total requests
    local total=$(wc -l < "$LOG_FILE")
    echo "Total Requests: $total"
    echo ""

    # Requests per status code
    echo "--- Status Codes ---"
    awk '{print $9}' "$LOG_FILE" | sort | uniq -c | sort -rn | head -10
    echo ""

    # Top 10 IPs
    echo "--- Top 10 IP Addresses ---"
    awk '{print $1}' "$LOG_FILE" | sort | uniq -c | sort -rn | head -10
    echo ""

    # Top 10 URLs
    echo "--- Top 10 URLs ---"
    awk '{print $7}' "$LOG_FILE" | sort | uniq -c | sort -rn | head -10
    echo ""

    # Requests per hour
    echo "--- Requests per Hour ---"
    awk '{print $4}' "$LOG_FILE" | cut -d: -f2 | sort | uniq -c
    echo ""

    # Error rate
    local errors=$(awk '$9 >= 400' "$LOG_FILE" | wc -l)
    local error_rate=$(echo "scale=2; $errors * 100 / $total" | bc)
    echo "Error Rate: $error_rate% ($errors errors)"
}

# Run with error handling
analyze_logs 2>/dev/null || echo "Analysis failed"

Example 5: API Integration

Interact with REST APIs using curl.

#!/usr/bin/env bash
#
# api-client.sh - REST API client utilities
#
set -euo pipefail

readonly API_BASE="${API_BASE:-https://api.example.com}"
readonly API_TOKEN="${API_TOKEN:?API_TOKEN required}"

# HTTP helper
api_request() {
    local method="$1"
    local endpoint="$2"
    local data="${3:-}"

    local curl_opts=(
        -s
        -X "$method"
        -H "Authorization: Bearer $API_TOKEN"
        -H "Content-Type: application/json"
    )

    [[ -n "$data" ]] && curl_opts+=(-d "$data")

    local response
    response=$(curl "${curl_opts[@]}" "$API_BASE$endpoint")
    local status=$?

    if [[ $status -ne 0 ]]; then
        echo "Request failed" >&2
        return 1
    fi

    echo "$response"
}

# GET request
get() {
    api_request GET "$1"
}

# POST request
post() {
    api_request POST "$1" "$2"
}

# List users
list_users() {
    get "/users" | jq -r '.[] | "\\(.id): \\(.name)"'
}

# Create user
create_user() {
    local name="$1"
    local email="$2"

    local payload=$(jq -n --arg n "$name" --arg e "$email" \\
        '{name: $n, email: $e}')

    post "/users" "$payload"
}

# Health check
health_check() {
    if get "/health" | jq -e '.status == "ok"' >/dev/null; then
        echo "API is healthy"
        return 0
    else
        echo "API is unhealthy"
        return 1
    fi
}

# Run if executed directly
case "${1:-}" in
    users)  list_users ;;
    create) create_user "$2" "$3" ;;
    health) health_check ;;
    *)      echo "Usage: $0 {users|create|health}" ;;
esac

Common Patterns Summary

Pattern	Used In	Purpose
`set -euo pipefail`	All scripts	Error handling
`trap cleanup EXIT`	Backup, Deploy	Resource cleanup
`log() { ... }`	All scripts	Consistent logging
`${VAR:-default}`	All scripts	Safe defaults
`getopts/case`	Backup, Monitor	Argument parsing
`readonly`	All scripts	Constants

Congratulations!

You've completed the Bash Scripting Course! You now have the skills to:

Write professional, maintainable scripts
Handle errors gracefully with proper logging
Parse arguments and configuration
Test your scripts for reliability
Automate real-world tasks like backups and deployments

Keep practicing: The best way to improve is to write more scripts. Start with small automation tasks and gradually tackle larger projects!

What's Next?

Continue your journey:

Explore the Advanced Topics module for regex, sed, and awk
Build your own script library from the templates
Set up CI/CD for your scripts with automated testing
Contribute to open-source projects using your new skills

Previous Testing Scripts

Next Back to Bash Tutorial