EX200 RedHat Red Hat Certified System Administrator - RHCSARHEL 10 Free Practice Exam Questions (2026 Updated)

Solution:

dnf install -y nfs-utils

mkdir -p /srv/nfs/projects

echo "/srv/nfs/projects 192.168.50.0/24(rw,sync)" > > /etc/exports

exportfs -rav

systemctl enable --now nfs-server

firewall-cmd --permanent --add-service=nfs

firewall-cmd --reload

exportfs -s

Detailed Explanation:

nfs-utils provides the NFS server tools.

/etc/exports defines the exported directory and allowed client network.

exportfs -rav reloads exports.

nfs-server must be enabled and started.

If a firewall is enabled, the NFS service must be allowed.

RHEL 10 network file services documentation covers NFS server configuration. ( Red Hat Documentation )

Solution:

Set the hostname:

hostnamectl set-hostname server1.example.com

Configure the existing connection with a static IP:

nmcli connection modify ens160 ipv4.address 192.168.1.2/24 ipv4.gateway 192.168.1.1 ipv4.dns 1.1.1.1 ipv4.method manual connection.autoconnect yes

Bring the connection up:

nmcli connection up ens160

Detailed Explanation:

hostnamectl is the correct modern command for changing the system hostname.

nmcli is the correct tool for RHEL 10 network configuration because the old ifcfg style is removed in RHEL 10, and NetworkManager keyfiles are the supported model.

ipv4.method manual tells NetworkManager to use static addressing.

connection.autoconnect yes ensures the profile activates automatically after reboot.

nmcli connection up ens160 applies the changes immediately.

Solution:

Open the firewall port and HTTP service:

firewall-cmd --permanent --add-port=82/tcp

firewall-cmd --permanent --add-service=http

firewall-cmd --reload

Add SELinux port labeling:

semanage port -a -t http_port_t -p tcp 82

Detailed Explanation:

firewall-cmd --permanent makes the change persistent.

--add-port=82/tcp opens the custom TCP port.

--add-service=http keeps standard HTTP allowed too.

SELinux blocks services on unexpected ports unless the port is labeled correctly.

http_port_t tells SELinux that port 82 is valid for web services.

Solution:

useradd harry

passwd harry

chage -M 30 -d 0 harry

chage -l harry

Detailed Explanation:

useradd harry creates the local user.

passwd harry sets the initial password.

chage -M 30 sets the maximum password age to 30 days.

chage -d 0 forces the user to change the password at next login.

chage -l harry verifies the policy.

Solution:

subscription-manager config --rhsm.manage_repos=0

Detailed Explanation:

This disables repository management by Subscription Manager, exactly as shown in the lab dataset.

Use this when a task wants system repositories disabled so custom repos can be managed manually.

Solution:

Create the destination directory if needed:

mkdir -p /root/tomfiles

Find and copy:

find / -type f -user tom -exec cp -pvf {} /root/tomfiles/ \;

Detailed Explanation:

find / searches the whole filesystem.

-type f restricts results to files.

-user tom matches owner tom.

-exec cp -pvf copies each file with verbose and force options.

mkdir -p is added as a safe preparation step.

Solution:

dnf install -y httpd policycoreutils-python-utils

mkdir -p /webdata

echo "RHEL10 Web Server" > /webdata/index.html

sed -i 's/^Listen 80/Listen 8080/' /etc/httpd/conf/httpd.conf

semanage port -a -t http_port_t -p tcp 8080

firewall-cmd --permanent --add-port=8080/tcp

firewall-cmd --reload

systemctl enable --now httpd

systemctl restart httpd

ss -tulpn | grep 8080

Detailed Explanation:

Apache defaults to port 80, so Listen 8080 changes the service port.

SELinux must allow Apache to bind to 8080, which is done with semanage port.

firewall-cmd opens the port externally.

RHEL 10 documents firewalld as the standard firewall management interface and SELinux port labeling for confined services. ( Red Hat Documentation )

Solution:

dnf install -y vdo kmod-kvdo lvm2

pvcreate /dev/sdc

vgcreate vdo-volumegroup /dev/sdc

lvcreate --type vdo -n vdo-logicalvolume -L 5G -V 50G vdo-volumegroup/vdo-pool

mkfs.xfs /dev/vdo-volumegroup/vdo-logicalvolume

Detailed Explanation:

VDO provides compression and deduplication.

-L 5G sets the physical backing size.

-V 50G sets the logical exposed size.

This allows thin, optimized storage presentation.

The exact commands are taken from the RHCSA dataset embedded in the uploaded lab HTML.

Solution:

sed -i '/^pool /d;/^server /d' /etc/chrony.conf

echo "server time.example.com iburst" > > /etc/chrony.conf

systemctl enable --now chronyd

systemctl restart chronyd

chronyc sources -v

chronyc tracking

Detailed Explanation:

chronyd is the RHEL 10 NTP implementation.

iburst speeds up initial synchronization.

chronyc sources -v and chronyc tracking confirm the sync state.

Red Hat’s RHEL 10 time synchronization documentation uses chrony as the supported NTP implementation. ( Red Hat Documentation )

Solution:

podman build -t myimage -f Containerfile .

loginctl enable-linger alex

cd ~/.config/systemd/user/

podman generate systemd --name mycontainer --files --new

systemctl --user daemon-reload

systemctl --user enable --now container-mycontainer.service

Detailed Explanation:

podman build creates the container image.

loginctl enable-linger alex allows user services to keep running without an active login session.

podman generate systemd creates a systemd unit file for the container.

systemctl --user manages the unit in the user session scope.

On newer Podman releases, behavior and defaults have changed in RHEL 10, but the lab’s workflow is still conceptually valid.

Solution:

Partition the disk:

fdisk /dev/sdb

Inside fdisk:

n = new partition

p = primary

1 = partition number

accept defaults

size +700M

t = change type

set Linux LVM type

w = write changes

Create the physical volume:

pvcreate /dev/sdb1

Create the volume group:

vgcreate vg_data /dev/sdb1

Create the logical volume:

lvcreate -L 500M -n lv_data vg_data

Create the filesystem:

mkfs.xfs /dev/vg_data/lv_data

Detailed Explanation:

The lab specifies a 700 MB partition and a 500 MB logical volume.

pvcreate initializes the partition for LVM.

vgcreate builds the storage pool.

lvcreate allocates space from the volume group.

mkfs.xfs creates the filesystem, which is standard on RHEL.