Linux Shell Foundations and the DBA Command Line

Why the Command Line Matters to a DBA

Database administrators spend a large portion of every workday at the terminal. Whether you are checking which PostgreSQL processes are consuming memory, rotating log files, or scheduling a nightly backup, the Linux shell is your control panel. This lesson builds the Bash foundation that every automation script you write later will depend on. Accuracy matters here: a misplaced quote or a forgotten redirect can corrupt data or overwrite a file you needed.

The Linux Shell and Bash

Bash (Bourne Again SHell) is the default interactive shell on most Linux distributions, including CentOS and Ubuntu. When you open a terminal, Bash reads your commands, interprets them, and passes instructions to the Linux kernel. Every DBA automation script in this course is a plain text file of Bash commands saved with a `.sh` extension and executed by the Bash interpreter.

Bash reads commands from left to right. Before executing anything, it performs a set of expansions in a defined order: brace expansion, tilde expansion, parameter and variable expansion, command substitution, arithmetic expansion, word splitting, and pathname expansion. Understanding this order prevents hard-to-find bugs.

Variables

A variable stores a value for later use. Assignment uses no spaces around the equals sign:

```bash

DB_HOST=localhost

DB_PORT=5432

```

Retrieve the value by prefixing the name with `$`:

```bash

echo $DB_HOST

echo "Connecting to ${DB_HOST}:${DB_PORT}"

```

Braces around the name (`${DB_HOST}`) are optional when the variable name is unambiguous, but they are considered best practice because they prevent accidental concatenation with adjacent characters. Variable names are case-sensitive; by convention, environment and configuration variables are written in ALL_CAPS, while loop counters use lowercase.

Quoting Rules

Quoting controls which characters Bash interprets and which it treats as literal text. There are three quoting mechanisms:

• Single quotes (`'...'`) preserve every character literally. No variable expansion or command substitution occurs inside single quotes.
• Double quotes (`"..."`) allow variable expansion (`$VAR`), command substitution (`` `cmd` `` or `$(cmd)`), and backslash escaping, but suppress word splitting and pathname expansion.
• Backslash (`\`) escapes a single following character, making it literal.

A common DBA mistake is forgetting to quote a variable that contains spaces, causing a filename or connection string to be split into multiple arguments. Always quote variables that may contain whitespace: `"$DB_NAME"`.

Command Substitution

Command substitution runs a command and inserts its output inline. The preferred modern syntax uses `$(...)` rather than backticks, because it nests cleanly:

```bash

CURRENT_DATE=$(date +%Y-%m-%d)

echo "Backup started on $CURRENT_DATE"

```

DBAs use command substitution to capture dynamic values—row counts, process IDs, or timestamps—directly into variables without writing intermediate files.

Pipelines

A pipeline connects commands so the standard output (stdout) of one command becomes the standard input (stdin) of the next, using the pipe character `|`:

```bash

ps aux | grep postgres | grep -v grep

```

This lists all running processes (`ps aux`), filters for lines containing "postgres," and then removes the grep process itself from the results. Pipelines are fundamental to DBA work: they let you filter, sort, count, and transform data streams without writing temporary files.

Redirections

Redirection changes where a command reads from or writes to:

| Operator | Meaning |

|----------|---------|

| `>` | Write stdout to a file, overwriting it |

| `>>` | Append stdout to a file |

| `<` | Read stdin from a file |

| `2>` | Redirect stderr (error output) to a file |

| `2>&1` | Merge stderr into stdout |

Example: saving a PostgreSQL query log and capturing errors separately:

```bash

psql -U postgres -c "SELECT count(*) FROM pg_stat_activity;" > query_out.txt 2> query_err.txt

```

Overwriting a file with `>` is irreversible on most filesystems. Before using `>`, confirm you do not need the existing content; use `>>` to append when in doubt.

Safety at the Terminal

The Linux command line operates with the permissions of the logged-in user. Running database administration tasks as the `root` user or the `postgres` superuser without need is risky: a typo in a destructive command has immediate effect. Follow the principle of least privilege—use a regular OS account and `sudo` only for tasks that require elevated permissions, and only for the specific command needed. Before running any command that modifies or deletes data, test it in a non-production environment. When writing scripts that will run as scheduled jobs, store credentials in environment variables or a secured configuration file, never hard-coded in the script itself.

Navigating the Filesystem and Inspecting Processes

Key navigation commands every DBA uses daily:

• `pwd` — print working directory
• `cd /var/lib/postgresql` — change directory to the PostgreSQL data directory
• `ls -lh` — list files with human-readable sizes
• `find /var/log -name "*.log" -mtime -1` — find log files modified in the last day

Process inspection:

• `ps aux` — list all running processes with CPU and memory usage
• `top` — interactive real-time process monitor
• `pgrep -u postgres` — list process IDs owned by the postgres OS user

Putting It Together

Every DBA automation script—backup jobs, health checks, log rotation—is assembled from exactly these building blocks: variables that hold configuration, quoting that protects string values, command substitution that captures live data, pipelines that transform output, and redirections that preserve logs. Mastering these fundamentals now means every script you write in the remaining modules will be readable, reliable, and maintainable.