Shell Scripts for SRE and DevOps ¶

Shell scripts are programs written for command-line interpreters (shells) that automate system tasks and operations. They combine sequences of commands into reusable scripts that can be executed as single units.

They are widely used by SRE (Site Reliability Engineers) and DevOps engineers to automate operations, reduce manual effort, and standardize workflows.

Historical Context and Evolution¶

Shell scripting originated in the early Unix systems (1970s) with the Bourne shell (sh). Over time, more feature-rich shells emerged:

Bash (Bourne Again Shell): Default on most Linux distributions
Zsh: Extended features with better user interaction
Ksh: AIX default shell with advanced scripting capabilities

Why Shell Scripts Are Important for SRE and DevOps¶

Tip

Shell scripts remain a core tool for SRE and DevOps. - They are simple: use plain Linux commands. - They are powerful: integrate system utilities, APIs, and services. - They are universal: available by default on nearly every Unix/Linux system. - They allow conditions, loops, functions, and modularity to make tasks reusable.

Examples of usage:

Daily health checks
Disk and memory monitoring
Service management
Deployment pipelines
Cron-based automation

Shell Interpreter and Location¶

The interpreter is the program that executes shell scripts.
Common locations:

/bin/sh
/bin/bash
/usr/bin/zsh

Default interpreter: /bin/bash in most Linux systems.
Speed: Shell scripts are slower than compiled languages (C, Go), but fast enough for automation.

Note

Always define interpreter at the top of scripts with shebang: bash #!/bin/bash

Core Components of Shell Scripts¶

Shebang Directive¶

#!/bin/bash
#!/bin/sh     # POSIX-compliant
#!/usr/bin/zsh
#!/usr/bin/env bash  # Portable

Comments and Documentation¶

# Single-line comment

: '
Multi-line comment
'

<<EOF
Here-document style comment
EOF

Variables and Data Types¶

NAME="value"          # String
COUNT=42              # Integer
FILES=(*.txt)         # Array
readonly CONST=100    # Constant
export GLOBAL_VAR     # Env variable

Special Variables¶

$0    # Script name
$1    # First argument
$#    # Number of args
$@    # All arguments
$?    # Exit status
$$    # PID
$!    # Background PID

How to Write Shell Scripts¶

1. Conditions¶

if [ -f /etc/passwd ]; then
  echo "File exists"
else
  echo "File missing"
fi

2. Loops¶

for i in {1..5}; do
  echo "Iteration $i"
done

3. Functions¶

greet() { echo "Hello $1"; }
greet "Admin"

4. Case (Switch)¶

case $1 in
  start) echo "Starting service" ;;
  stop)  echo "Stopping service" ;;
  *)     echo "Usage: $0 {start|stop}" ;;
esac

5. Modular Scripts¶

source ./utils.sh
say_hello "DevOps"

Advanced Scripting Techniques¶

Parameter Expansion¶

${VAR:-default}    # Use default if unset
${VAR:=default}    # Set default if unset
${#VAR}            # Length
${VAR#pattern}     # Remove prefix
${VAR%pattern}     # Remove suffix

Arrays and Associative Arrays¶

FILES=("f1" "f2")
declare -A CONFIG
CONFIG["host"]="example.com"

Input/Output Handling¶

read -p "Enter: " INPUT
cat <<END > file.txt
multi-line
END

Error Handling and Debugging¶

set -euo pipefail
trap 'echo "Error at line $LINENO"' ERR
set -x   # debug on
set +x   # debug off

Benefits of Shell Scripting¶

Fast prototyping of automation.
Integration with system tools (systemctl, docker, kubectl, rsync).
Portability across Linux distributions.
Low dependency: no need for extra runtimes.

Advanced Examples for Production Environments¶

1. Comprehensive System Health Check¶

(Full script with disk and memory checks, logging, colors.)

2. Advanced Log Analyzer¶

(Grep-based log analysis with report generation.)

3. Kubernetes Deployment Helper¶

(Validates YAML, applies deployment, waits for rollout.)

4. Secure Configuration Manager¶

(Encrypt/decrypt configs with OpenSSL.)

5. Advanced Backup System¶

(Database backups, retention, verification.)

Best Practices for Production Scripts¶

Security¶

Avoid command injection.
Use mktemp for temp files.

Performance¶

Prefer shell built-ins over external commands.
Process large files with while read.

Portability¶

Prefer POSIX-compliant syntax when possible.

Documentation¶

Include script headers (purpose, author, usage).
Document functions with parameters and return codes.

Integration with Modern DevOps Tools¶

CI/CD Pipelines¶

(Shell stages for Jenkins, rollback, Slack alerts.)

Cloud Integration¶

AWS: aws s3 cp
GCP: gsutil cp
Azure: az storage blob upload

Monitoring and Logging¶

Performance Monitoring¶

Track script execution time with $SECONDS.
Send metrics to monitoring systems.

Structured Logging¶

JSON logging with jq for easy integration.

Shell Scripts for SRE and DevOps¶