LFCS course and practice exam: Linux Foundation Certified System Administrator

This LFCS course has 55 video lessons and 94 graded labs, and its LFCS practice exam follows the official exam objectives: a 20-question sampler free with an account, the full question bank and timed mock exams with Pro.

Operations, networking, storage, users and services on Linux

Prepares you for the performance-based LFCS exam: operations deployment, networking, storage, essential commands, and users and groups.

Intermediate · 5 hours · 55 lessons · 112 labs

LFCS exam guide

The LFCS exam (Linux Foundation Certified System Administrator, by The Linux Foundation): 2 hours; questions: 17–20 performance-based tasks; pass mark: 67%; cost: USD 445 (exam only; includes one free retake).

LFCS vs RHCSA: which Linux admin exam should you take?

  • Format: Performance-based: tasks solved on the command line running Linux
  • Duration: 2 hours
  • Questions: 17–20 performance-based tasks
  • Pass mark: 67%
  • Cost: USD 445 (exam only; includes one free retake)
  • Valid for: 2 years
  • Delivery: Online, proctored (PSI Bridge)
  • Prerequisites: None

Exam domains and weights

  • Operations Deployment: 25%
  • Networking: 25%
  • Storage: 20%
  • Essential Commands: 20%
  • Users and Groups: 10%

A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.

10 LFCS sample questions with answers: free to read, no account needed.

Common questions

How long is the LFCS exam?

The LFCS exam lasts 2 hours.

How many questions are on the LFCS exam?

17–20 performance-based tasks.

What is the LFCS passing score?

The pass mark is 67%.

How much does the LFCS exam cost?

USD 445 (exam only; includes one free retake).

Is there a free LFCS practice test?

Yes. A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.

Source: LFCS exam page (Linux Foundation Training) (The Linux Foundation), checked 2026-10-03.

Who it is for

Intermediate level.

For Linux administrators preparing for the hands-on LFCS exam, and for anyone who wants Ubuntu servers that come back correctly after every reboot.

What you don't need yet:

What helps:

No formal prerequisites. The courses under "Take first" cover what helps.

Take first:

Take next:

Learning paths:

Nobody needs to know everything before they start. Each course builds on the one before, so a learning path takes you there step by step.

What this exam proves, and what it doesn't

LFCS is a performance-based exam: you solve tasks on the command line of a running Linux system, so passing shows you can do the work. It doesn't replace running production servers; our graded labs use a simulated Ubuntu server.

Exam objectives this course teaches

Linux Foundation Certified System Administrator (LFCS)

Labs

112 labs, 94 of them graded: you write the code, it runs, and graded labs check the result. The outline lists each lesson's labs.

What is free

Start free: First module free with an account. Pro: Every course, lab, handbook, practice exam and certificate.

Course outline

Start Here

  1. Two Hours, Twenty Hosts, One Reboot (2 labs): You can tell a runtime change from a persistent one, make a kernel parameter, a service and a host name survive a reboot, and read the PASS and FAIL lines of this course's simulated Ubuntu labs.
  2. Exam Strategy: Hosts, Help And The Order Of Twenty Tasks (1 lab): You can move between the base host and task hosts, use the documentation the exam allows, avoid the ports the exam reserves, and order a task list by points per minute and dependency.

Command Line Foundations

  1. Redirection: Where Output And Errors Go (3 labs): You can send a command's output and its errors to files or to each other in the right order, append without truncating, protect files with noclobber, and build pipelines and tee chains that carry the stream you mean.
  2. grep And Regular Expressions Under Time Pressure (3 labs): You can filter lines with grep's everyday flags, write anchored patterns with classes and counts in basic and extended syntax, and extract just the matching text from many files.
  3. Fields, Counts And Stream Edits (3 labs): You can split lines into fields with cut and awk, sort by a numeric column, count repeats with uniq, and change, delete or print lines with sed, in a pipeline or in place with a backup.
  4. Archives, Compression And A Restore That Works (2 labs): You can create, list and extract tar archives with gzip or xz compression, restore into another directory, pick single files or exclude patterns, and explain what tar does with absolute paths and permissions.
  5. Scripts That Say Whether They Worked (2 labs): You can write a bash script with a shebang, arguments and a usage message, test files, numbers and strings, branch with if, && and case, and return exit statuses that callers and schedulers can act on.
  6. Loops That Do A Day's Work (2 labs): You can loop over files, lines and ranges, read delimited lines safely, keep running totals with arithmetic, and write a provisioning loop that is safe to run twice.

Operations Deployment

  1. Processes: Parents, States And Priorities (2 labs): You can find a process and its parent, read its state in ps output, recognise stopped and zombie processes, start a job with a lower priority, change it with renice, and select processes by name with pgrep and pkill.
  2. Signals: Ask First, Then Insist (2 labs): You can send signals by name and number, explain which can be caught, read the exit status a signal leaves, write a trap that cleans up, and manage background jobs with jobs, kill %n, wait and timeout.
  3. Kernel Parameters: Now, At Boot, And Which File Wins (1 lab): You can read and set kernel parameters through sysctl and /proc/sys, make them persistent in /etc/sysctl.d, predict which file wins when several set the same key, and apply them without a reboot.
  4. Services That Will Not Come Back: Masks, Targets And The Journal (2 labs): You can work out why a service is down with is-active, is-enabled, get-default and the journal, unmask and enable a unit, fix an install section that the boot never reaches, and clear a start limit.
  5. Scheduling: cron, systemd Timers And at (1 lab): You can choose between cron, a systemd timer and at from a task's wording, write cron fields and timer calendars, make a job catch up after downtime, and control who may schedule jobs.
  6. Packages And Repositories: Find, Install, Hold, Purge (1 lab): You can make a package visible by fixing a sources entry, install, hold, remove and purge packages with apt, add a third-party repository with its own key, and inspect and pin versions.
  7. Recovering From Boot, File System And Disk Failures (1 lab): You can recognise and repair a boot stopped by /etc/fstab, reach a root shell from GRUB, check and repair ext4 and XFS file systems safely, and read the signs of a failing disk or degraded RAID array.
  8. Virtual Machines With libvirt: XML, virsh And Autostart (4 labs): You can read and fix a libvirt domain definition, explain define versus create, and use virsh to start, autostart, inspect, stop and remove guests, practising the commands in a self-graded VM task.
  9. Containers: Run, Publish, Persist, And Configure The Engine (2 labs): You can run containers with published ports, volumes and restart policies, make them start at boot with Docker's daemon or a Podman quadlet with linger, and change an engine's configuration without stopping it from starting.
  10. SELinux: Modes, Labels, Ports And Booleans That Last (1 lab): You can keep SELinux enforcing now and at boot, label files with lasting rules, add ports to a service's type, set booleans persistently, read an AVC denial, and recognise AppArmor's equivalents on Ubuntu.

Networking

  1. Addresses, Gateways And Names On Both Stacks (2 labs): You can configure static IPv4 and IPv6 addresses, a default route, DNS servers and a search domain with netplan, set the host name and static host entries, apply changes safely over SSH, and test resolution the way programs do.
  2. Time Sync With chrony: Servers, Zones And Proof (1 lab): You can tell the clock, the time zone and the NTP client apart, point chrony at exactly the servers a task names, set the zone, read chronyc's view of its sources, and let a network query this host.
  3. Network Troubleshooting: The Ladder From Link To Port (1 lab): You can diagnose a network fault layer by layer with ip, getent, ss, nc and curl, tell refused from timed out from unreachable, and use counters, logs and packet captures for faults that come and go.
  4. OpenSSH: Keys, Client Aliases And A Hardened Server (3 labs): You can create key pairs, write client host aliases and read their effective settings, harden sshd with a drop-in in a safe order, apply a port change on a socket-activated server, and use the directives the exam asks for.
  5. Packet Filtering With nftables: A Default Drop That Stays Up (2 labs): You can write an nftables input policy that drops by default, accepts established traffic and the required services, keeps the exam environment's ports open, loads at boot, and say when ufw is the right front end instead.
  6. Port Forwarding, Redirection And NAT With nftables (2 labs): You can turn a host into a router that masquerades an inside network, forward and redirect ports with destination NAT, filter forwarded traffic, keep forwarding on at boot, and verify translations with counters and conntrack.
  7. Static Routes: Prefixes, Metrics And Persistence (2 labs): You can predict which route the kernel picks by prefix and metric, add static routes with backups that survive a reboot in netplan or NetworkManager, prove them with ip route get, and recognise policy routing.
  8. Bridges And Bonds: Two Links, One Interface (3 labs): You can choose between a bond and a bridge, pick a bonding mode a switch can support, write both in netplan so they return at boot, read a bond's health from its status file, and prove a failover for real in a self-graded VM task.
  9. Reverse Proxies And Load Balancers (2 labs): You can explain what a reverse proxy changes for the back end, run a round-robin balancer that skips a failed server, write the nginx upstream, proxy_pass and header directives that keep the client's identity, and choose a balancing method.

Storage

  1. Names, Inodes And Links (3 labs): You can explain what a file name points to, create hard and symbolic links and predict which survives a delete or a rename, and tell copy from move by what happens to the inode.
  2. LVM End To End: Pools, Volumes And Online Growth (1 lab): You can build LVM from a bare disk with a chosen extent size, size volumes in units or extents, put ext4 and XFS on them mounted by UUID at boot, and grow them online with their file systems.
  3. The Virtual File System: /proc, /sys, Binds And tmpfs (2 labs): You can read processes and kernel values through /proc and /sys, explain which virtual file systems use memory, write bind and tmpfs mounts with security options in fstab, and change mount options live and for the boot.
  4. File Systems: Create, Label, Mount And Repair (1 lab): You can choose between ext4, XFS and vfat, partition a disk and create labelled file systems mounted by label at boot, read block and inode usage, and check and repair file systems safely.
  5. Remote File Systems: NFS, SMB And Network Block Devices (2 labs): You can mount NFS and SMB shares at boot without risking a hung boot, keep SMB credentials out of fstab, choose mount options for a server that goes away, and attach and mount a network block device in a self-graded VM task.
  6. Swap: Partitions, Volumes, Files And Priorities (2 labs): You can add swap as a partition, a logical volume or a file, activate it now and at every boot, order several swap areas with priorities, tune vm.swappiness, and resize or remove swap safely.
  7. Automounters: autofs Maps And systemd Automount (1 lab): You can mount shares on demand with an autofs master map and a wildcard indirect map, mount a single path on first access with systemd's automount, choose between them, and debug a mount that does not appear.
  8. Storage Performance: Busy, Slow, Or Both (2 labs): You can turn disk counters into iostat's rates, tell a saturated device from a busy parallel one by wait and queue size, find the process behind the load and lower its I/O priority.

Essential Commands

  1. Git For Admins: Who Changed That, And How To Undo It (2 labs): You can keep configuration in a Git repository, commit and push to a shared remote, branch and merge a change, find the commit behind a problem and undo it with revert.
  2. Services You Write: Units, Drop-Ins And The Reload (3 labs): You can read a unit file for faults, write a service that runs as its own account and restarts on failure, change a packaged unit with a drop-in, and make it start at every boot.
  3. Performance Triage: Processor, Memory Or Disk? (2 labs): You can read load average against the processor count, tell from vmstat whether processors, memory or disks are the bottleneck, find the process responsible with ps and /proc, and lower its priority or stop it.
  4. Constraints: Limits, Control Groups And Listeners (3 labs): You can read and change a process's resource limits, set lasting limits and whole-service caps for a systemd service with a drop-in, and check which addresses a service listens on.
  5. find: Ask The File System A Question (3 labs): You can combine find's tests for name, type, size, age, permissions and owner, act on the results with -exec, -delete or xargs, and handle names with spaces safely.
  6. Disk Full At Three In The Morning (3 labs): You can find what filled a file system with du and find, tell a block shortage from an inode shortage, recover space held by a deleted but open file without a restart, and stop it happening again.
  7. SSL Certificates: Create, Inspect And Verify A Chain (2 labs): You can create a private certificate authority and a server certificate with subject alternative names, inspect its fields and expiry, verify its chain, serve it and explain each client verification error.

Users And Groups

  1. Reading And Setting Permissions (3 labs): You can read a mode string and its octal form, set modes symbolically and in octal, predict what read, write and execute mean on a directory, and say who may change a file's owner and group.
  2. The Umask And The Special Bits (2 labs): You can predict the mode of a new file or directory from the umask, set a umask for a session and for good, and set, read and find setuid, setgid and sticky bits, including the capital S and T cases.
  3. Access Control Lists: One More Reader (2 labs): You can grant a named user or group access with setfacl, read an ACL and its mask with getfacl, set default ACLs that new files inherit, and remove entries cleanly.
  4. Users, Groups And Password Aging (2 labs): You can create groups and users with chosen IDs, primary and supplementary groups, comments and shells, add a group without removing others, set a first password the user must change, apply an expiry policy, and remove an account with its home.
  5. Accounts On Ubuntu: Skeletons, Groups And Offboarding (1 lab): You can create accounts with the right home, shell, groups and first-login password, give every new user standard files through /etc/skel, append groups without removing others, and lock, expire or remove accounts.
  6. Environment Profiles: Which File Does This Shell Read? (2 labs): You can predict which startup files a login, interactive or script shell reads, set environment for every user or one user in the right file, and give cron jobs and services the variables they need.
  7. User Limits: Who Gets Which Number At Login (1 lab): You can set per-user and per-group resource limits in limits.conf and limits.d, predict which line wins for any user, and check the result in a fresh login session.
  8. LDAP Users Through SSSD (2 labs): You can configure an Ubuntu client to resolve and authenticate LDAP users through SSSD, with the right file permissions, name service switch and home directory creation, and diagnose which layer fails when a directory user is invisible.

Timed Drills And Mock Exam

  1. Drill: From Emergency Mode To A Clean Boot (1 lab): You can bring an Ubuntu server out of emergency mode caused by a bad fstab line, and fix its boot target, a kernel parameter overridden by a vendor file, and a masked service, inside twelve minutes, with every change surviving a reboot.
  2. Drill: A Gateway That Survives The Reboot (3 labs): You can configure an Ubuntu host's name, static address, routes and DNS in netplan and a drop-by-default nftables ruleset with a port redirect, persistent across a reboot, inside fifteen minutes.
  3. Drill: Volumes, Swap, A Share And A Team Directory (1 lab): You can turn a spare disk into a mounted volume and active swap, mount a network export at boot, and set up a group directory with setgid and an ACL for one outsider, inside fifteen minutes, all surviving a reboot.
  4. Mock Exam, Part 1: Seventeen Tasks, One Reboot (5 labs): You can complete seventeen LFCS-style tasks across operations, users, networking and storage on an Ubuntu server within ninety minutes, verify each after a reboot, and score the result honestly with a strict sheet.
  5. Mock Exam, Part 2: Real Machines And The Costly Mistakes (2 labs): You can run the self-graded second part of the mock on two Ubuntu virtual machines, combine it with part one into one score, and recognise the mistakes that pass before a reboot and fail after it.

Certification courses