Linux and Red Hat (RHCSA to RHCE)

What Linux and Red Hat Enterprise Linux are, how to build a free practice lab, where things live on disk, and how to move around, handle files, search text, chain commands and edit files with vim. After this module you can find your way around any RHEL server from the command line.

1. What Linux and Red Hat Enterprise Linux areLinux is a free operating system kernel; a distribution adds tools, a package manager and support around it. Red Hat Enterprise Linux (RHEL) is the paid, supported distribution that banks, telecoms and governments run. You can practise on a free RHEL developer subscription, or on Rocky Linux or AlmaLinux, which are built to behave like RHEL.30 min
2. The filesystem hierarchy and pathsLinux has one tree of folders that starts at / (the root). Each top folder has a job: /etc holds settings, /var holds changing data like logs, /home holds users' files. An absolute path starts with /; a relative path starts from the folder you are in.30 min
3. Shell basics and getting helpThe shell is the program that reads what you type and runs it; on RHEL it is bash. A command line has a command, options (starting with - or --) and arguments. When you forget something, man, --help and man -k answer you without the internet.30 min
4. Working with files: ls, cp, mv, rm, links and findls lists files, mkdir and touch create them, cp copies, mv moves or renames, and rm deletes for good. ln makes hard and soft links. find searches the tree by name, size, owner or age, and can run a command on every match.35 min
5. Reading text: grep, less, pipes and redirectioncat, less, head and tail read files; grep keeps only the lines that match a pattern. > sends output into a file (replacing it), >> appends, and 2> captures errors. A pipe | sends one command's output into the next, so small tools join into powerful one-liners.35 min
6. Editing files with vimvim is the text editor found on almost every Linux server. It has modes: Normal mode for moving and commands, Insert mode for typing, and the : command line for saving and quitting. Learn i, Esc, :wq and :q! first, then a few editing keys.30 min

Who can log in and who can touch which file: users and groups, the files that store them, password ageing, read/write/execute permissions with chmod and chown, umask, the special SUID, SGID and sticky bits, ACLs for finer control, and safe admin access with sudo. After this module you can set up accounts and shared folders the way a real team needs them.

1. Users, groups and the files behind themEvery process runs as a user, and every user has a number called a UID. Users are listed in /etc/passwd, their password hashes in /etc/shadow, and groups in /etc/group. root has UID 0; system services use low UIDs; people get UIDs from 1000 up on RHEL.30 min
2. Creating and managing users and passwordsuseradd creates a user, passwd sets the password, usermod changes an account (usermod -aG adds a group), and userdel removes it. groupadd makes groups. chage controls password ageing: when a password expires and when an account stops working.30 min
3. File permissions: rwx, chmod and chownEvery file has an owner, a group and three sets of permissions: for the owner (u), the group (g) and others (o). Each set is read (r), write (w) and execute (x). chmod changes them, by letters (u+x) or numbers (r=4, w=2, x=1, so 750); chown changes the owner and group.35 min
4. umask and the special bits: SUID, SGID and stickyumask decides the permissions of new files: it removes bits from 666 for files and 777 for directories. Three special bits add more: SUID runs a program as its owner, SGID on a directory makes new files inherit its group, and the sticky bit on a shared directory lets people delete only their own files.30 min
5. Access control lists (ACLs)Normal permissions allow only one owner and one group. An ACL (access control list) adds extra entries for named users and groups, set with setfacl and read with getfacl. A + at the end of ls -l permissions means an ACL exists, and default ACLs on a directory are passed to new files.25 min
6. sudo and the sudoers filesudo lets an allowed user run one command as root, asks for the user's own password, and logs what was run. Rules live in /etc/sudoers and /etc/sudoers.d/, and you edit them only with visudo, which checks the syntax. On RHEL, members of the wheel group may run any command with sudo.25 min

See what is running and control it: processes, jobs, signals and priorities; systemd services and targets; logs with journalctl and a persistent journal; performance profiles with tuned and time sync with chrony. After this module you can start, stop, enable and debug any service on a RHEL server.

1. Processes: ps, top and jobsA process is a running program. Each has a PID (process ID), a parent, an owner and a state. ps shows a snapshot of processes, top shows a live view sorted by CPU, and the shell's job control (&, Ctrl+Z, bg, fg, jobs) lets you run commands in the background.30 min
2. Signals, kill and process priorityA signal is a short message to a process. kill sends one: SIGTERM (15) asks politely to stop, SIGKILL (9) stops at once, SIGHUP (1) often means "reload your config". pkill and killall pick processes by name. nice and renice change priority from -20 (most favoured) to 19 (least).25 min
3. systemd services and systemctlsystemd starts and supervises services. Each service is described by a unit file. systemctl start/stop/restart controls it now, enable/disable decides whether it starts at boot (enable --now does both), status shows its state and last log lines, and mask blocks it completely.35 min
4. Targets: the boot goal of the systemA target is a group of units that brings the system to a state, such as multi-user.target (text mode, network, services) or graphical.target (plus a desktop). systemctl get-default shows the boot target, set-default changes it, and isolate switches now. rescue.target and emergency.target are for repairs.25 min
5. Logs: journalctl, rsyslog and a persistent journalsystemd-journald collects logs from the kernel and every service; journalctl reads them with filters like -u (unit), -p (priority), -b (boot) and --since. rsyslog also writes classic text logs such as /var/log/messages and /var/log/secure. To keep the journal across reboots, make it persistent.30 min
6. Tuning profiles with tuned, and time with chronytuned applies ready-made performance profiles, such as virtual-guest or throughput-performance; tuned-adm recommend suggests one and tuned-adm profile applies it. Correct time matters for logs, certificates and logins: chronyd keeps the clock in sync with NTP servers, configured in /etc/chrony.conf.25 min

Install and manage software with dnf and rpm, set up repositories and AppStream, understand IP addresses, routes and DNS, configure network connections with nmcli, set the hostname, and open exactly the right ports with firewalld. After this module you can take a fresh RHEL server, give it a static address and a name, install a web server and make it reachable.

1. Installing software with dnf and rpmSoftware on RHEL comes in RPM packages. dnf downloads packages from repositories and installs them with all their dependencies; rpm queries what is installed. Learn dnf install, remove, update, search, info, provides and history, and rpm -qa, -qi, -ql and -qf.30 min
2. Repositories, BaseOS, AppStream and module streamsA repository is a server folder of packages with an index. RHEL 9 has two main repositories: BaseOS (the core OS) and AppStream (applications, languages and databases). Repositories are defined in .repo files in /etc/yum.repos.d/ with a name, baseurl, enabled and gpgcheck. AppStream can offer several versions of some software as module streams.30 min
3. Network basics: IP addresses, routes, DNS and the ip commandA server needs four things to talk on a network: an IP address, a prefix (netmask) that says which addresses are local, a default gateway for everything else, and DNS servers to turn names into addresses. The ip command shows addresses (ip addr) and routes (ip route); ss shows which ports are listening.35 min
4. NetworkManager with nmcli, the hostname and name resolutionNetworkManager owns the network settings on RHEL. nmcli manages connections: add one with a static address, gateway and DNS, modify it, and bring it up. hostnamectl sets the hostname. Names are looked up in /etc/hosts first and then in DNS, as /etc/nsswitch.conf says.35 min
5. firewalld: zones, services and portsfirewalld decides which incoming network traffic is allowed. Traffic is sorted into zones (public by default), and you allow services (like http) or ports (like 8080/tcp) in a zone with firewall-cmd. Changes are runtime-only unless you add --permanent, and permanent changes need --reload to take effect.30 min

Add a new disk and use it: partitions with MBR or GPT, XFS and ext4 file systems, mounting, permanent mounts in /etc/fstab with UUIDs, LVM volume groups and logical volumes you can grow while running, and swap space. After this module you can add, mount and extend storage on a live server without losing data or breaking the next boot.

1. Disks and partitions: MBR, GPT, fdisk and partedA new disk must be divided into partitions before most uses. Two partition table types exist: the old MBR (up to 4 primary partitions and 2 TiB) and the modern GPT (128 partitions, huge disks). lsblk shows disks and partitions; fdisk, gdisk and parted create them.35 min
2. File systems and mounting: XFS, ext4, mount and dfA file system is the structure that stores files and folders on a partition. RHEL's default is XFS; ext4 is also supported. mkfs.xfs or mkfs.ext4 creates one, mount attaches it to a directory, umount detaches it, and df -h and du show the space used.30 min
3. Permanent mounts with /etc/fstab and UUIDs/etc/fstab lists the file systems to mount at boot: one line each with the device, mount point, type, options, dump and fsck order. Use UUID= instead of /dev names because names can change. After editing, run systemctl daemon-reload and mount -a to catch mistakes BEFORE you reboot.30 min
4. LVM: physical volumes, volume groups and logical volumesLVM (Logical Volume Manager) pools disks into a volume group and cuts flexible logical volumes from it. Disks or partitions become physical volumes (pvcreate), are pooled into a volume group (vgcreate), and logical volumes are made with lvcreate. Space is counted in extents, 4 MiB each by default.40 min
5. Growing storage and adding swapGrow an LV and its file system in one step with lvextend -r. If the VG is out of space, add a disk with vgextend first. Swap is disk space used as overflow memory: make it with mkswap, turn it on with swapon, and add a swap line to /etc/fstab.35 min

Keep SELinux enforcing and still make things work: modes, contexts and labels, semanage fcontext with restorecon, booleans, port labels and reading denials with ausearch and sealert. Then secure remote access with SSH keys and a hardened sshd. After this module you can fix "permission denied" problems the right way, without turning security off.

1. SELinux: what it is and its modesSELinux is an extra security layer in the kernel. Normal permissions ask "which user owns this?"; SELinux also asks "is this kind of program allowed to touch this kind of file?" using labels. It runs in enforcing mode (blocks and logs), permissive mode (only logs) or is disabled. Keep it enforcing.30 min
2. Contexts and file labels: ls -Z, semanage fcontext and restoreconEvery file and process has an SELinux context: user:role:type:level. The type (ending in _t) is what matters most. ls -Z and ps -Z show contexts. To label a custom folder correctly and permanently, add a rule with semanage fcontext -a and apply it with restorecon -Rv.35 min
3. SELinux booleans and port labelsBooleans are on/off switches in the policy for common optional behaviour, such as letting httpd read home directories or connect to a database. getsebool lists them; setsebool -P changes them permanently. Ports have labels too: to run a service on a non-standard port, add the port with semanage port -a.25 min
4. Troubleshooting SELinux denialsWhen SELinux blocks something, it writes an AVC denial to /var/log/audit/audit.log. ausearch -m AVC finds them, sealert (from setroubleshoot-server) explains them in plain words and suggests a fix, and the journal shows a short summary. Read the source type, target type and action, then choose: label, boolean or port.30 min
5. SSH: keys, ssh-copy-id and hardening sshdSSH gives you an encrypted remote shell. Log in with a key pair instead of a password: ssh-keygen makes it, ssh-copy-id installs the public key on the server. Harden the server in /etc/ssh/sshd_config (or a drop-in file): no root login, no passwords once keys work, test with sshd -t, and reload.35 min

Make the server do routine work for you: schedule jobs with cron, at and systemd timers, pack and compress files with tar, and write bash scripts with variables, arguments, conditions, loops and exit codes. After this module you can automate a nightly backup that runs on time, cleans up after itself and reports failures.

1. Scheduling with cron and crontabcron runs commands on a schedule. Each user has a crontab, edited with crontab -e, where every line has five time fields (minute, hour, day of month, month, day of week) followed by the command. System jobs live in /etc/crontab and /etc/cron.d/, which have an extra user field.30 min
2. One-time jobs with at, and systemd timersat runs a command once at a set time (at 23:00, at now + 2 hours); atq lists waiting jobs and atrm removes them. systemd timers are the modern way to schedule: a .timer unit starts a .service unit on a calendar (OnCalendar=) or after a delay, logs to the journal, and can catch up on missed runs with Persistent=true.30 min
3. Archives and compression: tar, gzip, bzip2 and xztar packs many files into one archive file; gzip, bzip2 and xz compress files. tar can do both: -c creates, -x extracts, -t lists, -f names the archive, and -z, -j or -J pick gzip, bzip2 or xz. Always list (-t) before you extract, and use -C to choose where files go.30 min
4. Bash scripts: variables, quoting, arguments and exit codesA shell script is a text file of commands that starts with #!/bin/bash and is made executable with chmod +x. Variables hold text ($name), command substitution captures output ($(date)), $1 $2 and $@ are the script's arguments, and $? is the exit code of the last command: 0 means success.35 min
5. Bash scripts: conditions, loops and safe habitsif with [ ] or [[ ]] tests files, strings and numbers; case picks from several patterns. for loops over a list, and while read loops over the lines of a file. Functions group steps. Start scripts with set -euo pipefail so they stop at the first error instead of carrying on blindly.35 min

Understand every step from power-on to login, change kernel arguments and the default kernel with GRUB2 and grubby, recover a server whose root password is lost, and run applications in containers with Podman: images, ports, persistent storage with SELinux labels, rootless containers, and containers that start at boot as systemd services. After this module you can rescue a broken server and ship an app as a container.

1. The boot process, step by stepBooting is a relay race: the firmware (BIOS or UEFI) finds the boot loader, GRUB2 loads the kernel and the initramfs, the kernel starts with the initramfs as a temporary root to find the real disk, and then systemd (PID 1) starts everything up to the default target. Knowing the order tells you where to look when a boot fails.30 min
2. GRUB2, kernel arguments and the default kernelGRUB2 shows the boot menu. Press e to change the kernel arguments for ONE boot. For permanent changes on RHEL 9, use grubby (for example grubby --update-kernel=ALL --args="..."), or edit /etc/default/grub and run grub2-mkconfig. grubby also shows and sets the default kernel.30 min
3. Recovering a lost root passwordIf nobody knows the root password, you can reset it from the console: interrupt the boot with rd.break (or init=/bin/bash), remount the real root read-write, chroot into it, run passwd, and touch /.autorelabel so SELinux fixes the labels on the next boot. It needs console access, which is why physical and console security matter.30 min
4. Containers with Podman: images, run, ports and logsA container runs an application with everything it needs, isolated from the rest of the system but sharing the host's kernel. Podman is RHEL's container tool; it needs no background daemon and can run containers as a normal user. You pull images from registries, run them with podman run, publish ports with -p, and inspect them with ps, logs and exec.35 min
5. Persistent storage and containers as systemd servicesData inside a container disappears with it, so mount a host directory with -v HOST:CONTAINER:Z; the :Z option gives it the right SELinux label. To start a rootless container at boot, run it as a systemd user service: on current RHEL 9 with a Quadlet .container file (or the older podman generate systemd), and enable lingering with loginctl enable-linger.35 min

Automate many servers at once with Ansible: how the control node talks to managed nodes over SSH, inventories and ansible.cfg, ad-hoc commands, your first playbooks, the most-used modules and handlers. After this module you can turn a page of manual setup steps into a playbook that configures ten servers the same way, safely, again and again.

1. What Ansible is and how it worksAnsible is an automation tool: you describe the state you want (packages installed, services running, files in place) and it makes servers match. It is agentless: a control node connects to managed nodes over SSH and runs small programs called modules. Good modules are idempotent: running them twice changes nothing the second time.30 min
2. Inventory and ansible.cfgThe inventory lists your managed hosts in groups, in INI or YAML format; groups can contain other groups. ansible.cfg sets defaults such as which inventory to use, the remote user and privilege escalation (become). Ansible uses the first ansible.cfg it finds: $ANSIBLE_CONFIG, then ./ansible.cfg, then ~/.ansible.cfg, then /etc/ansible/ansible.cfg.35 min
3. Ad-hoc commands and ansible-docAn ad-hoc command runs one module on many hosts from the command line: ansible PATTERN -m MODULE -a "ARGUMENTS". It is good for quick checks and one-off fixes. Use -b to become root. ansible-doc shows every module's options and examples, offline.30 min
4. Writing and running playbooksA playbook is a YAML file with one or more plays. Each play names the hosts and a list of tasks; each task calls one module. Run it with ansible-playbook (or ansible-navigator run). Check it first with --syntax-check and a dry run with -C (check mode), and read the PLAY RECAP: ok, changed, failed, unreachable.35 min
5. Everyday modules and handlersA small set of modules covers most admin work: dnf, service, copy, template, file, user, group, lineinfile and firewalld. Always use the full name (FQCN) such as ansible.builtin.copy. Handlers are tasks that run only when notified by a task that changed something, typically to restart a service once at the end of the play.35 min

Write playbooks that adapt to each host: variables and facts, loops and conditions, Jinja2 templates, reusable roles and collections from Ansible Galaxy, Red Hat's ready-made RHEL System Roles, and Ansible Vault for secrets. After this module you can build a tidy, reusable automation project of the kind RHCE expects and real teams use.

1. Variables, facts and registered resultsVariables let one playbook work for many hosts and environments. Define them in the play (vars), in files (vars_files), per group or host (group_vars/ and host_vars/), or on the command line with -e, which always wins. Facts are variables Ansible gathers about each host (OS, IP, memory). register saves a task's result for later tasks.35 min
2. Loops, conditions and error handlingloop repeats a task for each item in a list; the current item is {{ item }}. when runs a task only if a condition is true, often using facts or registered results. block groups tasks, and rescue and always handle failures like try/catch/finally. failed_when and changed_when let you define what success means.35 min
3. Jinja2 templatesA template is a config file with placeholders. Jinja2 fills them in per host: {{ variable }} prints a value, {% if %} and {% for %} add logic, and filters like | default, | upper and | join shape values. The template module renders a .j2 file and copies the result to the host, reporting changed only if the result differs.30 min
4. Roles, collections and ansible-galaxyA role packages tasks, handlers, templates, files and default variables in a standard folder layout so you can reuse them, for example an "apache" role. Collections bundle roles, modules and plugins under a namespace, like ansible.posix. ansible-galaxy creates role skeletons and installs roles and collections, often from a requirements.yml file.35 min
5. RHEL System Roles and Ansible VaultRHEL System Roles are Red Hat's supported roles for common jobs: time sync, SELinux, networking, storage, firewall and more. Install the rhel-system-roles package and use them by setting their variables. Ansible Vault encrypts files that hold secrets (passwords, keys) so they can sit safely in Git; you give the vault password when you run the playbook.35 min

Turn your skills into a job: what the RHCSA (EX200) and RHCE (EX294) exams test and how they work, a practical exam strategy, building a home lab and a portfolio, and honest career paths and salary ranges in India. After this module you have a dated study plan, an exam-day checklist and a clear next step for your career.

1. RHCSA (EX200): what it is and how to prepareRHCSA (Red Hat Certified System Administrator) is earned by passing the EX200 exam. It is performance-based: you do real tasks on live RHEL systems, with no multiple-choice questions and no internet. It covers what modules 1 to 8 of this course teach. Always check the current exam page for the RHEL version, duration and objectives.30 min
2. RHCE (EX294): automation with AnsibleRHCE (Red Hat Certified Engineer) on current RHEL versions is earned by passing EX294, a hands-on exam about automating RHEL administration with Ansible, while holding a current RHCSA. You write inventories, playbooks, roles, templates and vault files that must work when the graders run them. Modules 9 and 10 of this course cover it; check the official page for current objectives.25 min
3. Exam strategy and lab habitsHands-on exams are won with habits: read every task fully, do the quick ones first, make everything persistent, verify as you go, and reboot before the end to prove it all comes back. A small checklist of commands that verify each kind of task saves points you would otherwise lose to small mistakes.30 min
4. Careers, salaries in India and your next stepsLinux skills lead to roles such as technical support engineer, Linux system administrator, cloud engineer, DevOps engineer and site reliability engineer. In India, freshers typically start around ₹3–6 LPA, varying by city and company, and pay grows with experience, certifications and automation skills. A home lab, a GitHub portfolio and clear interview answers matter as much as certificates.30 min