LPIC-1 course and practice exam: Linux Administrator (101-500 and 102-500)

This LPIC-1 course has 55 video lessons and 129 graded labs, and its LPIC-1 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.

Both LPIC-1 exams: system architecture to networking and security

Prepares you for both LPIC-1 exams, 101-500 and 102-500: system architecture, packages, GNU and Unix commands, file systems, shells and scripting, administration, services, networking and security.

Intermediate · 5 hours · 55 lessons · 131 labs

LPIC-1 exam guide

The LPIC-1 exam (LPIC-1: Linux Administrator, by Linux Professional Institute (LPI)): 90 minutes per exam; questions: 60 questions per exam; cost: varies by country; see lpimarketplace.com.

  • Format: Multiple-choice and fill-in-the-blank; two separate 60-question exams
  • Duration: 90 minutes per exam
  • Questions: 60 questions per exam
  • Cost: varies by country; see lpimarketplace.com
  • Valid for: 5 years
  • Delivery: Online proctored (OnVUE) or testing center (Pearson VUE)
  • Prerequisites: None

Exam domains and weights

  • 101-500: Topic 101: System Architecture: 13.3%
  • 101-500: Topic 102: Linux Installation and Package Management: 20%
  • 101-500: Topic 103: GNU and Unix Commands: 43.3%
  • 101-500: Topic 104: Devices, Linux Filesystems, Filesystem Hierarchy Standard: 23.3%
  • 102-500: Topic 105: Shells and Shell Scripting: 13.3%
  • 102-500: Topic 106: User Interfaces and Desktops: 6.7%
  • 102-500: Topic 107: Administrative Tasks: 20%
  • 102-500: Topic 108: Essential System Services: 20%
  • 102-500: Topic 109: Networking Fundamentals: 23.3%
  • 102-500: Topic 110: Security: 16.7%

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

10 LPIC-1 sample questions with answers: free to read, no account needed.

Common questions

How long is the LPIC-1 exam?

The LPIC-1 exam lasts 90 minutes per exam.

How many questions are on the LPIC-1 exam?

60 questions per exam.

How much does the LPIC-1 exam cost?

Varies by country; see lpimarketplace.com.

Is there a free LPIC-1 practice test?

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

Source: LPIC-1 Exam 101 and 102 Objectives (LPI official page, v5.0) (Linux Professional Institute (LPI)), checked 2026-10-01.

Who it is for

Intermediate level.

For people preparing for the two LPIC-1 exams, and for anyone who wants a broad grounding in everyday Linux administration that is not tied to one distribution.

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

LPIC-1 is two exams of multiple-choice and fill-in-the-blank questions: passing shows you know Linux administration. It doesn't test hands-on skill or replace running real servers; our graded labs have you work in a Linux sandbox.

Exam objectives this course teaches

LPIC-1: Linux Administrator

Labs

131 labs, 129 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: exam 101-500

  1. Sixty Questions, One Wrong Flag Each (3 labs): You can predict the output of short command lines the way the exam asks, tell the Debian and Red Hat package families apart, and read how this course's real, simulated and self-graded labs grade you.
  2. Exam 101 Strategy: Weights, Blanks And Ninety Minutes (2 labs): You can turn the 101-500 weights and your own confidence into a study order, answer fill-in-the-blank questions with exactly what is asked, and pace sixty questions in ninety minutes.

System architecture

  1. Hardware: What The Kernel Sees, What It Loads (2 labs): You can read hardware from /proc, /sys and /dev, identify devices and their drivers with lspci and lsusb, name mass storage devices, explain sysfs, udev and D-Bus, and load, blacklist or block kernel modules so the setting survives a reboot.
  2. Booting: Firmware To Login, And Where To Step In (2 labs): You can describe the boot from BIOS or UEFI through GRUB, the kernel and initramfs to init, pass a kernel option for one boot at the GRUB menu, compare SysVinit, systemd and Upstart, and read boot events with dmesg and a persistent journal.
  3. Runlevels, Targets And A Polite Shutdown (2 labs): You can map SysVinit runlevels to systemd targets, change the target now or by default, read /etc/inittab, warn users and shut down or reboot from the command line, and stop processes with TERM before KILL.

Installation and packages

  1. Disk Layout And The Boot Loader (4 labs): You can design a partition layout with /boot, the ESP, /var, /home, swap and LVM for a machine's purpose, read GRUB Legacy's menu.lst and GRUB 2's /etc/default/grub, regenerate grub.cfg with each family's tool, install the loader, and add a kernel option for every boot.
  2. Shared Libraries: Why A Program Will Not Start (2 labs): You can list a program's shared libraries with ldd, explain the loader's search order, read ld.so.conf and the ldconfig cache, tell a soname link from the real file, and make a library loadable with LD_LIBRARY_PATH or ld.so.conf.d and ldconfig.
  3. Debian Packages: dpkg, apt And The Sources List (2 labs): You can inspect a .deb file's fields and contents, find which package owns a file with dpkg -S or provides one with apt-file, install, hold, remove and purge with apt-get, read package status with dpkg -s and dpkg -l, and read both formats of the APT sources list.
  4. RPM, YUM, DNF And Zypper (3 labs): You can query package files and the RPM database with rpm -q and its letters, install, upgrade, verify and erase packages, find which package provides a file with rpm -qf and dnf provides, read .repo files, and translate the same tasks to yum, zypper and rpm2cpio.
  5. Linux As A Guest: Clones, Clouds And Containers (2 labs): You can tell virtual machines, system containers and application containers apart, find and reset the machine ID and SSH host keys a clone shares, read cloud-init user data, and describe IaaS instances, block storage, networks and guest drivers.

GNU and Unix commands

  1. What The Shell Hands Your Command (3 labs): You can predict what a command receives after the shell expands globs and variables, quote names and patterns so they arrive intact, and find a command's flags on the machine itself with type, help and --help.
  2. Variables, The PATH And The History (3 labs): You can set, export and unset variables and predict what a child process sees, tell set from env, explain how bash finds a command with type and which, run programs outside the PATH, use and configure history, and find help with man sections, apropos and help.
  3. 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.
  4. 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.
  5. Filters: Twenty Small Tools (2 labs): You can read compressed files with zcat, xzcat and bzcat, take lines from either end with head and tail, number, translate, delete and join lines with nl, tr and paste, inspect bytes with od, split and rejoin a file, and prove copies identical with md5sum, sha256sum and sha512sum.
  6. Files: Globs, Copies And Compression (3 labs): You can predict what *, ? and [] globs match, copy, move and remove files and trees with cp, mv, rm and rmdir, create paths, files and set times with mkdir -p and touch, identify files with file, write fixed-size files with dd, and compress and decompress with gzip, bzip2 and xz, and know cpio's input and output modes.
  7. 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.
  8. 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.
  9. 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.
  10. Processes: Priorities, Monitors And Long Jobs (2 labs): You can start and change process niceness with nice and renice and say why only root lowers it, monitor a system with top, free, uptime and watch, find and signal processes with pgrep, pkill and killall, and keep jobs running after logout with nohup, screen and tmux.
  11. 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.
  12. vi: The Editor That Is Always There (2 labs): You can switch between vi's normal, insert and command modes, move and search with h j k l, G and / ? n, insert, delete, copy, put and undo with i a o, x dd dw cw, yy p and u, save and quit with :w :wq :x ZZ or discard with :q!, and set EDITOR.

Devices and file systems

  1. Partitions And File Systems (2 labs): You can choose between MBR and GPT, create partitions with parted and know fdisk's and gdisk's keys, create ext2/3/4, XFS, VFAT, exFAT and swap with mkfs and mkswap, know what Btrfs adds, and read and change ext4 settings with dumpe2fs, tune2fs and e2label.
  2. File System Integrity: Measure, Check, Repair (2 labs): You can find what fills a file system with df, du and df -i, check and repair ext2/3/4 with fsck and e2fsck and read its exit status, adjust checks and labels with tune2fs, and choose xfs_repair, xfs_fsr and xfs_db for XFS.
  3. Mounting: By Hand And At Every Boot (2 labs): You can mount and unmount file systems by hand, read and write the six fields of /etc/fstab, name devices by UUID or LABEL found with blkid and lsblk, choose options such as noatime, noauto, user and nofail, test with mount -a, and recognise systemd mount units.
  4. 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.
  5. 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.
  6. 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.
  7. 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.
  8. The File Hierarchy And Finding Files (3 labs): You can place files in the right directories by the Filesystem Hierarchy Standard, find commands with which, type and whereis, and explain how locate, updatedb and updatedb.conf find files by name.

Mock exam 101-500

  1. Mock Exam 101-500 (1 lab): You can sit a sixty-question mock of exam 101-500 built from LPI's objective weights in ninety minutes, mark it, and turn the review's topic scores, objectives and misses into a replay plan.
  2. Review: The Traps Behind The Misses (2 labs): You can sort mock misses into four families of trap, replay the classic 101 traps for real, find them in a command history with a pattern list, and plan the last week before exam 101-500.

Start here: exam 102-500

  1. Exam 102 Strategy: Quick Points And Slow Projects (2 labs): You can turn the 102-500 weights and your own time estimates into points per hour, plan quick wins and long projects, and learn the files exam 102 asks about by their one job.

Shells and scripting

  1. The Shell Environment: Which File Runs When (2 labs): You can tell login, interactive and non-interactive shells apart and predict which of /etc/profile, ~/.bash_profile, ~/.bash_login, ~/.profile and ~/.bashrc each reads, define aliases and functions, load files with source, and give users defaults through /etc/skel and /etc/profile.d.
  2. 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.
  3. 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.

Interfaces and desktops

  1. X11: The Server Is Your Screen (3 labs): You can explain X11's client-server model and Wayland's place, read DISPLAY values, read xorg.conf and xorg.conf.d sections and the X log, control access with xhost and xauth, and allow or refuse X11 forwarding in sshd.
  2. Desktops, Remote Screens And Accessibility (3 labs): You can name the layers of a Linux desktop and the major environments, tell XDMCP, VNC, RDP and SPICE apart by purpose and port, and recognise and switch the keyboard and visual accessibility aids the exam names.

Administrative tasks

  1. 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.
  2. Account Files: Every Answer Is A Field (2 labs): You can read every field of /etc/passwd, /etc/shadow and /etc/group, answer account questions with awk and getent, create accounts with /etc/skel and system IDs, and lock, expire or remove an account knowing what each step leaves.
  3. Cron, At And Timers: Jobs Nobody Types (2 labs): You can read and write crontab lines with lists, ranges and steps, choose between user crontabs, system crontab files, at and systemd timers, control access with the allow and deny files, and write a timer that catches up after downtime.
  4. Encodings, Locales And Time Zones (3 labs): You can explain ASCII, ISO-8859, Unicode and UTF-8, convert text with iconv, predict which of LANG, LC_* and LC_ALL applies, and show or set a time zone with TZ, /etc/localtime, tzselect and timedatectl.

Essential system services

  1. Keeping Time: Two Clocks And NTP (2 labs): You can tell the system clock from the hardware clock and move time between them with hwclock, explain NTP strata, read chronyc sources and ntpq -p output, and point chrony at chosen servers so the clock is synchronised after every boot.
  2. Logs: rsyslog Rules And The Journal (2 labs): You can name syslog facilities and the eight priorities in order, write rsyslog selectors and actions including remote forwarding, send messages with logger, search the journal with journalctl, make it persistent, and rotate text logs with logrotate.
  3. Mail Servers: Aliases, Forwards And The Queue (2 labs): You can explain the MUA, MTA and MDA roles and the sendmail-compatible commands of sendmail, Postfix and Exim, route local mail with /etc/aliases, newaliases and ~/.forward, and read, flush and relay the mail queue.
  4. Printing With CUPS: Two Switches Per Queue (2 labs): You can describe CUPS, its port, files and drivers, submit, list and cancel jobs with both the System V and BSD commands, add and default a queue with lpadmin, and tell cupsreject and cupsdisable apart when a queue stops.

Networking

  1. Addresses, Subnets And Ports (3 labs): You can work out an IPv4 network, broadcast address and host count from a prefix length, recognise private, loopback and link-local ranges in IPv4 and IPv6, shorten IPv6 addresses, and match common services to their TCP or UDP ports.
  2. Network Settings That Survive A Reboot (3 labs): You can tell runtime ip changes from persistent configuration, give an interface a fixed address, gateway and DNS server with nmcli, netplan or ifupdown, set the host name with hostnamectl, and name the files behind each.
  3. Network Troubleshooting: A Ladder Of Questions (3 labs): You can troubleshoot a connection rung by rung with ip, ss, nc, ping, traceroute and tracepath and their net-tools predecessors, read a traceroute, find which way traffic leaves with ip route get, and fix a route for a test or for good.
  4. Client DNS: Files First, Then The Server (2 labs): You can trace how a name is resolved through nsswitch.conf, /etc/hosts and /etc/resolv.conf, explain systemd-resolved's stub, and query with getent, host and dig, knowing which of them read /etc/hosts.

Security

  1. Security Rounds: Special Bits, Logins, Ports And sudo (3 labs): You can find set user ID and set group ID files with find -perm, see who is and was logged in, find what holds a port with ss, lsof and fuser, set soft and hard limits with ulimit, and grant one command through a sudoers drop-in checked by visudo.
  2. Host Security: Old Doors And New Ones (3 labs): You can explain shadow passwords and fix a leaked hash, use /etc/nologin, read inetd and xinetd configuration and TCP wrappers' allow and deny files, and find and close unneeded services with ss, systemctl disable and mask.
  3. Keys For Machines, People And Files (3 labs): You can manage SSH host and user keys, known_hosts and authorized_keys, use ssh-agent, a client config and port forwarding, and explain GnuPG key pairs, encryption, signing, verification and revocation, signing and verifying a file with real tools.

Mock exam 102-500

  1. Mock Exam 102-500 (1 lab): You can sit a sixty-question mock of exam 102-500 built from LPI's objective weights in ninety minutes, mark it, and turn the review's topic scores, objectives and misses into a replay plan and a booking decision.
  2. Review: The Habits Behind The 102 Misses (2 labs): You can sort exam 102 mistakes into four habits, replay the shell traps with real bash, spot the admin traps in a command history, and plan the final week before booking exam 102-500.

Certification courses