Reliable Bash Scripting

Writing Portable, Secure, and Production-Ready Shell Scripts Across Linux Distributions

Preface

1. Who Should Read This Book
2. How This Book Is Structured
3. Conventions Used in This Book
4. About the Author
5. Acknowledgments

Introduction: The Hidden Complexity of Shell Scripts

1. A Script That Broke Production
2. What Makes a Shell Script Reliable
3. The Linux Distribution Landscape
4. How This Book Is Organized

Chapter 1: The Bash Execution Model

1. How Bash Reads and Parses Input
2. The Expansion Order: A Critical Sequence
3. Word Splitting and Pathname Expansion
4. Subshells and Process Forking
5. Interactive vs Non-Interactive Mode Differences

Chapter 2: Variables, Quoting, and Safe Syntax

1. Variable Assignment and Naming Conventions
2. The Three Types of Quotes
3. Parameter Expansion and Default Values
4. Special Parameters: Positional, IFS, PATH, and More
5. Common Quoting Pitfalls and How to Avoid Them

Chapter 3: Control Flow and Logic

1. Test Commands: [ ], [[ ]], and test
2. Conditional Execution with if/elif/else
3. Pattern Matching with case Statements
4. Loops: for, while, until, and select
5. Break, Continue, and Early Exit Patterns

Chapter 4: Functions and Modular Design

1. Defining and Calling Functions
2. Local Variables and Scope
3. Positional Parameters in Functions
4. Return Values and Exit Codes
5. Script Libraries and Sourcing

Chapter 5: Arrays and Associative Arrays

1. Indexed Arrays: Creation and Manipulation
2. Iterating Over Arrays Safely
3. Array Operations: Slicing, Searching, Deleting
4. Associative Arrays for Key-Value Data
5. Portability Considerations for Arrays

Chapter 6: Input/Output, Redirection, and File Descriptors

1. Standard Streams and File Descriptors
2. Redirection Operators Explained
3. Pipelines and Command Chaining
4. Here-Documents and Here-Strings
5. Process Substitution and Named Pipes

Chapter 7: Process and Job Management

1. Background Jobs and the & Operator
2. Waiting for Processes to Complete
3. Killing and Managing Child Processes
4. Process Groups and Sessions
5. Monitoring Long-Running Operations

Chapter 8: Signals, Traps, and Cleanup

1. Understanding Unix Signals
2. The trap Command
3. Handling Common Signals in Scripts
4. Ensuring Cleanup Runs on Exit
5. Signal Handling in Pipelines and Subshells

Chapter 9: Error Handling and Defensive Scripting

1. Exit Codes and Their Meaning
2. The set Command: -e, -u, -o pipefail, and More
3. Validating Input and Preconditions
4. Graceful Failure and Partial Success
5. Logging Errors Effectively

Chapter 10: Debugging and Testing Scripts

1. Bash Built-In Debugging Options
2. Using set -x Wisely
3. Static Analysis Tools for Shell Scripts
4. Writing Tests for Shell Scripts
5. Continuous Integration for Shell Scripts

Chapter 11: Text Processing Essentials

1. grep and Extended Pattern Matching
2. sed for Stream Editing
3. awk for Field-Based Processing
4. find for File Discovery
5. xargs, sort, uniq, cut, and wc

Chapter 12: Advanced Text Processing with sed and awk

1. Advanced sed Techniques
2. awk as a Programming Language
3. Combining Tools in Complex Pipelines
4. When to Use Which Tool

Chapter 13: POSIX Compatibility and Portability

1. The POSIX Shell Standard
2. Bashisms vs POSIX Shell Features
3. Detecting the Running Shell
4. Writing Portable Scripts with bash -u and Strict Options
5. When to Use #!/bin/sh vs #!/usr/bin/env bash

Chapter 14: Linux Distribution Differences

1. Default Shell Versions Across Distributions
2. Path and Tooling Variations
3. Systemd vs SysVinit vs OpenRC
4. Package Managers in Scripts
5. Alpine Linux and BusyBox Considerations

Chapter 15: Security in Shell Scripts

1. Command Injection Vulnerabilities
2. PATH Manipulation and Environment Attacks
3. Handling User Input Safely
4. Secrets and Credentials in Scripts
5. File Permissions and SUID Concerns
6. Secure Temporary Files and Directories

Chapter 16: Performance Optimization

1. The Cost of Forking External Commands
2. Using Builtins Over External Tools
3. Minimizing Subshell Creation
4. Efficient File and Data Handling
5. When to Use a Different Language

Chapter 17: Concurrency in Shell Scripts

1. Parallel Execution with Background Jobs
2. Controlling Concurrency Limits
3. Synchronization and Locking
4. GNU parallel and Other Tools
5. Race Conditions and Atomic Operations

Chapter 18: Automation, DevOps, and CI/CD

1. Shell Scripts in CI/CD Pipelines
2. Infrastructure as Code and Shell
3. Container Build Scripts and Entrypoints
4. Configuration Management Integration
5. Monitoring and Alerting Scripts

Chapter 19: System Administration Patterns

1. User and Group Management Scripts
2. Log Processing and Rotation
3. Backup and Restore Procedures
4. Service Health Checks and Monitoring
5. Disk Space and Resource Management

Conclusion: The Art of Reliable Scripting

1. Principles That Endure
2. When Bash Is the Right Tool
3. Continuing Your Journey

Appendix A: Bash Syntax Cheat Sheet

1. Shebang and Strict Mode
2. Variables
3. Arrays
4. Conditionals
5. Test Operators Reference
6. Loops
7. Functions
8. Input/Output Redirection
9. Arithmetic
10. Special Variables
11. Common set Options
12. shopt Options

Appendix B: Common Production Patterns Library

1. Standard Script Skeleton
2. Retry Pattern with Exponential Backoff
3. Parallel Processing with Concurrency Limit
4. Safe File Write (Atomic)
5. Wait for Service with Timeout
6. Parse Configuration File into Associative Array
7. Send Alert via Webhook
8. Disk Space Check

Appendix C: POSIX vs. Bash Feature Comparison Matrix

1. Core Language Features
2. Quoting and Expansion
3. Control Flow
4. Input/Output
5. Functions and Scope
6. Special Variables
7. Shell Options (shopt)
8. Utilities and Commands

References