RHCSA / RH134 Glossary

Goal

Keep short definitions with the paths that show up in RH124, RH134, and ROL labs. I expand this as I progress through the course.

Reviewed terms

Base system paths

Shell and command line

Bash

Definition: Default shell on RHEL. Interprets commands, variables, and scripts.

Relevant paths:

Shebang

Definition: First line of a script (#!/bin/bash). Tells the system which interpreter runs the file.

Relevant paths:

Environment variable

Definition: Exported value (export VAR=value) inherited by child processes.

Relevant paths:

Permissions, owners, and roles (POSIX)

rwx permissions (read, write, execute)

Definition: Every file and directory has permissions for three categories: owner (user), group (group), and others (others). Each category may have r (read), w (write), and x (execute).

How to read ls -l:

-rwxr-xr--  1 root root  1234 Mar 26 10:00 script.sh
│└┬┘└┬┘└┬┘
│ u  g  o   ← user, group, others
└ type: - file, d directory, l link

In the example: owner = all; group = read + execute; others = read only → notation rwxr-xr--.

Numeric (octal) values

Each letter has a value; add them per category:

Example rwxr-xr-x → user 7, group 5, others 5 → chmod 755.

Common examples:

chmod — octal (numeric) form

Definition: Sets permissions with three digits (user, group, others).

chmod 755 script.sh      # rwxr-xr-x
chmod 644 config.conf    # rw-r--r--
chmod 600 secret.txt     # rw-------
chmod 1777 /tmp          # sticky on directory (leading 1 before 777)

chmod — symbolic form

Definition: Changes permissions by who and what to change, without recalculating full octal.

chmod u+x script.sh        # add execute for owner
chmod g-w file             # remove write for group
chmod o=r file             # others read-only
chmod a+r file             # everyone can read
chmod u=rwx,g=rx,o= script.sh   # explicit per category
chmod +x script.sh         # executable for all (u,g,o)

Owner and group: chown / chgrp

Definition: Changes who owns the file and which group it belongs to (not the rwx bits).

chown user:group file
chown root:root /etc/myapp.conf
chgrp developers project/
chown -R www:www /var/www/html/   # recursive on directory

Relevant paths:

umask

Definition: Mask that subtracts permissions from new files and directories.

umask          # show current mask (e.g. 0022)
umask 077      # very restrictive new files for owner

Relevant paths:

Special permissions (EX200 summary)

chmod u+s /usr/bin/command    # SUID symbolic
chmod g+s /srv/shared         # SGID on directory
chmod +t /tmp                 # sticky bit
chmod 4755 file               # SUID + 755

ACL (extended permissions)

Definition: Access control lists finer than u/g/o only (specific user, extra rules). Commands: getfacl, setfacl.

setfacl -m u:maria:rwx /srv/project
getfacl /srv/project

Example paths: Shared directories under /srv/ or /home/ in RH124 labs.

Reading and searching text

less

Definition: Terminal pager to scroll long files without dumping everything on screen (q to quit).

Example paths:

tail

Definition: Shows the last lines of a file. tail -f follows the file in real time (great for logs).

Example paths:

grep

Definition: Searches text patterns in files or pipes. grep -E uses extended regex.

Example paths:

Regular expression (regex)

Definition: Pattern to match text (., *, [], ^, $). In RH134 mainly used with grep -E.

Example paths: Any file under /etc/ or /var/log/ when filtering configs or logs.

Logs and system logging

syslog

Definition: Classic logging model: services and kernel write messages to log files.

Relevant paths:

rsyslog

Definition: Service that receives and routes syslog messages to files, sockets, or other targets.

Relevant paths:

Guided lab: redirect debug to /var/log/messages-debug

Exercise goal (RH134 / logs-syslog): have rsyslog write all messages at debug priority or higher (any facility) to /var/log/messages-debug.

Why practice this

Practicing syslog is not just “passing a lab”—it is learning where to look when something breaks on a server and how to make the system record what matters.

Analogy from development: syslog is “server-side observability”—levels (debug, info, err), filtering (grep/tail), and centralized rules (/etc/rsyslog.d/), like Sentry or structured logs but at the OS level.

In one sentence: control what the system logs, where it is written, and how you read it when something breaks—a foundation for sysadmin, DevOps, and any backend work on Linux.

Rule (in /etc/rsyslog.d/debug.conf):

*.debug /var/log/messages-debug

Steps (lab order):

# On workstation
lab start logs-syslog

ssh student@servera
sudo -i

# Create the file (exact name: debug.conf)
vi /etc/rsyslog.d/debug.conf
# content: *.debug /var/log/messages-debug

rsyslogd -N1                    # validate syntax
systemctl restart rsyslog

logger -p user.debug "Debug Message Test"
tail /var/log/messages-debug    # should show "Debug Message Test"

Expected output (example):

Feb 13 18:27:58 servera root[25416]: Debug Message Test

(You may also see systemd/rsyslogd lines from restarting the service.)

Common mistakes:

Finish the lab:

exit   # root → student → workstation
lab finish logs-syslog

journald · ✓ Reviewed {#journald—reviewed}

Status: reviewed in RH134 (syslog, journal, and logging labs).

Definition: systemd daemon that receives messages from the kernel, systemd, and services, and stores them in the journal (binary, indexed log—not a plain-text .log file).

Where it comes from: Built into systemd. Managed as a service/unit; main config in journald.conf.

What it is for:

Relation to journalctl: journald writes; journalctl reads. You almost always use them together.

Relevant paths:

Useful commands (service):

systemctl status systemd-journald
systemctl restart systemd-journald   # after changing journald.conf

journalctl · ✓ Reviewed {#journalctl—reviewed}

Status: reviewed in RH134 (syslog, journal, and logging labs).

Definition: Command to read and filter logs from the systemd journal (journald). It does not open plain text files in /var/log/ directly—it queries the structured log stored by the kernel, systemd, and services.

Where it comes from: Part of systemd. The journald daemon writes the journal; journalctl is the query tool. It complements (does not replace) syslog/rsyslog and files like /var/log/messages.

Strongest use case: Troubleshoot why a service failed to start or what happened since the last reboot, filtering by unit, time, or priority without hunting through multiple files.

Common uses:

Combined examples (most used in labs and EX200):

journalctl -u rsyslog.service -n 30 --no-pager
journalctl -u sshd.service --since today
journalctl -p warning -b
journalctl -xe

Priorities (-p): lowest to highest severity — debug, info, notice, warning, err, crit, alert, emerg.
journalctl -p err includes err and everything more severe.

Relevant paths:

journalctl vs. tail /var/log/messages:

On RHEL it pays to know both: many services write to the journal and also to syslog depending on config.

logger

Definition: Shell command to send messages to the system log (syslog/rsyslog and, depending on config, the journal too). It does not write a file by hand—it uses the system’s logging infrastructure.

Where it comes from: Part of the syslog ecosystem on RHEL (util-linux / logging tools). The message goes through the syslog API; rsyslog (or the active log daemon) routes it by facility, priority, and rules in /etc/rsyslog.conf.

Strongest use case: From scripts, cron, and one-liners, record events in the same pipeline as the rest of the system—with timestamp, tag, and priority—without scattered ad-hoc log files. Ideal for auditing backups, scheduled jobs, or custom automation.

How to use it:

logger "Backup finished successfully"
logger -t my-script "Task started"
logger -p user.info "Process OK"
logger -p user.warning "Disk space low"
logger -p local0.err "Copy failed"
echo "command output" | logger -t cron-lab -p info

Common priorities (low to high): debug, info, notice, warning, err, crit, alert, emerg.

Relevant paths:

See the result:

logger -t rh134-test -p user.info "Test message from glossary"
grep rh134-test /var/log/messages
# or live:
tail -f /var/log/messages

When to use it vs. echo to a file: echo >> /tmp/my.log stays isolated; logger integrates the event into centralized server logging—aligned with RH134 (syslog, cron, admin scripts).

systemd

systemd

Definition: Init and service manager on RHEL. Boots the system, mounts, targets, and unit dependencies.

Relevant paths:

Unit

Definition: A .service, .timer, .target, etc. file describing what to run and when.

Relevant paths:

systemctl

Definition: Command for start, stop, enable, disable, status, daemon-reload, list-timers, etc.

Related paths: Operates on units in /etc/systemd/system/ and /usr/lib/systemd/system/.

Target

Definition: Groups units for a system state (similar to legacy runlevels).

Example paths:

Timer (systemd)

Definition: A .timer unit that triggers a .service on a schedule (OnCalendar) or interval.

Relevant paths:

systemd-tmpfiles

Definition: Creates, cleans, and sets permissions on temp files/directories per rules.

Relevant paths:

Task scheduling

at

Definition: Schedules one job at a future date/time.

Relevant paths:

batch

Definition: Like at, but runs when system load is low.

Relevant paths: Same queue and permissions as at (/var/spool/at/, at.allow/at.deny).

crontab

Definition: Table of recurring user jobs (crontab -e, crontab -l).

Relevant paths:

crond

Definition: Daemon that runs user crontabs and system cron jobs.

Relevant paths:

/etc/cron.d/

Definition: System-level cron files; each line includes user and command.

What it is for: Recurring tasks from packages or the admin without editing a user’s personal crontab.

Other useful terms

RHEL

Red Hat Enterprise Linux. Base OS for official labs and the RHCSA exam.

ROL / LMS

Red Hat course portal (RH124, RH134) and cloud lab machines.

Lab

RHEL environment provided by the course—not a self-hosted home VM.

How I use this glossary

• I check paths + definition before a chapter or EX200 practice.
• When a new path repeats in labs, I add it with a one-line “what it is for”.
• If RHEL moves something, I note it in the table.