Skip to content
Français
Account: not signed in, sync available My learning
Select theme
Français

Operate a Linux server: the complete path

  • 15 min

By updated

Improve this page

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 situationRequired skill
A service refuses to start after a rebootsystemd, journalctl, systemctl status
A /etc/passwd file was modified in several placesdiff -u, patch workflow
50,000 log lines, find the critical errorsregex, grep -E, awk, journalctl -p err
Run a backup every night at 2 amcron, systemd timers
A server is slow, find the culprittop, vmstat, free -h, iostat
Extract the unique IPs from an access.logcut, sort, uniq in a pipeline
Automate the deployment of a configurationrobust Bash script with error handling
Connect to a server without a password, through a jump hostEd25519 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:

  1. Master text in a pipeline, the tools of the admin's daily work

  2. Run services, systemd is everywhere

  3. Observe in real time, read the state of the system

  4. Automate repetitive tasks

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, a trap and temporary files created by mktemp
  • 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