Shell Scripting Basics

A shell script is nothing more than a plain text file that contains a sequence of Linux commands. When you run that file, the shell (the program that reads and executes your commands, like Bash) reads each line and does what it says, one after the other. Think of it as a to-do list for your computer. Instead of you typing 'mkdir new_folder' and then 'cd new_folder' and then 'nano report.txt' one by one, you put all three commands in a file called 'setup.sh', make it executable, and run it. The computer does the rest.

To create a shell script, you need three things: a text editor (like nano or vim), the 'shebang' line at the top of the file, and the correct file permissions. The shebang line looks like '#!/bin/bash'. It tells the system which shell interpreter to use. Without it, the system might guess wrong and your script could fail with confusing errors. After you write your commands, you must make the script executable with the command 'chmod +x scriptname.sh'. This tells Linux 'yes, this file is allowed to be run as a program'.

Variables are a fundamental building block. A variable is a named container that holds data. You assign data to it with an equals sign, like 'name="Alice"'. Notice there are no spaces around the equals sign. To use that value later, you put a dollar sign in front of the variable name, like 'echo $name'. This will print 'Alice' on the screen. Variables let you write scripts that work with different data without changing the script itself. Instead of hard-coding a file path, you use a variable and set it once at the top of the script.

Loops let you repeat a set of commands multiple times. The most common loop is the 'for' loop. It looks like this:

for file in *.txt do echo "Processing $file" done

This loops over every file that ends with '.txt' in the current directory, runs the 'echo' command for each one, and substitutes the current file's name into the '$file' variable. There is also the 'while' loop, which runs as long as a condition is true, like 'while [ $count -lt 10 ]'. You almost always need a counter variable and a way to change that condition inside the loop, or it will run forever (an 'infinite loop') and you will have to press Ctrl+C to stop it.

Conditionals let your script make decisions. The basic structure is 'if', 'then', 'else', and 'fi' (which is 'if' backwards). For example:

if [ -f /etc/passwd ] then echo "The file exists" else echo "File not found" done

This checks if the file /etc/passwd exists ('-f' means 'is a file'). If it does, the script prints one message; otherwise, it prints another. The square brackets are actually a command called 'test'. You must have spaces inside them, or the test will fail. Conditionals let your script react to different situations.

Functions are mini-scripts inside your script. You define one with 'myfunction() { commands; }'. Then you 'call' it by typing its name. Functions are brilliant for avoiding repetition. If you need to print a timestamped log message ten times, write one function for that task and call it whenever needed. If you later want to change the format of the timestamp, you change it in one place instead of ten.

Shell scripting replaces the tedious, error-prone work of typing dozens or hundreds of commands manually. It is how system administrators automate backups, monitor server health, process log files, and deploy software. It makes the computer do the boring work while the human does the thinking.

Imagine you work for a small company that runs its website on a Linux server. Every night, the server needs to be backed up. The manual way would be to SSH into the server, type 'tar -czf backup_$(date +%Y%m%d).tar.gz /var/www', then copy that file to a backup drive. If you do it once, fine. If you do it every single night for a year, you will eventually forget, typo a path, or fall asleep. A shell script handles this perfectly.

Here is what a real IT professional does. First, she writes a script called 'nightly_backup.sh' in her home directory. The script starts with '#!/bin/bash'. Then she sets a variable for the source directory: 'SOURCE_DIR="/var/www"'. And one for the backup destination: 'BACKUP_DIR="/mnt/backups"'.

Then she uses a conditional to check if the backup drive is mounted. If the drive is not mounted, the script should not run. The command looks like 'if mount | grep -q /mnt/backups'. If it fails, the script prints a warning and exits with a non-zero exit code (like 'exit 1'), which would trigger an alert to her team.

Next, she uses a 'for' loop to check which old backups exist. She might decide to keep only the last 30 backups. The loop iterates over backup files, counts them, and if there are more than 30, deletes the oldest ones using 'rm'. This prevents the backup drive from filling up.

Then comes the actual backup command: she runs 'tar -czf ${BACKUP_DIR}/backup_$(date +%Y%m%d_%H%M%S).tar.gz $SOURCE_DIR'. She wraps the backup action inside a function called 'create_backup' so that if she ever needs to change how the backup is compressed, she edits one function instead of the whole script.

Finally, she schedules the script using 'cron'. She runs 'crontab -e' and adds a line: '0 2 * * * /home/admin/nightly_backup.sh'. This tells Linux to run that script every day at 2:00 AM. From that point on, she never thinks about backups unless the script fails. That is the real power of shell scripting: it turns human vigilance into machine reliability.