The Operate module of the Linux course teaches you to act on a live system: transform data in bulk, run services under systemd, work remotely over SSH, automate scheduled tasks, watch resources and interpret logs. It gathers 47 lessons across 8 groups, this page included, of which 11 carry a lab and 45 a quiz. It assumes the basics of the Fundamentals module are in place: navigation, permissions, redirections and filtering with grep. These are the skills expected of a working Linux administrator, and the direct foundations of the LFCS and RHCSA certifications.
What can an administrator who masters this module do?
They diagnose a service that refuses to start, extract a piece of information from 50,000 lines of log and automate the task they have just done by hand. The table below starts from situations you will meet on a production server, and gives the skill that answers each one. It also works as an entry test: if three rows leave you without an answer, this module is for you.
| Real situation | Required skill |
|---|---|
| A service refuses to start after a reboot | systemd, journalctl, systemctl status |
A /etc/passwd file was modified in several places | diff -u, patch workflow |
| 50,000 log lines, find the critical errors | regex, grep -E, awk, journalctl -p err |
| Run a backup every night at 2 am | cron, systemd timers |
| A server is slow, find the culprit | top, vmstat, free -h, iostat |
| Extract the unique IPs from an access.log | cut, sort, uniq in a pipeline |
| Automate the deployment of a configuration | robust Bash script with error handling |
| Connect to a server without a password, through a jump host | Ed25519 keys, ~/.ssh/config, ProxyJump |
The lessons of the module, group by group
The 8 groups follow one another in the order below, that of the training plan, for a complete progression, but each one stands on its own if you are after a precise skill. Each lesson carries its guide, often its quiz, and a lab when the operation needs a real machine.
Process text on the command line
Extract, transform, compare and analyse text, from the configuration file to the access log. This is the most rewarding group of the module: these tools come back in all the others, and they weigh heavily in both certifications.
Edit and transform. Vim for administration covers modes, motions, text objects and substitution, the editor present on every server. Search and replace in a file changes a configuration without opening it, with sed, vim and grep. cut, tr and paste extract columns and convert characters, sort, count and deduplicate analyses lists with sort, uniq, wc and comm, and diff compares and propagates configuration changes with the patch workflow.
Search and analyse. Regular expressions give the anchors, POSIX classes and quantifiers shared by grep, sed and awk. Follow a log in real time watches a deployment live with tail -f and journalctl -f. sed goes as far as capture groups and in-place editing, awk filters by field and computes totals, and advanced redirections add here-doc, process substitution and xargs.
Archive and exchange. Advanced tar makes incremental backups with --listed-incremental and sends them over SSH. Download with curl and wget handles GitHub releases, tokens and the resumption of an interrupted transfer, and check the integrity of a file verifies with sha256sum or gpg --verify that an archive has not been altered.
Remote access with SSH
Connection, key authentication, remote commands and tunnels: SSH beyond a simple login. It is the protocol through which all the rest of your administration work passes, and the first service you will harden in the Secure module.
Create and manage SSH keys covers Ed25519, ssh-copy-id, authorized_keys and its permissions. Connect over SSH organises ~/.ssh/config, ProxyJump and ControlMaster, and configure the OpenSSH server validates sshd_config with sshd -t. Run remote commands chains pipes, remote sudo and loops over several servers, and SSH tunnels open an internal service, expose a local service or create a SOCKS proxy.
Write Bash scripts
Scripts and functions to eliminate repetitive tasks. The seven lessons follow one another in order: you cannot usefully debug a script whose parameter expansions you do not yet master.
Write a shell script lays down the structure and the shebang. Variables and parameters details $1, $#, $@, expansions and arrays, conditions and tests cover if, [[ ]] and case, and loops cover for, while and until. Robust scripts add set -euo pipefail, trap and mktemp, functions add local and source, and debug a script covers bash -x, PS4, shellcheck and trap ERR.
Alternative shells
Customise Bash, discover Zsh and Fish. This group is the only truly optional one: it unlocks no exam skill, but it saves time every day for anyone who lives in a terminal.
Customise Bash sets up aliases, functions, PS1 and fzf. Zsh brings Oh My Zsh, autocompletion and plugins, and Fish brings autosuggestions and syntax highlighting without a configuration file.
Schedule tasks
cron, at and systemd timers make the system autonomous. The three lessons each carry a lab, because a scheduled task can only be verified by waiting for it to fire on a real machine.
cron covers the crontab syntax, variables and the debugging of silent tasks. at schedules a one-off action with atq and atrm, and systemd timers replace cron with OnCalendar and built-in logging.
Manage processes
Observe, control and cap what runs on the machine. This group answers two different questions: what consumes resources, and why a process still exists.
Manage processes covers ps, top, kill, nice and renice, from observation to control. Shell jobs suspend and resume a command with Ctrl+Z, bg and fg, background execution launches and monitors with &, $! and wait, and nohup survives an SSH disconnection. witr walks up to the ancestor of a process to answer "why is this running?", and resource limits cap open files and processes with ulimit, limits.conf and prlimit.
Performance and tuning
Measure before optimising. This group first teaches you to read the memory and load indicators, and only then to apply a profile of system settings.
Monitor memory reads free, /proc/meminfo and vmstat to detect a leak. Assess performance identifies the bottleneck among CPU, disk and network with the load average, iostat and sar. Tuned profiles then apply a tuning with tuned-adm, and verify it.
systemd and boot
systemd is the service manager of every modern Linux server: it starts units, manages their dependencies and centralises their logs. These guides cover the foundation used every day. The Maintain module comes back to it for one precise point: enabling a service at boot and proving that it comes back after a reboot.
Reboot and shut down cleanly covers shutdown, reboot and warning the active sessions. Kernel boot parameters go through grubby on RHEL and update-grub on Debian, with the check in /proc/cmdline. Understand systemd lays down units, targets and dependencies, start and diagnose a service moves on to systemctl, journalctl filters by service, priority or boot, and logrotate keeps /var/log from filling the disk.
Which neighbouring guides help day to day from this module?
Five guides useful every day belong to other modules of the Linux course: compression, the three tools for transferring between machines, and the tmux terminal multiplexer. They are not among the lessons of this module, but they come up constantly when you operate a server, especially for backups and deployments.
Archive and compress, from the Fundamentals module, covers tar, gzip and zip. The Networking module holds the three transfer tools: SCP for a copy to a remote server, SFTP for an interactive session, rsync for incremental synchronisation. Finally, tmux keeps your sessions alive, with windows, panes and ~/.tmux.conf (its guide is not yet translated).
Where should I start, depending on my level?
Three profiles enter this module through three different doors. Choose the tab that suits you: the complete progression for those coming out of Fundamentals, the entry by need for an administrator already in post, the entry by exam objective for those preparing a certification.
You have just finished the Fundamentals module and want to step up to a real system. 3-5 weeks
If time is short, the minimal path takes four steps, in this order: text in a pipeline, then systemd and journalctl, then a first script scheduled with cron, then processes and memory. This is the operational minimum to administer a Linux server in production, and it represents about two weeks of regular work.
For a complete path, follow this order:
-
Master text in a pipeline, the tools of the admin's daily work
- Transform text with cut, tr and paste, extract columns from a flat file
- Sort, count and deduplicate, analyse lists and logs
- Basic regular expressions, grep, sed, awk with powerful patterns
- Compare files with diff, detect and propagate changes
-
Run services, systemd is everywhere
- Understand systemd, the architecture before the commands
- Start and diagnose a service, systemctl day to day
- Read logs with journalctl, find the cause of a failure
-
Observe in real time, read the state of the system
- Follow a log in real time, tail, journalctl -f, grep --line-buffered
- Manage processes on Linux, ps, top, kill, nice
- Monitor memory, free, vmstat, /proc/meminfo
-
Automate repetitive tasks
- Write a shell script, the foundations
- Bash variables and parameters,
$1 $# $@, expansions, arrays - Bash conditions and tests,
[[ ]], file tests,case - Bash loops,
for,while, reading a file - Write robust scripts, set -euo pipefail, error handling
- Bash functions,
local, return throughecho,source - Debug a Bash script,
bash -x,shellcheck, RHCSA pitfalls - Schedule with cron, recurring tasks
You already administer Linux servers and want to consolidate your practices or fill gaps. targeted by need
| Your need | Recommended guides |
|---|---|
| Services that go down without explanation | Understand systemd → Diagnose a service → journalctl |
| Logs that are too large | Follow a log in real time → Rotation with logrotate |
| Fragile scripts that break in production | Robust scripts |
| Silent scheduled tasks | Cron → systemd timers |
| Slow server, unknown cause | Processes → Memory → Performance → Tuned profiles |
| A mysterious process is still running | witr → Resource limits |
| Configs that diverge between servers | diff and patch → Regex and sed |
| Back up and transfer between servers | Advanced tar → rsync → Check integrity |
The Operate module directly covers several domains of the Linux Foundation (LFCS) and Red Hat (RHCSA) certifications. certification
| Certification objective | Guides covered here |
|---|---|
| LFCS, Compare and Manipulate File Content | diff, cut, tr and paste, sort, count and deduplicate |
| LFCS / RHCSA, Analyze text with regular expressions | regex basics, BRE, ERE, grep, sed, awk |
| LFCS, Use Input-Output Redirection | regex basics + advanced redirections |
| LFCS / RHCSA, Locate and Analyze System Log Files | follow logs, journalctl |
| LFCS / RHCSA, Manage Startup Process and Services | systemd, services, kernel boot parameters |
| LFCS / RHCSA, Diagnose and Manage Processes | processes, resource limits |
| LFCS / RHCSA, Schedule Tasks | cron, at, timers |
| LFCS / RHCSA, Use Scripting to Automate Tasks | script, variables, conditions, loops, robust scripts, functions, debug |
| LFCS, Pagers and Vi | Vim |
| LFCS / RHCSA, Archive, compress, unpack with tar | advanced tar, archive and compress |
| LFCS, Configure the OpenSSH client (SFTP) | SFTP, SCP |
| LFCS / RHCSA, Configure the OpenSSH server and client | OpenSSH server, Connect over SSH, Create and manage SSH keys |
| RHCSA, Configure key-based authentication for SSH | Create and manage SSH keys |
| LFCS, Use SSH tunneling and port forwarding | SSH tunnels |
| LFCS, Download files over the network | Download with curl and wget |
| LFCS / RHCSA, Verify file integrity | Check the integrity of a file |
| RHCSA, Transfer files securely (rsync, SCP, SFTP) | rsync, SCP, SFTP |
How do I validate what I have learned in this module?
Eleven lessons of the module carry a lab playable with the dsoxlab CLI, and 45 of the 47 lessons end with a quiz. The labs cover first what requires a real machine: scheduling with cron, at and systemd timers, running services and reading journals, resource limits and tuned profiles.
The rest of the module is validated another way, and that is deliberate: a cut | sort | uniq pipeline is checked by typing it on your own files, not in a graded environment. Take a real log from your machine, a /var/log/auth.log or the output of journalctl -p err -b, and ask yourself a precise question to answer in a single command. The full catalogue is listed with dsoxlab list-labs.
Key takeaways
- The Operate module counts 47 lessons in 8 groups, this page included, of which 11 lessons with a lab and 45 with a quiz
- It turns a Linux user into an operational administrator: services, logs, scripts, scheduling, processes
- systemd and journalctl form the core: a service that does not start is always diagnosed along the same path
- Text pipelines (
cut,sort,uniq,grep,sed,awk) are reused everywhere, including in auditing and hardening - A production script carries
set -euo pipefail, atrapand temporary files created bymktemp - These skills are directly assessed by the LFCS and RHCSA, practical exams in front of a machine
- What comes next is played out in the Maintain, Secure and Troubleshoot modules, in the order of the training plan