Bash Scripting for Automation

• Anything you type more than once deserves a script: backups, deploys, log rotation, environment setup and smoke tests.
• Scripts are the glue between tools — bash sits at the heart of CI runners, cron jobs, Dockerfile RUN steps and Ansible shells.
• A script encodes tribal knowledge: the exact sequence of commands that works is preserved, reviewable and repeatable.
• Bash needs no runtime, no compiler and no dependencies beyond the shell — it runs on every Linux machine, container and cloud VM.
• A small investment in disciplined patterns (set -euo pipefail, exit codes) turns fragile one-offs into reliable automation that fails loudly instead of silently.

The checklist is the same each time: verify, act, verify, log — and if any step fails, stop and escalate. That is exactly what a hardened bash script does with conditionals, exit codes and set -e: it never skips a step silently, and it tells you loudly when something is wrong.

• The shebang (#!/usr/bin/env bash) tells the kernel which interpreter to run the file with, so ./script.sh works without typing bash explicitly.
• Bash executes the file line by line in a child shell, keeping variables and working directory changes isolated from your interactive session.
• Positional parameters ($1, $2, ...) map to the arguments you pass on the command line, and $? always holds the exit status of the last command.
• Conditionals (if/test) and loops (for/while) are syntax that controls the order and repetition of command execution.
• An exit code of 0 reports success; any non-zero value reports failure. set -euo pipefail makes the script terminate automatically when a command or pipeline fails.

• Deploy and release scripts: build, copy artifacts, run migrations, restart services — executed by cron or CI runners.
• Backup and rotation jobs that tar a directory, upload it and clean up old copies, always logging and exiting non-zero on failure.
• Health-check and self-healing wrappers: restart a service if a probe fails, capped with retry limits.
• Environment bootstrap scripts (provisioning) that install packages, create users and apply config on fresh VMs.
• Database maintenance and ETL glue — dump, transform with awk/sed, and load — glued together where heavy tools are overkill.

• Start every script with #!/usr/bin/env bash and set -euo pipefail.
• Quote every variable expansion: "$VAR" — unquoted expansions silently split and glob.
• Use ${VAR:-default} for optional inputs and validate required arguments at the top of the script.
• Prefer clear names and functions for logic that is used more than once; keep each function doing one job.
• Always exit non-zero on failure and write a meaningful message to stderr with >&2.
• Run shellcheck on every script in CI — it catches quoting, POSIX and syntax bugs a human misses.

• Spaces around = in assignments: name = "alice" runs the command name, not an assignment.
• Forgetting to make the script executable, then failing with ./script.sh: Permission denied.
• Using $@ unquoted, which splits arguments; use "$@" to preserve each argument as one word.
• Writing [ "$x" = "y" ] with && inside [ ], which is invalid — use [ "$x" = "y" ] && ... outside.
• Relying on set -e alone while a failing command is hidden inside a pipeline — add set -o pipefail.
• Not redirecting cron script output, so errors vanish into cron mail and nobody reads them.

• bash -n script.sh checks syntax only; bash -x script.sh traces every command and its expansion.
• Add set -x temporarily inside the script to see values as they are evaluated, then remove it.
• echo "DEBUG: VAR=$VAR" before and after the suspect block to see where the value changes.
• Run shellcheck and fix every warning before debugging behavior — most bash bugs are lint-visible.
• Reduce: isolate the failing line in a tiny test script, then grow it back one line at a time.