EX200 Create simple shell scripts — Timed 25 Questions

Question 1

A system administrator needs to create a shell script that checks if the user 'jdoe' exists in the system and, if not, creates the user with a home directory. The script should also verify that the creation was successful. Which of the following script snippets correctly implements this logic?

25 minute time limit — choose an answer to begin.

Accepted Answer

if id 'jdoe' &>/dev/null; then echo 'Exists'; else useradd -m 'jdoe' && echo 'Created' || echo 'Failed'; fi. It uses `id` to check for the user's existence (redirecting output to /dev/null to suppress messages), then uses `useradd -m` to create the user with a home directory. The `&&` and `||` operators ensure that success or failure of the creation is explicitly reported, fulfilling the requirement to verify successful creation.

Answer

if grep -q '^jdoe:' /etc/passwd; then echo 'Exists'; else useradd 'jdoe' && echo 'Created'; fi

Answer

if ! id 'jdoe' &>/dev/null; then useradd -m 'jdoe'; else echo 'Exists'; fi

Answer

[ -z $(id 'jdoe' 2>/dev/null) ] && useradd -m 'jdoe' && echo 'Created'

Question 2

Refer to the exhibit. A junior admin runs this script as root, but it always prints 'httpd is running' even when httpd is stopped. What is the most likely cause?

Accepted Answer

The script uses the test command `[` instead of directly using the command as the condition, causing the condition to always be true.. When a command is used as a condition inside `[ ]`, the `test` builtin evaluates the exit status of the command inside the brackets, not the command itself. In this script, `[ systemctl is-active httpd ]` always returns true (exit code 0) because `[` treats the string "systemctl" as a non-empty string, which is always true. The correct syntax is to use the command directly as the condition: `if systemctl is-active httpd; then`.

Answer

The script is not executable and is run with `sh script.sh`, causing the shebang to be ignored.

Answer

The variable SERVICE is misspelled as "HTTPD" in the condition.

Answer

The `systemctl` command requires root privileges, and the script is run as a non-root user.

Question 3

You are a system administrator for a medium-sized company running Red Hat Enterprise Linux 8 on all servers. The development team has created a shell script that is supposed to be run nightly via cron to synchronize configuration files from a master server to multiple web servers. The script is located at /opt/scripts/sync_configs.sh and is owned by root. It uses rsync over SSH with key-based authentication. The script works perfectly when run manually by root, but when it runs via cron, the synchronization fails with the error 'Host key verification failed.' The script does not explicitly specify any SSH options. The cron job is configured in /etc/crontab as: `0 2 * * * root /opt/scripts/sync_configs.sh`. The SSH keys are stored in /root/.ssh/id_rsa and the known_hosts file contains the correct host key for the master server. What is the most likely cause of the failure, and what is the best course of action to resolve it?

Accepted Answer

The cron environment lacks the SSH agent or the key is not loaded. Modify the script to use `ssh -i /root/.ssh/id_rsa -o StrictHostKeyChecking=no` or add a line to load the key via `ssh-add`.. D is correct because cron runs in a minimal environment that does not automatically load the SSH agent or add keys to it. When the script runs manually as root, the SSH agent is typically running and the key is loaded, but cron does not have access to the agent's socket. The error 'Host key verification failed' is misleading; the actual issue is that SSH cannot authenticate because the private key is not available to the agent, not that the host key is unknown. Adding `ssh -i /root/.ssh/id_rsa` explicitly specifies the key file, bypassing the need for an agent, or using `ssh-add` in the script loads the key into an agent for the cron session.

Answer

The PATH variable in cron does not include /usr/bin/rsync. Add a full path to rsync in the script or set PATH in the crontab.

Answer

The script does not have execute permission for the root user. Run `chmod +x /opt/scripts/sync_configs.sh`.

Answer

The known_hosts file in /root/.ssh/ contains an incorrect host key for the master server. Remove the entry and reconnect manually to update it.

Question 4

Match each package management command to its action.

Accepted Answer

dnf install: Installs a package with dependencies. In RHEL 8/9, DNF is the default package manager. 'dnf install' installs packages with dependencies, 'dnf remove' uninstalls, 'rpm -ivh' installs local RPMs without dependency resolution. 'dnf update' updates all packages, and 'dnf search' finds packages by keyword. Common confusions arise between install/update and remove/search.

Answer

dnf update: Installs a package with dependencies

Answer

dnf search: Removes a package

Question 5

A junior admin writes a script that uses functions. They notice that a variable set inside a function is not available after the function call. What is the likely cause and best practice?

Accepted Answer

The variable was declared with 'local', change to 'global' keyword. The variable is unavailable after the function call because it was declared with the 'local' keyword. To make it global, you should either remove the 'local' declaration or explicitly use 'declare -g'. There is no 'global' keyword in bash. Option A's cause is correct but its remedy is wrong; Option D has the correct remedy but incorrectly claims variables are local by default. Therefore, none of the given options is entirely correct.

Answer

The script must be sourced (.) instead of executed to retain variables

Answer

The function was called inside a subshell, use 'export' to make it global

Answer

In bash, variables declared in a function are local by default, use 'declare -g' to make them global

Question 6

A sysadmin creates a script to rotate log files. The script uses 'find /var/log -type f -name "*.log" -mtime +30 -exec gzip {} \;' but some log files are not compressed. The script runs as root. What is the most likely reason some files remain uncompressed?

Accepted Answer

Another process deletes log files between find's detection and execution, causing 'find' to error on missing files. The `find` command traverses the directory and for each matching file, it invokes `gzip`. There is a time-of-check-to-time-of-use (TOCTOU) race condition: between the moment `find` identifies a file and the moment `gzip` opens it, another process (e.g., logrotate) may delete or rename the file. In that case, `gzip` will fail with a 'No such file or directory' error, and that log file's data will not be compressed. Since the script runs as root, permission problems are not the cause.

Answer

The log files are already compressed (.gz extension), and gzip fails silently

Answer

The script lacks proper quoting around {} which causes gzip to fail on files with spaces

Answer

The '-mtime +30' flag selects files newer than 30 days, so old files are excluded

Question 7

A script uses 'read' to get user input and then performs an action based on the input. However, when the script is piped (e.g., './script.sh | othercommand'), the read command does not wait for input and the script continues with empty variable. How can this be fixed?

Accepted Answer

Use 'exec < /dev/tty' at the start of the script. Both `read input < /dev/tty` and `exec < /dev/tty` at the script start redirect input to the controlling terminal, fixing the issue. The example `./script.sh | othercommand` pipes stdout, not stdin, so it would not cause the described problem.

Answer

Use 'stdbuf -i0' before the script invocation to set stdin unbuffered

Answer

Use 'read -t 0 input' to force immediate read

Question 8

Which TWO of the following are valid ways to make a shell script executable?

Accepted Answer

chmod 755 script.sh. Option B (chmod 755 script.sh) is correct because it sets the execute bits for owner, group, and others (rwxr-xr-x), making the script directly executable via ./script.sh. Option D (chmod u+x script.sh) is correct because it adds the execute permission for the file's owner, which is sufficient to run the script as that user. Option A (bash script.sh) invokes the interpreter explicitly and does not require or change the execute permission, so it is not a way to make the script executable. Option C (. script.sh) sources the script in the current shell, which also does not require the execute bit and is not a method of making it executable. Option E (chmod +x script.sh) is a valid chmod command but was not marked as correct, so it is excluded here.

Answer

bash script.sh

Answer

. script.sh

Answer

chmod +x script.sh

Question 9

Which TWO methods correctly create a variable containing the number of regular files in the current directory (excluding . and ..)?

Accepted Answer

count=$(find . -maxdepth 1 -type f -printf '.' | wc -c). Option B is correct because `find . -maxdepth 1 -type f -printf '.'` prints exactly one dot character for each regular file found directly in the current directory, and `wc -c` counts those characters, yielding the number of regular files while excluding directories, symlinks, and the . and .. entries. Option E is correct because `find . -maxdepth 1 -type f` lists only regular files at depth one, and piping to `wc -l` counts those lines, again excluding . and .. and non-regular entries. Option A is wrong because `ls -1A` lists all entries except . and .., including directories, symlinks, and other non-regular files, so its count is not limited to regular files. Option C is wrong because `stat -c%F *` does not include hidden files (glob `*` skips dotfiles) and can fail or misbehave on names, so it does not reliably count all regular files in the current directory. Option D is wrong because `ls -1` includes directories and other non-regular entries and also omits hidden files, so it does not count regular files correctly.

Answer

count=$(ls -1A | wc -l)

Answer

count=$(stat -c%F * | grep -c 'regular file')

Answer

count=$(ls -1 | wc -l)

Question 10

You are tasked with creating a script that reads a list of usernames from /tmp/users.txt, one per line, and creates a home directory for each user using `mkdir /home/$username`. The script is:

#!/bin/bash
while read username; do
  mkdir /home/$username
done < /tmp/users.txt

However, the script fails for usernames that contain spaces (e.g., 'john smith'). The error is 'mkdir: cannot create directory '/home/john': File exists' and then a separate directory for 'smith'. What is the best fix?

Accepted Answer

Use `while IFS= read -r username` to preserve the line as is.. Setting `IFS=` (to an empty value) before the `read` command prevents the shell from splitting the line into fields based on whitespace. The `-r` option prevents backslash escapes from being interpreted. Together, they ensure that each line from the file is read exactly as is, preserving spaces in usernames. Option B is not sufficient because even though quoting `$username` prevents word splitting in the `mkdir` command, the `read` command itself splits the line before the variable is assigned, so the username is already broken into multiple words. Option A changes to a `for` loop that iterates over the output of `cat`, which also splits on whitespace and is subject to pathname expansion. Option C disables pathname expansion (globbing) but does not affect word splitting by `read`.

Answer

Change the loop to `for username in $(cat /tmp/users.txt)`.

Answer

Quote $username in the mkdir command as in `mkdir "/home/$username"`.

Answer

Add `set -f` to disable pathname expansion.

Question 11

A developer wrote a shell script that is intended to back up log files by copying all .log files from /var/log/myapp to /backup/logs. The script runs daily via cron but the backup folder is empty. The script contains the following line: `cp /var/log/myapp/*.log /backup/logs/`. What is the most likely reason the backup fails?

Accepted Answer

No .log files exist in /var/log/myapp at the time of script execution, causing the glob to match nothing.. The glob pattern `*.log` in the `cp` command is expanded by the shell at the time the script runs. If no `.log` files exist in `/var/log/myapp` when the cron job executes, the shell passes the literal string `*.log` to `cp`, which then fails with a 'No such file or directory' error (or, depending on shell settings, may silently do nothing). This is a common issue when log rotation or cleanup removes files before the backup runs.

Answer

The PATH variable in cron is not set, so cp cannot be found.

Answer

The script does not have execute permission for the user running cron.

Answer

The cron job is not enabled because the crontab syntax is incorrect.

Question 12

Which THREE of the following practices are recommended when creating simple shell scripts in a Red Hat Enterprise Linux environment to ensure reliability, security, and maintainability?

Accepted Answer

Quote variables when used in commands, e.g., "$file" instead of $file.. Quoting variables (e.g., "$file") prevents word splitting and glob expansion, which can cause commands to operate on unexpected arguments or filenames with spaces. This is a fundamental shell scripting best practice that directly improves reliability and security by preserving the intended value of the variable.

Answer

Use #!/bin/sh for compatibility, even if bash-specific features are needed.

Answer

Always run scripts by invoking the interpreter directly (e.g., bash script.sh) instead of making them executable.

Question 13

Which TWO of the following are true about creating simple shell scripts in Red Hat Enterprise Linux?

Accepted Answer

The shebang line (e.g., #!/bin/bash) is used to specify the interpreter.. The shebang line (e.g., #!/bin/bash) tells the kernel which interpreter to use when executing the script. Without it, the shell may fall back to the default interpreter (often /bin/sh) or fail to run the script correctly. This is a fundamental requirement for any interpreted script in Linux.

Answer

Scripts must be stored in /usr/local/bin to be found by the shell.

Answer

A script must be compiled before it can be run.

Answer

A script must have a .sh file extension to be executable.

Question 14

You are a system administrator for a small company. The development team has created a shell script named 'deploy.sh' that automates deployment of a web application. The script is located at /home/devops/deploy.sh. The team reports that when they run the script with './deploy.sh' from the /home/devops directory, it fails with a 'Permission denied' error. However, running 'bash deploy.sh' works fine. Additionally, the script's first line is '#!/bin/bash' and the file permissions are '-rw-rw-r--'. The team wants to be able to run the script directly without typing 'bash'. Which of the following actions should you take to resolve the issue?

Accepted Answer

Add the execute permission to the script using 'chmod +x /home/devops/deploy.sh'.. The 'Permission denied' error when running './deploy.sh' indicates that the script lacks execute permission. The current permissions '-rw-rw-r--' show read/write for owner and group, and read-only for others, but no execute bit. Adding execute permission with 'chmod +x' allows the script to be run directly via its shebang line.

Answer

Change the shebang line to '#!/bin/sh' because bash is not the default shell.

Answer

Move the script to /usr/local/bin so it can be found in the PATH.

Answer

Change the owner of the script to root using 'chown root:root /home/devops/deploy.sh'.

Question 15

Arrange the steps to configure a logical volume snapshot named 'snap_lv_data' of logical volume 'lv_data'.

Accepted Answer

Create snapshot using lvcreate -s, Mount snapshot to a directory, Perform operations on snapshot, Unmount snapshot, Remove snapshot. The correct sequence for configuring a logical volume snapshot is to first create the snapshot with lvcreate -s, mount it to access its contents, perform necessary operations (such as backups), unmount the snapshot, and finally remove it to clean up. Common mistakes include mounting or operating on the snapshot before it exists, or removing it prematurely.

Answer

Mount snapshot to a directory, Create snapshot using lvcreate -s, Perform operations on snapshot, Unmount snapshot, Remove snapshot

Answer

Create snapshot using lvcreate -s, Perform operations on snapshot, Mount snapshot to a directory, Unmount snapshot, Remove snapshot

Answer

Create snapshot using lvcreate -s, Mount snapshot to a directory, Remove snapshot, Perform operations on snapshot, Unmount snapshot

Question 16

An administrator writes a script that uses the 'set -e' option at the top. What is the primary effect of this option?

Accepted Answer

It exits the script immediately if a command fails. The 'set -e' option instructs the shell to exit immediately if any command or pipeline returns a non-zero exit status (i.e., fails). This is commonly used in scripts to prevent execution from continuing after an error, which could lead to unpredictable behavior or data corruption. It does not affect variable handling, command printing, or debug verbosity.

Answer

It treats unset variables as an error

Answer

It prints each command before execution

Answer

It enables debug mode with verbose output

Question 17

A system administrator needs to create a shell script that processes a list of hostnames stored in a file, one per line, and runs a command on each host. Which loop construct is most appropriate?

Accepted Answer

while read host; do ... done < hosts. The `while read host; do ... done < hosts` construct reads the file line by line, preserving each hostname exactly as it appears, including spaces or special characters. This is the safest and most idiomatic way to process a list of hostnames in a shell script, as it avoids word splitting and glob expansion issues that can occur with other methods.

Answer

for i in $(seq 1 $(wc -l < hosts)); do ... done

Answer

for host in $(cat hosts); do ... done

Answer

until read host; do ... done < hosts

Question 18

A developer wants to create a script that accepts a directory path as an argument and creates a timestamped backup of that directory. If no argument is provided, it should back up the current directory. How should the script handle the argument?

Accepted Answer

dir=${1:-.}. `${1:-.}` uses the default value substitution syntax in bash: if parameter `$1` (the first positional argument) is unset or null, it expands to `.` (the current directory). This ensures the script backs up the supplied directory path or defaults to the current directory when no argument is provided, exactly matching the requirement.

Answer

dir=${@:-.}

Answer

dir=${0:-.}

Answer

dir=${?:-.}

Question 19

An administrator writes a script to check disk usage and send an alert if usage exceeds 80%. The script uses 'df -h /' and parses the output. To maintain portability and avoid common pitfalls, which approach is recommended?

Accepted Answer

Use 'df / | awk 'NR==2 {print $5}' | tr -d '%'. It uses `df /` (without `-h`) to produce a stable, machine-parseable output where the fifth field (`$5`) is always the percentage used, and `awk` reliably extracts it. The `tr -d '%'` removes the percent sign for numeric comparison. This approach avoids the portability issues of parsing human-readable output from `df -h`, which can vary in column spacing and ordering across different Unix/Linux systems.

Answer

Use 'df -h / | tail -1 | sed 's/.* //' | tr -d '%'

Answer

Use 'df -h / | tail -1 | cut -d' ' -f5'

Answer

Use 'df -h / | grep -oP '\d+%'

Question 20

A script needs to execute a command that might fail, but the script should continue. The administrator wants to capture the exit status for logging. Which code snippet correctly implements this?

Accepted Answer

./risky_command; rc=$?; echo $rc. It runs the risky command, captures its exit status immediately after in the `$?` variable, and then echoes it for logging. The script continues regardless of the command's success or failure, which meets the requirement. The `$?` variable holds the exit status of the last executed foreground command, so assigning it to `rc` right after `./risky_command` ensures the correct value is stored.

Answer

set -e; ./risky_command; rc=$?; echo $rc

Answer

rc=$? ./risky_command; echo $rc

Answer

./risky_command && rc=$?; echo $rc