Bash scripting basics: your first real scripts

Everything here runs as student in a new folder, ~/scripts, on rocky01, and none of the scripts changes the system. Each step gives you one whole block to paste: it creates the script with a here-document (the <<'EOF' you met in Lesson 14), then runs it. The outputs come from running these exact scripts; your times, UIDs and percentages can differ a little.

1Write your first script and make it run

Paste this whole block:

mkdir -p ~/scripts && cd ~/scripts
cat > hello.sh <<'EOF'
#!/bin/bash
# hello.sh: my first script
echo "Hello from $(hostname -s)"
echo "Today is $(date +%A), and you are logged in as $USER"
EOF
bash hello.sh
./hello.sh

You should see something like this:

Hello from rocky01
Today is Tuesday, and you are logged in as student
-bash: ./hello.sh: Permission denied

bash hello.sh works because you asked bash to read the file. ./hello.sh asks the kernel to run it, and the kernel refuses because the file has no execute bit. Give it one and try again:

chmod +x hello.sh
ls -l hello.sh
./hello.sh

You should see something like this:

-rwxr-xr-x. 1 student student 133 Oct 27 11:05 hello.sh
Hello from rocky01
Today is Tuesday, and you are logged in as student

The ./ matters: bash only looks for commands in the folders listed in $PATH, and the current folder isn’t one of them. $(hostname -s) and $(date +%A) were replaced by their output before echo ran, and $USER is a variable bash sets for you.

✅ Checkpoint: ./hello.sh prints two lines and ls shows rwx for the owner.

2Store values in variables and quote them

Paste this whole block:

cat > vars.sh <<'EOF'
#!/bin/bash
# vars.sh: variables, quoting and command substitution
server="rocky01"
os_name="Rocky Linux"
kernel=$(uname -r)
root_used=$(df --output=pcent / | tail -n 1 | tr -d ' %')

echo "Server:   $server"
echo "OS:       $os_name"
echo "Kernel:   $kernel"
echo "Root use: ${root_used}%"
EOF
chmod +x vars.sh
./vars.sh

You should see something like this:

Server:   rocky01
OS:       Rocky Linux
Kernel:   6.12.0-211.16.1.el10_2.0.1.x86_64
Root use: 12%

A variable is set with name=value and no spaces, and read with $name. The value with a space, Rocky Linux, needs quotes when you set it. root_used holds the output of a small pipeline from Lesson 14, and the braces in ${root_used}% tell bash where the name ends. Now try the three kinds of quoting at the prompt:

server="rocky01"
echo 'Single quotes print $server as it is'
echo "Double quotes print $server"
echo "${server}_old and $server_old"

You should see this:

Single quotes print $server as it is
Double quotes print rocky01
rocky01_old and 

Single quotes keep everything as typed. Double quotes still expand variables but stop word splitting, which is what you want almost always. In the last line bash looked for a variable called server_old, found nothing and printed an empty string, without any error.

Braces fix that.

✅ Checkpoint: vars.sh shows your kernel and root use, and you can explain why the last line ends empty.

3Read the command line: $0, $1, $# and “$@”

Paste this whole block:

cat > args.sh <<'EOF'
#!/bin/bash
# args.sh: show what a script receives on its command line
echo "Script name: $0"
echo "First:       $1"
echo "Second:      $2"
echo "Count:       $#"
echo "All:         $*"
for arg in "$@"; do
    echo "  -> [$arg]"
done
EOF
chmod +x args.sh
./args.sh priya "web team" arjun

You should see this:

Script name: ./args.sh
First:       priya
Second:      web team
Count:       3
All:         priya web team arjun
  -> [priya]
  -> [web team]
  -> [arjun]

$0 is the script’s name as you typed it, $1 and $2 are the first two arguments and $# is how many there are. “web team” arrived as one argument because you quoted it. "$@" in the for loop keeps each argument as it was typed, while $* glues them into one string, which is fine for printing and wrong for looping.

✅ Checkpoint: The loop prints three items, and “web team” stays together.

4Make decisions with if and test

Paste this whole block:

cat > checkuser.sh <<'EOF'
#!/bin/bash
# checkuser.sh: report whether each user named on the command line exists
# Exit codes: 0 all found, 1 at least one missing, 2 used wrongly

if [ $# -eq 0 ]; then
    echo "Usage: $0 USER [USER...]" >&2
    exit 2
fi

missing=0
for user in "$@"; do
    if id "$user" >/dev/null 2>&1; then
        uid=$(id -u "$user")
        if [ "$uid" -ge 1000 ]; then
            kind="regular user"
        else
            kind="system account"
        fi
        echo "OK      $user (UID $uid, $kind)"
    else
        echo "MISSING $user"
        missing=$((missing + 1))
    fi
done

if [ "$missing" -gt 0 ]; then
    echo "$missing of $# user(s) missing"
    exit 1
fi
echo "All $# user(s) found"
EOF
chmod +x checkuser.sh
./checkuser.sh priya arjun appsvc

You should see something like this:

OK      priya (UID 1001, regular user)
OK      arjun (UID 1002, regular user)
OK      appsvc (UID 991, system account)
All 3 user(s) found

The first if tests $# with -eq (numbers) and prints a usage line to standard error with >&2 when there are no arguments. Inside the loop, if id "$user" uses the exit code of id directly, with its output thrown away into /dev/null. The inner if compares the UID with 1000, the line between system accounts and people that you saw in Lesson 15.

✅ Checkpoint: All three users show OK, and appsvc is reported as a system account.

5Use exit codes, $? and the && and || shortcuts

Run this:

./checkuser.sh priya ghost; echo "exit code: $?"
./checkuser.sh; echo "exit code: $?"
./checkuser.sh arjun >/dev/null && echo "arjun is there" || echo "arjun is missing"
./checkuser.sh ghost >/dev/null && echo "ghost is there" || echo "ghost is missing"
grep -q '^webteam:' /etc/group && echo "group webteam exists"

You should see this:

OK      priya (UID 1001, regular user)
MISSING ghost
1 of 2 user(s) missing
exit code: 1
Usage: ./checkuser.sh USER [USER...]
exit code: 2
arjun is there
ghost is missing
group webteam exists

The script returns 1 when it found a problem and 2 when you used it wrongly, so a caller can tell the two apart. a && b runs b only if a succeeded, and a || b runs b only if a failed. grep -q prints nothing and only sets the exit code, which makes it perfect for tests like the last line.

Be careful with a && b || c. It isn’t a real if/else: c also runs when a succeeds but b fails. It’s fine when b is an echo, as above; for anything that can fail, write a proper if.

✅ Checkpoint: You see exit code 1 for the missing user and 2 for the missing argument.

6Compare numbers and text the right way

Run this at the prompt first:

[ 9 -lt 10 ] && echo "9 is smaller than 10 as numbers"
[[ 9 < 10 ]] || echo "but as text, 9 comes after 10"
[[ $(hostname -s) == rocky* ]] && echo "the name starts with rocky"

You should see this:

9 is smaller than 10 as numbers
but as text, 9 comes after 10
the name starts with rocky

-lt compares numbers. < inside [[ ]] compares text in dictionary order, where “9” sorts after “1”, so it says 9 is not less than 10. Use the letter operators for numbers and = != == < > for text. Now a script that uses a number test with a default limit:

Paste this whole block:

cat > rootuse.sh <<'EOF'
#!/bin/bash
# rootuse.sh: compare how full / is with a limit (default 80)
limit=${1:-80}
used=$(df --output=pcent / | tail -n 1 | tr -d ' %')

if [ "$used" -ge "$limit" ]; then
    echo "WARNING: / is ${used}% full (limit ${limit}%)"
    exit 1
elif [ "$used" -ge $((limit - 10)) ]; then
    echo "NOTICE: / is ${used}% full, close to the ${limit}% limit"
else
    echo "OK: / is ${used}% full (limit ${limit}%)"
fi
EOF
chmod +x rootuse.sh
./rootuse.sh; echo "exit $?"
./rootuse.sh 20; echo "exit $?"
./rootuse.sh 10; echo "exit $?"

You should see something like this:

OK: / is 12% full (limit 80%)
exit 0
NOTICE: / is 12% full, close to the 20% limit
exit 0
WARNING: / is 12% full (limit 10%)
exit 1

${1:-80} means “the first argument, or 80 if there isn’t one”. elif adds a second test, and $((limit - 10)) does whole-number arithmetic. Only the WARNING branch exits with 1, so a cron job or monitor can act on it.

✅ Checkpoint: rootuse.sh gives OK, NOTICE and WARNING for the limits 80, 20 and 10.

7Ask a question with read

Paste this whole block:

cat > svcask.sh <<'EOF'
#!/bin/bash
# svcask.sh: ask for a service name and say whether it is running
read -r -p "Which service should I check? " svc

if [[ -z $svc ]]; then
    echo "No service name given" >&2
    exit 2
fi

if systemctl is-active --quiet "$svc"; then
    echo "$svc is running"
else
    echo "$svc is NOT running (state: $(systemctl is-active "$svc"))"
    exit 1
fi
EOF
chmod +x svcask.sh
./svcask.sh

Type sshd and press Enter. You should see this:

Which service should I check? sshd
sshd is running

Now feed the answer through a pipe instead of typing it:

echo nginx | ./svcask.sh; echo "exit $?"
echo chronyd | ./svcask.sh; echo "exit $?"

You should see this:

nginx is NOT running (state: inactive)
exit 1
chronyd is running
exit 0

read -r -p shows the question and stores the line you type in svc; -r keeps backslashes as typed. When the answer comes from a pipe, bash hides the question because nobody is there to read it. nginx isn’t installed yet (Lesson 56 does that), so systemctl reports inactive, and chronyd is the time service you’ll configure in Lesson 40.

✅ Checkpoint: svcask.sh says sshd and chronyd are running and exits with 1 for nginx.

8Loop over a file with while, and over files with for

Paste this whole block:

cat > hosts.txt <<'EOF'
rocky01.saatlab.test
ubu01.saatlab.test
kafka01.saatlab.test
EOF
cat > pinghosts.sh <<'EOF'
#!/bin/bash
# pinghosts.sh: ping every host listed in a file, one name per line
list=${1:-hosts.txt}

if [ ! -r "$list" ]; then
    echo "Cannot read $list" >&2
    exit 2
fi

up=0
down=0
while read -r host; do
    [ -z "$host" ] && continue
    if ping -c 1 -W 1 "$host" >/dev/null 2>&1; then
        echo "UP    $host"
        up=$((up + 1))
    else
        echo "DOWN  $host"
        down=$((down + 1))
    fi
done < "$list"

echo "$up up, $down down"
[ "$down" -eq 0 ]
EOF
chmod +x pinghosts.sh
./pinghosts.sh; echo "exit $?"

You should see something like this:

UP    rocky01.saatlab.test
UP    ubu01.saatlab.test
DOWN  kafka01.saatlab.test
2 up, 1 down
exit 1

while read -r host reads hosts.txt one line at a time, because of the < "$list" after done. ping -c 1 -W 1 sends one packet and waits one second. kafka01 is in /etc/hosts but the VM only appears in Lesson 58, so it’s down for now (or ubu01 is down too, if it isn’t running). The last line, [ "$down" -eq 0 ], has no if around it: its exit code becomes the script’s exit code.

A for loop over files is handy for checking all your scripts at once:

for f in *.sh; do bash -n "$f" && echo "$f: syntax ok"; done

You should see this:

args.sh: syntax ok
checkuser.sh: syntax ok
hello.sh: syntax ok
pinghosts.sh: syntax ok
rootuse.sh: syntax ok
svcask.sh: syntax ok
vars.sh: syntax ok

✅ Checkpoint: pinghosts.sh reports kafka01 as DOWN and exits with 1, and all your scripts pass bash -n.

9Put repeated work into functions

Paste this whole block:

cat > sysinfo.sh <<'EOF'
#!/bin/bash
# sysinfo.sh: a short report built from two small functions

# line LABEL VALUE: print one aligned line
line() {
    printf '%-9s %s\n' "$1:" "$2"
}

# reachable HOST: exit code 0 if HOST answers one ping
reachable() {
    ping -c 1 -W 1 "$1" >/dev/null 2>&1
}

line "Host" "$(hostname -s)"
line "Kernel" "$(uname -r)"
line "Uptime" "$(uptime -p)"
for h in ubu01 kafka01; do
    if reachable "$h"; then
        line "$h" "answers ping"
    else
        line "$h" "no reply"
    fi
done
EOF
chmod +x sysinfo.sh
./sysinfo.sh

You should see something like this:

Host:     rocky01
Kernel:   6.12.0-211.16.1.el10_2.0.1.x86_64
Uptime:   up 2 hours, 7 minutes
ubu01:    answers ping
kafka01:  no reply

A function is defined once with name() { ... } and called like any command. Inside it, $1 and $2 are the function’s own arguments, not the script’s. reachable has no echo at all: its exit code is the exit code of its last command, ping, so it slots straight into an if. Lesson 39 builds on this with local variables and a full health-check script.

✅ Checkpoint: sysinfo.sh prints five aligned lines, and you can point at the two functions it uses.