RHCSA Syllabus Breakdown and a Realistic Study Plan

The RHCSA is a practical Linux administration certification focused on completing real system tasks. Preparing for it requires repeated command-line practice, not only reading notes or memorising command options.

This guide breaks the RHCSA syllabus into manageable skill areas and provides an eight-week plan built around hands-on labs. Red Hat can revise exam objectives when the supported Red Hat Enterprise Linux track changes, so always compare your plan with the current official EX200 objectives before booking the exam.

What does the RHCSA syllabus cover?

The RHCSA syllabus covers essential command-line tools, shell scripting, running systems, storage, file systems, software, networking, users, security and basic container administration. The exact wording and included technologies can change between Red Hat Enterprise Linux exam versions, but the core requirement remains the same: configure and troubleshoot a Linux system without step-by-step guidance.

A useful diagram in words is:

Linux fundamentals
    -> users, permissions and processes
    -> storage, file systems and networking
    -> services, security and automation
    -> integrated administration labs

Each layer depends on the one before it. For example, configuring a web service may require package installation, service management, firewall access, correct file ownership and SELinux labels.

RHCSA syllabus breakdown by skill area

The following table converts the main objectives into practical tasks. It is a study map rather than a replacement for Red Hat's current official exam objectives.

Essential tools and shell usage

You should be comfortable combining commands rather than running each command independently. Practise locating data, filtering output, creating archives and editing configuration files from a terminal.

For example, find regular files larger than 10 MiB under /var/log:

find /var/log -type f -size +10M -exec ls -lh {} \;

Create a compressed archive while preserving extended attributes and SELinux information:

tar --xattrs --selinux -czf /root/etc-backup.tar.gz /etc

Redirection is also important:

grep -i error /var/log/messages > /tmp/errors.txt 2>/tmp/grep-errors.txt

The first redirection writes normal output to errors.txt. The 2> operator sends command errors to a separate file.

Shell scripting

RHCSA scripting tasks are generally small administrative scripts. Focus on readable Bash that accepts input, checks conditions and returns a useful result.

#!/bin/bash

service_name="$1"

if [[ -z "$service_name" ]]; then
    echo "Usage: $0 SERVICE"
    exit 2
fi

if systemctl is-active --quiet "$service_name"; then
    echo "$service_name is running"
else
    echo "$service_name is not running"
    exit 1
fi

Test it with:

chmod +x check-service.sh
./check-service.sh sshd

Do not study scripting separately from administration. Write small scripts that check disk usage, inspect services or report failed login attempts.

Running systems and services

You must be able to control services, investigate boot problems and find useful log entries. Learn both the command and where the corresponding configuration is stored.

systemctl enable --now chronyd
systemctl status chronyd
systemctl get-default
journalctl -b -p err

enable --now starts the service immediately and enables it for later boots. journalctl -b -p err displays error-priority messages from the current boot.

Also practise changing targets and recovering access in a disposable virtual machine. Recovery procedures can vary by RHEL version, so use instructions that match your exam track.

Local storage and file systems

Storage is a major hands-on topic because one task can involve several connected steps. You should understand the difference between a disk, partition, LVM physical volume, volume group, logical volume, file system and mount point.

Diagram in words:

Disk or partition -> LVM physical volume -> volume group
                  -> logical volume -> file system -> mount point

The following example uses an empty lab disk. It destroys existing data on /dev/vdb, so never run it against an unknown device.

lsblk
pvcreate /dev/vdb
vgcreate labvg /dev/vdb
lvcreate -L 1G -n appdata labvg
mkfs.xfs /dev/labvg/appdata
mkdir -p /srv/appdata
blkid /dev/labvg/appdata

Add the displayed UUID to /etc/fstab:

UUID=YOUR-UUID /srv/appdata xfs defaults 0 0

Then validate before rebooting:

mount -a
findmnt /srv/appdata

Never assume an /etc/fstab entry is correct. A typing error can cause boot or mount failures, so mount -a is an essential verification step.

Networking and firewall configuration

You should be able to inspect interfaces, create persistent NetworkManager connections and confirm listening services. Use nmcli for persistent configuration and ip for inspection and temporary testing.

nmcli device status
nmcli connection show
ip address show
ip route show
ss -lntup

A static lab connection can be created as follows. Replace the interface name and addresses with values from your own isolated lab network.

nmcli connection add type ethernet ifname enp1s0 con-name static-lab \
  ipv4.method manual ipv4.addresses 192.0.2.20/24 \
  ipv4.gateway 192.0.2.1 ipv4.dns 192.0.2.53 \
  connection.autoconnect yes
nmcli connection up static-lab

To allow an HTTP service permanently:

firewall-cmd --permanent --add-service=http
firewall-cmd --reload
firewall-cmd --list-services

Check configuration in layers: interface state, IP address, route, DNS, listening socket and firewall. This prevents random changes that make troubleshooting harder.

Users, permissions and SELinux

Account management includes local users, groups, password policies, shared directories, ACLs and controlled administrative access. Practise creating the required result and verifying it from the affected user's perspective.

groupadd developers
useradd -G developers anita
passwd anita
mkdir -p /srv/project
chown root:developers /srv/project
chmod 2770 /srv/project

The leading 2 sets the setgid bit, so new files inherit the directory's group. For more precise access, use ACLs:

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

SELinux should normally remain enforcing. If a web service cannot access a non-standard directory, inspect labels and logs instead of disabling SELinux.

ls -Zd /srv/web
semanage fcontext -a -t httpd_sys_content_t '/srv/web(/.*)?'
restorecon -Rv /srv/web

If semanage is unavailable, identify and install the package providing it with dnf provides '*/semanage'. These security skills also support later learning in a Cybersecurity and SOC course.

Software and container administration

Package tasks may include installing, removing, updating and identifying software. Know how to work with configured repositories and query installed packages.

dnf repolist
dnf search httpd
dnf install -y httpd
rpm -q httpd
dnf history

If containers are listed in your current exam objectives, practise pulling an approved image, running a container, mapping ports and mounting persistent storage with Podman. Container requirements differ between exam tracks, so follow the documentation matching the RHEL version used for your exam.

What is a realistic RHCSA study plan?

A realistic plan is eight weeks for a learner who already understands basic Linux navigation, with five study sessions each week. Use shorter daily practice rather than one long weekly session, and spend at least half of every session working directly in virtual machines.

A practical session can use this 90-minute structure:

1. Spend 15 minutes recalling commands without notes.
2. Spend 50 minutes completing one scenario.
3. Spend 15 minutes troubleshooting an intentionally broken configuration.
4. Spend 10 minutes recording mistakes and shorter verification commands.

Use snapshots only to reset a lab, not as a substitute for recovery skills. Build at least two RHEL-compatible virtual machines so that you can test networking, remote access and service connectivity.

Linux administration is also foundational for automation pipelines and cloud operations. After developing these skills, the AWS DevOps course provides a path into Git, infrastructure automation, CI/CD and cloud operations. Learners focusing on Microsoft cloud administration can apply the same Linux troubleshooting approach in the Microsoft Azure AZ-104 course.

How should you troubleshoot RHCSA lab failures?

Troubleshoot from evidence and verify every layer before editing configuration. Start with status and logs, identify the failed dependency, make one controlled change and test the result again.

Use this sequence:

Read the task -> inspect current state -> make one change
-> validate syntax -> restart or reload -> test externally -> check persistence

For service failures, begin with:

systemctl status httpd --no-pager
journalctl -u httpd --since "10 minutes ago"
httpd -t

httpd -t checks Apache configuration syntax. Do not repeatedly restart a service before reading the error because the log often identifies the exact file and line involved.

How do you know when you are ready for the RHCSA exam?

You are ready when you can complete integrated tasks from memory, verify persistence after reboot and recover from mistakes within a fixed time. Command recognition is not enough; you need to produce a working final system.

Use this readiness checklist:

• You can use manual pages and command help efficiently.
• You can configure LVM and persistent mounts without a copied procedure.
• You can manage users, groups, ACLs and sudo access safely.
• You can diagnose services with systemd and journal logs.
• You can configure persistent networking and firewall access.
• You investigate SELinux labels instead of disabling enforcement.
• You verify every task after reboot where persistence matters.
• You can complete a multi-topic lab without internet access.

During practice, score the final state rather than the commands attempted. A correct command followed by an incorrect configuration still produces a failed system.

Summary

The RHCSA syllabus is broad but manageable when studied as connected administration tasks. Build a strong base in files and permissions, then progress through services, storage, networking, security, scripting and any container objectives included in your exam version.

The most effective preparation cycle is simple: configure, verify, break, troubleshoot and repeat. Keep a mistake log and revisit weak labs until you can complete them without a step-by-step guide.

To extend your Linux skills into cloud automation and delivery pipelines, review the AWS DevOps course and contact Network Rhinos for current batch and enquiry details.

Reviewed by Network Rhinos Linux trainers.

Related reading: Linux File Permissions and Ownership Explained