# RHCSA Study Notes

## Exam Information
- Exam Code: EX200
- Duration: 2.5 hours
- Passing Score: 210/300 (70%)

[CLI Commands](rhcsa.md#cli-commands)

## Core Topics

### 1. Essential Tools
- [x] Access a shell prompt and issue commands
- [x] Use input-output redirection
- [x] Use grep and regular expressions
- [x] Access remote systems using SSH
- [x] Log in and switch users in multiuser targets

### 2. File Management
- [x] Create, delete, copy, and move files and directories
- [x] Create and manage hard and soft links
- [x] Find files and directories
- [x] Manage file permissions and ownership

### 3. Service Configuration
- [x] Configure networking and hostname resolution
- [x] Start, stop, and check system service status
- [x] Configure services to start automatically at boot
- [x] Configure time service clients

### 4. Storage Management
- [x] List, create, delete, and modify physical storage partitions
- [x] Create and configure filesystem
- [x] Configure and manage swap space
- [x] Create and manage LVM storage
- [x] Create and manage STRATIS storage

### 5. Container Management
- [x] Find and retrieve container images
- [x] Create and manage containers
- [x] Configure container storage

### 6. System Management
- [x] Boot, reboot, and shut down a system
- [x] Install Red Hat Enterprise Linux
- [x] Use systemd targets for system management
- [x] Configure system logging
- [x] Schedule tasks using cron and systemd timers

### 7. Security
- [x] Configure firewall settings
- [x] Configure SELinux
- [x] Manage users and groups
- [x] Set file permissions and ownership

## Resources
- Official Red Hat Documentation
- Practice Environments
- Useful Commands Reference

## Progress Tracking
- [ ] Complete practice exams
- [x] Lab environment setup
- [ ] Hands-on practice completed

---
*Note: Check boxes can be used to track progress on each topic as you study*

---
---

# CLI Commands

## Networking

### nmtui
```bash
nmtui # Network Manager Text User Interface
```

### ip
```bash
sudo ip addr add dev eth0 192.168.2.2/24 # Add an IP address to the interface eth0 Note: Not persistent, will be lost on reboot
```

### nmcli
```bash
nmcli connection add connection.interface-name ens160 ipv4.addresses 192.168.100.1/24 ipv4.gateway 192.168.100.254 type ethernet # Persistant IP address

sudo nmcli connection up ethernet-ens160 # Bring up the ethernet interface

sudo nmcli connection down ethernet-ens160 # Bring down the ethernet interface

sudo nmcli connection delete id "ens160" # Delete the ethernet connection

sudo nmcli connection show # Show all connections
```

## Manage and Monitor Processes

### top
```bash
top # Display running processes

top -o %MEM # Sort by memory usage

top -o %CPU # Sort by CPU usage

top -p 1234 # Display information for process 1234
```
### pidof
```bash
pidof sleep # Display the PID of the sleep command
```

### kill
```bash
kill -l # List all signals

kill -9 1234 # Kill the process with PID 1234
```

### nice
```bash
nice -n 10 sleep 100 # Run the sleep command with a priority of 10
```

## Partitions and Mounting

### lsblk
```bash
lsblk -f # List all block devices with filesystem type
```

### fdisk
```bash
sudo fdisk /dev/sda # Partition the disk /dev/sda 
# Note: n for new partition, p for primary, 1 for first partition, w for write
```

### mkfs
```bash
sudo mkfs.xfs /dev/sda1 # Format the partition /dev/sda1 as XFS
```

### mount
```bash
sudo mount /dev/sda1 /mnt # Mount the partition /dev/sda1 to /mnt

sudo mount -a # Mount all partitions
```

### LVM
```bash
sudo fdisk /dev/sda # Partition the disk /dev/sda
# Note: p for print, n for new partition, t for type, 8e for LVM, w for write

### Physical Volumes ###
sudo pvdisplay # Display all physical volumes
sudo pvs # Display all physical volumes

sudo pvcreate /dev/sda1p1 # Create a physical volume on /dev/sda1p1
sudo pvcreate /dev/sdb1p1 # Create a physical volume on /dev/sdb1p1
sudo pvcreate /dev/sdc1p1 # Create a physical volume on /dev/sdc1p1

### Volume Groups ###
sudo vgcreate vg_data /dev/sda1p1 /dev/sdb1p1 /dev/sdc1p1 # Create a volume group vg_data on /dev/sda1p1, /dev/sdb1p1, /dev/sdc1p1

sudo vgdisplay # Display all volume groups
sudo vgs # Display all volume groups

### Logical Volumes ###
sudo lvdisplay # Display all logical volumes
sudo lvs # Display all logical volumes

sudo lvcreate -n lv_data -l 100%FREE vg_data # Create a logical volume lv_data on vg_data
sudo lvcreate -n lv_data -L 100M vg_data # Create a logical volume lv_data on vg_data with a size of 100M

### Formatting and Mounting ###
sudo mkfs.xfs /dev/vg_data/lv_data # Format the logical volume lv_data as XFS
sudo mount /dev/vg_data/lv_data /mnt # Mount the logical volume lv_data to /mnt
sudo umount /mnt # Unmount the logical volume lv_data from /mnt

### Extending and Reducing ###
sudo lvextend -L +100M /dev/vg_data/lv_data # Extend the logical volume lv_data by 100M
sudo lvreduce -L -100M /dev/vg_data/lv_data # Reduce the logical volume lv_data by 100M

sudo lvremove /dev/vg_data/lv_data # Remove the logical volume lv_data
sudo vgremove vg_data # Remove the volume group vg_data
sudo pvremove /dev/sda1p1 /dev/sdb1p1 /dev/sdc1p1 # Remove the physical volumes /dev/sda1p1, /dev/sdb1p1, /dev/sdc1p1

### Interactive LVM Tool ###
sudo lvm # Interactive LVM tool
```

### STRATIS
```bash
sudo dnf install stratisd stratis-cli # Install the STRATIS storage service and CLI

sudo stratis pool create pool1 /dev/sda1p1 # Create a pool named pool1 on /dev/sda1p1
sudo stratis pool add-data pool1 /dev/sdb1p1 # Add a data volume to the pool named pool1 on /dev/sdb1p1

sudo stratis pool delete pool1 # Delete the pool named pool1

sudo stratis pool list # List all pools
sudo stratis blockdev list # List all block devices

sudo stratis fs create pool1 fstest # Create a filesystem named fstest on the pool named pool1
sudo stratis fs list # List all filesystems # Note: UUID is the UUID of the filesystem
mkdir /mnt/fsmount # Create a mount point for the filesystem
sudo nano /etc/fstab # Add the following line to the fstab file: UUID=1234567890 /mnt/fsmount xfs x-systemd.requires=stratisd.service 0 0
sudo mount -a # Mount all filesystems
```

## Automatic Services & Task Scheduling

### cron
```bash
sudo crontab -e # Edit the cron table

sudo crontab -l # List the cron table

### crontab format ###

* * * * * command # Run the command every minute

0 12 * * * command # Run the command at 12:00 PM

0 0 * * * command # Run the command at 12:00 AM
```

### at
```bash
at 12:00 PM # Schedule a command to run at 12:00 PM

at -l # List all scheduled jobs

atq # List all scheduled jobs

atrm 1 # Remove the scheduled job with ID 1
```

### systemd

```bash
sudo systemctl start sshd # Start the sshd service
sudo systemctl stop sshd # Stop the sshd service
sudo systemctl restart sshd # Restart the sshd service

sudo systemctl enable sshd # Enable the sshd service to start on boot
sudo systemctl disable sshd # Disable the sshd service from starting on boot
sudo systemctl status sshd # Check the status of the sshd service

sudo systemctl daemon-reload # Reload the systemd daemon

sudo systemctl mask sshd # Mask the sshd service
sudo systemctl unmask sshd # Unmask the sshd service
```

### systemd service and timer commands

```bash
### Creating a service ###
sudo nano /etc/systemd/system/myapp.service
# [Unit]
# Description=My App

# [Service]
# Type=simple
# ExecStart=/usr/bin/myapp
# User=myuser

### Creating a timer ###
sudo nano /etc/systemd/system/myapp.timer
# [Unit]
# Description=My App Timer

# [Timer]
# OnBootSec=10min # Run the timer 10 minutes after the system starts
# OnCalendar=*-*-* 10:00:00 # Run at 10:00 AM every day
# OnCalendar=*-*-* *:*:0 # Run at every minute

# [Install]
# WantedBy=graphical.target # Run the timer on the graphical target

### Tying the timer to the service ###
sudo systemctl link /etc/systemd/system/myapp.timer 

### Starting a service ###
sudo systemctl start myapp
sudo systemctl start myapp.timer
```

## Bash Scripting

### Basic Script
```bash
nano myscript.sh
```

> Note: Shebang is the first line of the script that tells the system which interpreter to use.
```bash
#!/bin/bash
echo "Hello, World!"

### Variables ###
myvar="Hello, World!"
echo $myvar

### Conditionals ###
if [ -f /etc/passwd ]; then
    echo "File exists"
else
    echo "File does not exist"
fi
```

### Script to create a directory
> NOTE: When creating bash scripts you can use particular operators to check for the existence of a file (-f) or directory (-d). The 
> following example uses the -d operator to check for the existence of a directory. Using conditional logic, if the script detects 
> that the directory does not exist, the script will go ahead and create it.

```bash
#!/bin/bash

# Ask the user to enter a directory name
echo "Enter a directory name: "

# Read the user's input 
read user_dir

# Check if the user_dir exists
if [ -d "$user_dir" ]; then
  echo "The directory '$user_dir' already exists."
else
  # Create the user_dir directory if it doesn't exist
  mkdir "$user_dir"
  echo "The directory '$user_dir' has been created."
fi
```

> In a similar vein, you can check for the existence of a regular file using the -f operator.

```bash
#!/bin/bash

# Ask the user to enter a filename
echo "Enter a filename: "

# Read the user's input
read user_file

# Check if the file exists
if [ -f "$user_file" ]; then
  echo "The file '$user_file' exists."
else
  echo "The file '$user_file' does not exist."
fi
```

### for loop
```bash
#!/bin/bash

for i in 1..10; do
    echo $i
done
```

### while loop
```bash
#!/bin/bash

i=1
while [ $i -le 10 ]; do
    echo $i
    i=$((i+1))
done
```

### until loop
```bash
#!/bin/bash

i=1
until [ $i -gt 10 ]; do
    echo $i
    i=$((i+1))
done
```

### Example script to check a user's age
```bash
#!/bin/bash
echo "Please provide me your age: "

read age

if [ "$age" -le 17 ]; then
	echo "You cannot enter bars or vote."
elif [ "$age" -ge 18 ] && [ "$age" -le 20 ]; then
	echo "You can vote but not enter bars."
else
	echo "You are old enough to vote and enter bars."
fi
```

## Boot Process & Targets

### Change the grub2 configuration
```bash
sudo grub2-mkconfig -o /boot/grub2/grub.cfg # Create a new grub configuration file

sudo nano /etc/default/grub # Edit the grub configuration file

# Add the following line to the grub configuration file:
GRUB_CMDLINE_LINUX="quiet splash"
```

### dmesg

> Note: The boot process is the process by which a system starts up. It is a sequence of events that occur when a system is powered on or rebooted.

```bash
sudo dmesg # Display the kernel messages
sudo dmesg | tail # Display the last 10 lines of the kernel messages
sudo dmesg | grep "kernel" # Display the kernel messages that contain the word "kernel"

### /var/log/messages ###
sudo less /var/log/messages # Display the kernel messages
```

### systemd targets

> Note: Systemd targets are a way to manage the boot process of a system. They are a way to manage the boot process of a system.
>> multi.target is the default target for the system.
>> graphical.target is the target for the graphical interface.
>> basic.target is the target for the minimal system.
>> rescue.target is the target for the rescue mode.
>> emergency.target is the target for the emergency mode.
>> multi-user.target is the target for the multi-user mode.
>> reboot.target is the target for the reboot mode.
>> poweroff.target is the target for the poweroff mode.

```bash
systemctl list-units --type=target

### Changing the default target ###
sudo systemctl set-default multi-user.target # Set the default target to multi-user.target
sudo systemctl set-default graphical.target # Set the default target to graphical.target
sudo systemctl set-default basic.target # Set the default target to basic.target
```

### Run Level

> Note: Run level is a way to manage the boot process of a system. It is a way to manage the boot process of a system.
> 0 is the emergency mode. 
> 1 is the single user mode.
> 2 is the multi-user mode. 
> 3 is the multi-user mode. 
> 4 is the multi-user mode. (unused)
> 5 is the graphical mode.
> 6 is the reboot mode.

```bash
runlevel # Display the current run level
sudo systemctl get-default # Display the default target
sudo systemctl set-default runlevel3.target # Set the default target to runlevel3.target
sudo telinit 3 # Change to runlevel 3
```

## Manage SSH Connections

### ssh
```bash
ssh user@host # Connect to the host as the user

ssh -p 2222 user@host # Connect to the host as the user on port 2222

ssh -i /path/to/private_key user@host # Connect to the host as the user using a private key

ssh-copy-id user@host # Copy the user's public key to the host

ssh-keygen -t ed25519 -C "comment" -f ~/.ssh/id_ed25519 -N "" # Generate a new ed25519 key

ssh-keygen -t rsa -b 4096 -C "comment" -f ~/.ssh/id_rsa -N "" # Generate a new rsa key
```

### sshd_config
```bash
sudo nano /etc/ssh/sshd_config # Edit the sshd configuration file

# Add the following line to the sshd configuration file:
Port 2222

sudo systemctl restart sshd # Restart the sshd service
```

## NFS & NTP

### NFS
```bash
sudo dnf install nfs-utils # Install the NFS utilities

### Port Number ###
> Note: The port number for NFS is 2049.

### Firewall ###
sudo firewall-cmd --add-service=nfs --permanent # Add the NFS service to the firewall
sudo firewall-cmd --reload # Reload the firewall
sudo firewall-cmd --list-services # List the services in the firewall

sudo nano /etc/exports # Edit the exports file

# Add the following line to the exports file:
/mnt/nfs 192.168.1.0/24(rw,sync,no_subtree_check) # The directory to export

sudo exportfs -r # Export the NFS shares
sudo exportfs # Display the NFS shares

sudo systemctl start nfs-server # Start the NFS server

### root-squash and no_root_squash
> Note: root-squash is a feature of NFS that allows the root user to access the NFS share as a regular user. no_root_squash 
> is a feature of NFS that allows the root user to access the NFS share as the root user.

> Note: async is a feature of NFS that allows the NFS server to write to the NFS share asynchronously. 
> sync is a feature of NFS that allows the NFS server to write to the NFS share synchronously.

```bash
sudo nano /etc/exports # Edit the exports file

# Add the following line to the exports file:
/mnt/nfs 192.168.1.0/24(rw,sync,no_subtree_check,root_squash) # The directory to export

# Add the following line to the exports file:
/mnt/nfs 192.168.1.0/24(rw,async,no_subtree_check,no_root_squash) # The directory to export
```

### Configure an NFS Client
```bash
sudo dnf install nfs-utils # Install the NFS utilities

sudo nano /etc/fstab # Edit the fstab file

# Add the following line to the fstab file:
192.168.1.1:/mnt/nfs /mnt/nfs nfs defaults 0 0

sudo mount -a # Mount the NFS shares

sudo mount 192.168.1.1:/mnt/nfs /mnt/nfs # Mount the NFS share
sudo umount /mnt/nfs # Unmount the NFS share
```

### NTP
```bash
sudo dnf install ntp # Install the NTP utilities

sudo ntpdate time.nist.gov # Update the time
sudo ntpq -p # Display the NTP peers
sudo ntpstat # Display the NTP status

### Timezone and Time Commands ###
sudo timedatectl set-timezone America/Chicago # Set the timezone to America/Chicago
sudo timedatectl set-time "12:00:00" # Set the time to 12:00:00
sudo timedatectl set-ntp true # Enable the NTP service
sudo timedatectl set-ntp false # Disable the NTP service

### chrony
```bash
sudo dnf install chrony # Install the chrony utilities

sudo chronyc sources # Display the chrony sources
sudo chronyc tracking # Display the chrony tracking
sudo chronyc sources -v # Display the chrony sources with more detail

sudo nano /etc/chrony.conf # Edit the chrony configuration file

# Add the following line to the chrony configuration file:
server time.nist.gov iburst # Add the NIST time server
pool 2.rhel.pool.ntp.org iburst # Add the RHEL time server

sudo systemctl start chronyd # Start the chrony service
sudo systemctl enable chronyd # Enable the chrony service to start on boot
```

## Secure Linux Systems

### lsattr
```bash
lsattr # List the attributes of the files and directories

lsattr /etc/passwd # List the attributes of the /etc/passwd file
```

### chattr
```bash
chattr +i /etc/passwd # Set the immutable attribute on the /etc/passwd file
chattr -R +i /etc/ # Set the immutable attribute on the /etc/ directory and all its contents
chattr +a /etc/passwd # Set the append only attribute on the /etc/passwd file

chattr -i /etc/passwd # Remove the immutable attribute on the /etc/passwd file
chattr -R -i /etc/ # Remove the immutable attribute on the /etc/ directory and all its contents
```

### getfacl
```bash
getfacl /etc/passwd # Display the ACLs of the /etc/passwd file
```

### setfacl
```bash
setfacl -m u:user:rwx /etc/passwd # Set the ACLs of the /etc/passwd file for the user user with read, write, and execute permissions
setfacl -m g:group1:r file.txt # Set the ACLs of the file.txt file for the group group1 read only
```

### SELinux Basics
```bash
sudo sestatus # Display the SELinux status

sudo getenforce # Display the SELinux mode

sudo setenforce 0 # Set the SELinux mode to permissive
sudo setenforce 1 # Set the SELinux mode to enforcing

ls -Z # List the SELinux context of the files and directories
ps -eZ # List the SELinux context of the processes

### SELinux Port Management
# Note: SELinux will block any attempt to use a port that is not in the SELinux policy in enforcing mode.
sudo semanage port -a -t http_port_t -p tcp 8080 # Add the HTTP port to the SELinux policy
sudo semanage port -d -t http_port_t -p tcp 8080 # Remove the HTTP port from the SELinux policy

### SELinux Login Management
sudo semanage login -a -s user_t user1 # Add the user user1 to the SELinux policy
sudo semanage login -d user1 # Remove the user user1 from the SELinux policy

### getsebool
```bash
getsebool -a # List all SELinux booleans

getsebool httpd_can_network_connect # Display the SELinux boolean for the httpd_can_network_connect boolean

### setsebool
```bash
setsebool -P httpd_can_network_connect on # Set the httpd_can_network_connect boolean to on
setsebool -P httpd_can_network_connect off # Set the httpd_can_network_connect boolean to off

sudo semanage boolean -l -C # List all SELinux booleans

### sealert
```bash
sudo sealert -a /var/log/audit/audit.log # Display the SELinux alerts

journalctl | grep -i sealert # Display the SELinux alerts
```

## Manage Packages on RHEL

### rpm
```bash
rpm -q httpd # Display the installed packages
rpm -qa # Display all installed packages

rpm -qf /bin/bash # Display the package that installed the /bin/bash command
rpm -ql httpd # Display the files installed by the httpd package
rpm -ql coreutils | grep bin # Display the files installed by the coreutils package

sudo rpm -i httpd-2.4.37-1.el8.x86_64.rpm # Install the httpd package

sudo rpm -e httpd # Remove the httpd package
```

### rpm2cpio
```bash
rpm2cpio httpd-2.4.37-1.el8.x86_64.rpm | cpio -tv # Display the contents of the httpd package

rpm2cpio httpd-2.4.37-1.el8.x86_64.rpm | cpio -idmv # Extract the contents of the httpd package
```

### dnf
```bash
sudo dnf install httpd # Install the httpd package

sudo dnf remove httpd # Remove the httpd package

sudo dnf list # List all packages

sudo dnf search httpd # Search for the httpd package
sudo dnf info httpd # Display information about the httpd package

sudo dnf provides /bin/bash # Display the package that provides the /bin/bash command
sudo dnf deplist httpd # Display the dependencies of the httpd package
```

### modify the .repo file to skip the GPG check
```bash
sudo nano /etc/yum.repos.d/rhel.repo

# Add the following line to the rhel.repo file:
gpgcheck=0
```

### dnf groups
```bash
sudo dnf group list # List all groups
sudo dnf group list --hidden # List all hidden groups

sudo dnf group install "Development Tools" # Install the Development Tools group
sudo dnf group install --with-optional "Development Tools" # Install the Development Tools group with optional packages
sudo dnf group info "Development Tools" # Display information about the Development Tools group
sudo dnf group remove "Development Tools" # Remove the Development Tools group

sudo dnf history # Display the history of the packages
sudo dnf history undo 1 # Undo the last package installation
sudo less /var/log/dnf.rpm.log # Display the dnf log
```

### dd 
> Note: dd is used to copy and convert files and is used to create disk images.
```bash
sudo dd if=/dev/sr0 of=/optical-rhel.iso bs=1M # Create an ISO image of the optical drive

sudo dd if=/dev/sr0 of=/optical-rhel.iso bs=1M status=progress # Create an ISO image of the optical drive with progress

### mounting an iso image using /etc/fstab
```bash
sudo nano /etc/fstab

# Add the following line to the fstab file:
/path/to/iso /mnt/iso iso9660 defaults 0 0

sudo mount -a # Mount the ISO image
sudo umount /mnt/iso # Unmount the ISO image

### dnf config-manager
sudo dnf config-manager --add-repo="file:///path/to/repo/AppStream" # Add a repository
sudo dnf config-manager --add-repo="file:///path/to/repo/BaseOS" # Add a repository

sudo dnf repolist # List all repositories
```

## Understand and Configure Firewalls

### firewall-cmd
> Note: firewall-cmd is used to manage the firewall rules.
```bash
### displaying the firewall zones
sudo firewall-cmd --get-active-zones # Display the active zones
sudo firewall-cmd --get-default-zone # Display the default zone
sudo firewall-cmd --get-zones # Display the zones

### setting the default zone
sudo firewall-cmd --set-default-zone=public # Set the default zone to public

### displaying the rules in the firewall
sudo firewall-cmd --list-all # Display all the rules in the firewall
sudo firewall-cmd --list-services --zone=public # Display the services in the public zone
sudo firewall-cmd --list-ports --zone=public # Display the ports in the public zone
sudo firewall-cmd --list-protocols --zone=public # Display the protocols in the public zone

### adding rules to the firewall
sudo firewall-cmd --zone=public --add-service=http --permanent # Add the http service to the public zone
sudo firewall-cmd --zone=public --add-port=80/tcp --permanent # Add the port 80/tcp to the public zone
sudo firewall-cmd --zone=public --add-protocol=tcp --permanent # Add the tcp protocol to the public zone

### removing rules from the firewall
sudo firewall-cmd --zone=public --remove-service=http --permanent # Remove the http service from the public zone
sudo firewall-cmd --zone=public --remove-port=80/tcp --permanent # Remove the port 80/tcp from the public zone
sudo firewall-cmd --zone=public --remove-protocol=tcp --permanent # Remove the tcp protocol from the public zone

### reloading the firewall
sudo firewall-cmd --reload # Reload the firewall
```

### port reference
```bash
sudo less /etc/services # Display the services
```

## Manage DNS and Logging

### resolv.conf
```bash
sudo nano /etc/resolv.conf # Edit the resolv.conf file

sudo systemctl restart NetworkManager # Restart the NetworkManager service
```

### nsswitch.conf
```bash
sudo nano /etc/nsswitch.conf # Edit the nsswitch.conf file

sudo systemctl restart NetworkManager # Restart the NetworkManager service
```

### query dns
```bash
dig www.google.com # Query the DNS server for www.google.com

dig -x 192.168.1.1 # Query the DNS server for the reverse lookup(PTR) of 192.168.1.1

nslookup www.google.com # Query the DNS server for www.google.com

nslookup -type=mx gmail.com # Query the DNS server for the MX records for gmail.com
```

### logging
```bash
sudo journalctl # Display the journal
sudo journalctl -xe # Display the journal and show the boot messages
sudo journalctl -f # Display the journal and follow the log

sudo journalctl -u httpd # Display the journal for the httpd service

sudo journalctl --since "1 hour ago" # Display the journal for the last hour
sudo journalctl --since "1 hour ago" --until "2 hour ago" # Display the journal for the last hour and until 2 hours ago
```

### rsyslog
```bash
sudo nano /etc/rsyslog.conf # Edit the rsyslog configuration file

sudo systemctl restart rsyslog # Restart the rsyslog service

sudo systemctl status rsyslog # Display the status of the rsyslog service
```

### logrotate
```bash
sudo nano /etc/logrotate.conf # Edit the logrotate configuration file\
```

### logger
```bash
logger "This is a test message" # Log a message

logger -p local0.info "This is a test message" # Log a message to the local0.info facility

sudo tail /var/log/messages # Display the messages
```

## Troubleshoot RHEL Systems

### Troubleshooting Capacity Problems
```bash
### df
sudo df -h # Display the disk space usage
sudo df -i # Display the inode usage
sudo df -T # Display the filesystem type

### dd
sudo dd if=/dev/zero of=/dev/sda1 bs=1M count=100 # Create a 100MB file on the /dev/sda1 partition
sudo dd if=/dev/zero of=/dev/sda1 bs=1M count=100 status=progress # Create a 100MB file on the /dev/sda1 partition with progress

### du
sudo du -hs /home/user1 # Display the disk space usage of the /home/user1 directory
sudo du -h file.txt # Display the disk space usage of the file.txt file
```

### Troubleshooting CPU Issues
```bash
### uptime
sudo uptime # Display the uptime of the system

### lscpu
sudo lscpu # Display the CPU information

### stress test cpu with stress-ng
sudo stress-ng --cpu 2 --timeout 10s # Stress test the CPU for 10 seconds

### vmstat
sudo vmstat 1 5 # Display the VM statistics every 1 second for 5 seconds

### top
sudo top # Display the top processes
```

### Troubleshooting Memory Issues
```bash
### free
sudo free -h # Display the memory usage

### vmstat
sudo vmstat 1 5 # Display the VM statistics every 1 second for 5 seconds

### top
sudo top # Display the top processes then press m to sort by memory
```

### Troubleshooting Network Issues
```bash
### nmtui
sudo nmtui # Network Manager Text User Interface

### nmcli
sudo nmcli connection show # Display the network connections

### ip route
ip route show # Display the routes

### ip addr
ip -c addr # Display the network interfaces
```

### Troubleshooting DNS Issues
```bash
### check dns resolution with dig
dig google.com # Query the DNS server for google.com

### check dns resolution with resolv.conf
sudo vim /etc/resolv.conf # Edit the resolv.conf file
### change the nameserver to 8.8.8.8
nameserver 8.8.8.8
```

### Recovering the Root Password
```bash
### reboot the system
sudo reboot

### press esc to get to the grub menu
### press e to edit the grub menu

### go to the line that starts with linux16
### scroll down to the end of the line

### delete rhgb quiet

### add the init=/bin/bash to the end of the line
... init=/bin/bash

### press ctrl+x to boot into single user mode
### mount the root filesystem
mount -o remount,rw /

### change the root password
passwd root

### inform selinux to allow the root password change
touch /.autorelabel
exec /usr/lib/systemd/systemd

### the system may take a while to boot
```

## Manage Containers on RHEL

### podman
```bash
sudo dnf install podman # Install podman

podman pull nginx:latest # Pull the latest nginx image
podman images # Display the images

podman run --name mynginx -d -p 8080:80 nginx:latest # Run the nginx container

podman ps # Display the running containers
podman logs mynginx # Display the logs of the mynginx container
podman exec -it mynginx bash # Execute a command in the mynginx container

podman start mynginx # Start the mynginx container
podman stop mynginx # Stop the mynginx container
podman rm mynginx # Remove the mynginx container

podman rmi nginx:latest # Remove the nginx image
```

### Building Custom Images with Podman
```bash
FROM fedora:latest

RUN dnf install -y vim

COPY welcome.txt /root/welcome.txt

CMD ["/bin/bash"]
```

> Note: You can build the image with podman build -t myimage .

### Running Containers with Podman
```bash
### build the image
podman build -t myimage -f Containerfile .

### run the container
podman run -it --name mycustomcontainer myimage
```

### Persistent Storage
```bash
### create a volume
podman volume create myvolume

### list the volumes
podman volume ls

### run the container with the volume
podman run --name mywebserver -d -p 8080:80 -v myvolume:/var/www/html:Z nginx
```

### Scheduling Containerised Services with Systemd
> Note: You can use systemd to schedule containerised services.
>> configure the service to run under a user's account even when the user is not logged into the system
```bash
### enable linger for the user
sudo loginctl enable-linger user1

### create a systemd service
mkdir -p /home/user1/.config/systemd/user
podman pull nginx

### run the container
podman run -d --name mynginx -p 8080:80 nginx

### cd into the user's home directory
cd /home/user1/.config/systemd/user
podman generate systemd --name mynginx --files --new # generate the systemd service file

### ensure the service file is wantedby default.target 
[Install]
WantedBy=default.target

systemctl --user daemon-reload # reload the systemd user daemon
systemctl --user enable container-mynginx.service # enable the mynginx service

systemctl --user status container-mynginx.service # check the status of the mynginx service

### after rebooting the system, the service will start automatically
```