CompTIA Linux+ course and practice exam: XK0-006

This CompTIA Linux+ course has 55 video lessons and 144 graded labs, and its CompTIA Linux+ 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.

System management, services, security, automation and troubleshooting

Prepares you for CompTIA Linux+ XK0-006: system management, services and user management, security, automation and scripting, and troubleshooting.

Intermediate · 5 hours · 55 lessons · 148 labs

CompTIA Linux+ exam guide

The CompTIA Linux+ exam (CompTIA Linux+ (V8), by CompTIA): 90 minutes; questions: maximum of 90; pass mark: 720 (on a scale of 100–900).

  • Format: Multiple-choice and performance-based questions
  • Duration: 90 minutes
  • Questions: Maximum of 90
  • Pass mark: 720 (on a scale of 100–900)
  • Valid for: 3 years, renewed through CompTIA Continuing Education (retirement estimated 2028)
  • Delivery: Online proctored or testing center
  • Prerequisites: Recommended: 12 months hands-on Linux experience; CompTIA A+, Network+, or Server+ or comparable knowledge

Exam domains and weights

  • System Management: 23%
  • Services and User Management: 20%
  • Security: 18%
  • Automation, Orchestration, and Scripting: 17%
  • Troubleshooting: 22%

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

10 CompTIA Linux+ sample questions with answers: free to read, no account needed.

Common questions

How long is the CompTIA Linux+ exam?

The CompTIA Linux+ exam lasts 90 minutes.

How many questions are on the CompTIA Linux+ exam?

Maximum of 90.

What is the CompTIA Linux+ passing score?

The pass mark is 720 (on a scale of 100–900).

Is there a free CompTIA Linux+ practice test?

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

Source: CompTIA Linux+ (V8) certification page (CompTIA), checked 2026-10-02.

Who it is for

Intermediate level.

For support and operations staff moving into Linux administration, and for anyone preparing for CompTIA Linux+ who wants practice that feels like the job.

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

Linux+ has multiple-choice and performance-based questions: passing shows you know Linux administration. It doesn't replace running real servers; our graded labs have you work on a simulated server that checks your result.

Exam objectives this course teaches

CompTIA Linux+ (V8)

Labs

148 labs, 144 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. The Pager Goes Off At 2 A.M.: A Three-Question Triage (2 labs): You can triage a failing Linux service with three questions (what is failing and since when, what the machine is short of, what changed just before), answer each from logs and command output with grep, awk and sort, and recognise how Linux+ asks the same thing in multiple-choice and performance-based questions.
  2. Ninety Minutes, Two Kinds Of Question: How Linux+ Is Scored (3 labs): You can plan your ninety minutes around performance-based and multiple-choice questions, explain the 720 passing score on the 100-900 scale, read BEST, FIRST and MOST likely stems, and complete a simulated-terminal task that still passes after a reboot on Rocky Linux and Ubuntu.

System Management

  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. 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.
  3. 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.
  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. Four Minutes To Boot: Firmware, GRUB, Kernel And Targets (2 labs): You can name each stage of the Linux boot (BIOS or UEFI firmware, GRUB, the kernel and its parameters, the initramfs, systemd and its default target), find where each is configured on Red Hat and Debian families, change kernel parameters and the default target so they persist, and explain PXE and the graphical stack.
  6. The App In /bin That Vanished: The FHS, Distributions And Licences (3 labs): You can say where the Filesystem Hierarchy Standard puts configuration, programs, variable data, add-on software and the kernel's views, tell which package owns a file, identify a distribution's family from /etc/os-release, and distinguish free software, open source, copyleft, permissive and proprietary licences.
  7. A Card With No Driver, A Stick With Too Much: Devices And Kernel Modules (3 labs): You can find which device lacks a driver with lspci -k and dmesg, predict what modprobe loads and refuses to remove, explain the difference between blacklist and install /bin/false in modprobe.d, disable a module the way a hardening benchmark requires, and choose among lsusb, lscpu, lsmem, lshw, dmidecode, ipmitool, insmod, rmmod, modinfo, depmod and dracut.
  8. No Space For Tonight's Scans: Partitions And LVM On Both Families (2 labs): You can partition a disk with GPT, build physical volumes, a volume group and a logical volume, put a file system on it and mount it by UUID, grow it online by adding a disk with vgextend and lvextend -r on Rocky Linux or Ubuntu, and choose among fdisk, gdisk, parted, growpart, pvmove, vgexport and vgimport.
  9. Which RAID, Which File System? Disks That Fail And Inodes That Run Out (3 labs): You can compare RAID 0, 1, 5, 6 and 10 by usable space, failures survived and write cost, read /proc/mdstat to spot a degraded array and name the mdadm steps to replace a member, and choose among XFS, ext4, Btrfs and tmpfs, including how inode count limits the number of files.
  10. The Upload That Ran: Mount Options, Swap And Network Shares (3 labs): You can write fstab entries by UUID with the security options noexec, nosuid and nodev, add swap that survives a reboot, mount an NFS share with _netdev and nofail, configure autofs to mount a share on demand, write an SMB entry, and read /proc/mounts, findmnt and remount options.
  11. A Server Nobody Can Find: Addresses, Routes And Names On Both Families (2 labs): You can give an interface a static address, gateway, name server and search domain with nmcli on Red Hat systems and a netplan file on Ubuntu, set the host name, explain how /etc/hosts, /etc/resolv.conf and /etc/nsswitch.conf decide name lookups, and choose among ip, ss, dig, nslookup, ping, tracepath, mtr, nc, curl, nmap, tcpdump, ethtool, arp and iperf3.
  12. 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.
  13. Friday's Backup, Monday's Restore: Incrementals, Images And Compressed Logs (3 labs): You can take full and incremental tar backups and restore them in order, copy and verify a block-level image with dd, explain when to use ddrescue, rsync and cpio, search compressed logs with zgrep and zcat, and choose among gzip, bzip2, xz, zip and 7-Zip.
  14. Twelve Old Servers, Two New Hosts: KVM, QEMU, libvirt And Disk Images (2 labs): You can explain how KVM, QEMU, virtio and libvirt divide the work, create a VM disk from a template with a qcow2 backing file, convert and resize images, move a VM between running, paused and shut off with virsh, take a snapshot, and choose NAT, bridged, host-only, routed or open networking.

Services And Users

  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. 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.
  3. 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.
  4. 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.
  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. 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.
  7. Starters, Leavers And A Service Account: Accounts On Two Families (2 labs): You can create user and system accounts with the right shell, home and UID range on Ubuntu and Rocky Linux, seed new homes from /etc/skel, remove a leaver with their home, read /etc/passwd, /etc/shadow, /etc/group and login.defs, and use id, groups, who, w, last, lastlog, chsh and groupmod.
  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. The Reindex That Died With The VPN: Jobs, cron, at And Timers (3 labs): You can run, list, stop and wait for background jobs, keep a job alive after logout with nohup, schedule repeating work with crontab, one-off work with at, and catch-up work with anacron or a systemd timer with OnCalendar and Persistent, on both Rocky Linux and Ubuntu.
  11. The Upgrade That Broke Nginx: Packages, Repositories And Pins On Both Families (3 labs): You can install, query and remove packages with dnf and rpm on the Red Hat family and apt and dpkg on the Debian family, read dependencies, add a repository with GPG checking, pin a package so upgrades skip it, use update-alternatives, and place source builds, pip, cargo, npm, Flatpak and Snap.
  12. Down Until Morning: Unit Files, Drop-ins, Masks And systemd's Helpers (2 labs): You can write a service unit with dependencies, a dedicated user and a restart policy, override a unit with a drop-in instead of editing it, tell start, enable and mask apart, reload systemd after changes, and use hostnamectl, timedatectl, resolvectl, sysctl and systemd-analyze, on both families.
  13. Clocks, Names, Addresses And Pages: The Services Every Depot Runs (3 labs): You can point chrony at internal NTP servers on both families, explain PTP, read a DNS zone and a DHCP configuration and find where they disagree, serve a page with nginx or httpd, and name the ports and roles of SMTP and IMAP servers.
  14. Works On My Laptop: Images, Containers, Volumes And Networks (2 labs): You can explain how Podman, Docker, containerd and runC relate, read and write a Dockerfile with FROM, USER, ENTRYPOINT and CMD, run a rootless container with a published port, an SELinux-labelled volume and environment variables, make it start at boot with a quadlet and lingering, and choose bridge, host, none, macvlan, ipvlan or overlay networking.

Security

  1. One Word Locked Out Every Directory User: PAM, SSSD, LDAP And Kerberos (2 labs): You can trace a login through a PAM stack, predict the result of required, requisite, sufficient and optional modules, find a one-word PAM change that locks users out, and explain how SSSD, LDAP, Kerberos, realm, Winbind, Samba and polkit fit into authentication and authorisation.
  2. Who Wrote That Sudoers File? The Journal, rsyslog, logrotate And auditd (2 labs): You can query the journal by unit, priority, tag and time, make it persistent, explain rsyslog selectors, remote forwarding and logrotate directives, write audit rules that watch files with keys, and find the login user behind a change with the audit trail even after sudo.
  3. One Rule, Four Firewalls: firewalld, ufw, nftables And iptables (4 labs): You can express one access rule in firewalld zones, ufw, nftables and iptables, make each persist across a reboot, tell runtime from permanent and services from ports, explain stateful filtering, ipset, NAT, PAT, DNAT and SNAT, and turn on IP forwarding.
  4. The Pager Command That Opened A Root Shell: sudo, su And Least Privilege (2 labs): You can write sudoers drop-ins for a group with exact commands, check them with visudo, understand what NOPASSWD and NOEXEC change, grant full administration through wheel on Rocky and sudo on Ubuntu, and choose between sudo -i, su - and a direct root login.
  5. Root Over SSH From Anywhere: Keys, sshd, setuid Files And Attributes (3 labs): You can create and restrict SSH keys, audit sshd_config and its drop-ins for root login, passwords, X11 forwarding, tries and allowed groups, explain agents, tunnels, SFTP chroots and fail2ban, find setuid and setgid programs that are not approved, use chattr and lsattr, and replace telnet, FTP and TFTP.
  6. Three Audit Findings And A Phone: Password Policy, Lockouts And MFA (4 labs): You can set password length, class and reuse rules with pwquality and pam_pwhistory, check passwords against a breach list, age and lock accounts with chage, passwd and usermod, give service and kiosk accounts nologin or rbash, lock out repeated failures with faillock, and explain how TOTP multifactor codes are made.
  7. The Certificate That Expired On A Sunday: Hashes, Encryption And Certificates (3 labs): You can tell a hash from an HMAC from encryption, encrypt a file with a passphrase, explain GPG and LUKS2 with Argon2, build and verify a certificate chain, diagnose untrusted, mismatched and expiring certificates, and choose TLS versions and algorithms to remove.
  8. What Changed Last Night? Integrity, Scans, Benchmarks And Secure Deletion (3 labs): You can build and check a file integrity baseline as AIDE does, read indicators of compromise, rank vulnerability findings by CVSS while allowing for backported fixes, explain OpenSCAP, CIS Benchmarks, banners, GDPR and supply chain checks, and destroy data with shred, dd, badblocks or a discarded key.

Automation And Scripting

  1. 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.
  2. 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.
  3. The Cleanup That Emptied The Wrong Directory: Shell Scripts Under Exam Conditions (3 labs): You can find faults in a shell script with shellcheck and by reading, cut paths apart with parameter expansion, match with [[ =~ ]] and BASH_REMATCH, split fields with IFS, and write guarded functions with local variables, defaults and return codes that a scheduler can trust.
  4. When awk Runs Out: Python Data Types, Modules And Virtual Environments For Admins (3 labs): You can read system data into Python lists and dictionaries, use the right data type for numbers, text and flags, use built-in modules such as json, argparse, pathlib and subprocess, create a virtual environment and install dependencies into it, and recognise PEP 8 style and indentation rules.
  5. The Release Tag That Never Left The Laptop: Git Branches, Remotes, Tags And History (3 labs): You can initialise and configure a repository, ignore secrets with .gitignore, commit, branch, diff and merge, clone, fetch, pull and push to a remote, tag releases and push the tags, park work with stash, squash and rebase branches, and undo commits with reset.
  6. Forty Servers By Teatime: Ansible Playbooks, Inventories And Puppet Manifests (4 labs): You can explain agentless push and agent-based pull configuration management, read an Ansible inventory and host patterns, read a playbook's plays, tasks, modules, variables, facts and handlers, explain idempotence, ad hoc commands and collections, and read a Puppet class with resources, facts and certificates.
  7. A New Depot By Friday: OpenTofu, Cloud-init, Pipelines And Kubernetes (3 labs): You can explain how OpenTofu uses providers, resources, state and APIs to plan changes, choose Kickstart or cloud-init for unattended installs, describe a CI/CD pipeline with shift-left testing, DevSecOps and GitOps, read a Kubernetes Deployment, Service, ConfigMap, Secret and volume, and compare Docker Swarm with Compose.
  8. The Assistant Was Confident: Reviewing AI-Generated Code, Prompts And Data (3 labs): You can list where AI assistants help an administrator, test a generated regular expression against hard cases, review a generated script with shellcheck and a dry run before it touches a system, decide what data may go into a public, private or local model under corporate policy, and write a prompt with context, constraints, examples and a required format.

Troubleshooting

  1. The Customers Noticed First: SLAs, SLOs, Alerts, SNMP And Log Aggregation (3 labs): You can tell an SLA from an SLO from an SLI and compute an error budget, set thresholds that alert on sustained problems instead of flapping, send alerts as events, notifications and webhooks, read SNMP traps with a MIB, choose agent or agentless collection, and explain health checks and log aggregation.
  2. You Are In Emergency Mode: Boot Failures From GRUB To fstab, On Both Families (3 labs): You can place a boot failure at the firmware, GRUB, kernel and initramfs, or systemd stage, use GRUB kernel parameters and rescue or emergency targets, rebuild an initramfs, repair an fstab entry that stops the boot, protect optional disks with nofail, and read exit statuses that mean not found, not executable, killed or crashed.
  3. No Space Left, Says The Disk With Room To Spare: Inodes, Held Files, Corruption And Repair (3 labs): You can tell block exhaustion from inode exhaustion with df -h and df -i, find space held by deleted but open files and free it, recognise quota errors, read I/O errors and read-only remounts as signs of a failing device, and repair an unmounted file system with e2fsck or xfs_repair, using a backup superblock when the primary is damaged.
  4. The Tracker Is Down, For Some People: Link, Address, Route, Name And Port (4 labs): You can work a network fault rung by rung: link state, negotiation and MTU; addresses, subnets and IP conflicts; gateways and routes; DNS, the hosts file and dual stack; listening sockets and firewalls; then fix the configuration persistently with nmcli or netplan.
  5. Forbidden, With Perfect Permissions: Paths, ACL Masks And SELinux Denials (3 labs): You can find a permission fault along a path with namei, read an ACL's effective rights and mask, check attributes and account access, read AVC denials, and fix SELinux file labels with semanage fcontext and restorecon, booleans with setsebool -P and ports with semanage port, instead of switching enforcement off.
  6. Patched On Paper: Missing Updates, Broken Chains, Old Protocols And Open Doors (3 labs): You can find and apply security updates and spot when a restart is still needed, diagnose expired, incomplete and weak certificates, explain protocol and cipher negotiation failures, close obsolete plain-text services, repair a repository that skips signature checks, and resolve package dependency problems.
  7. It Is Slow, Says Everyone: CPU, Memory, Disk And Network Bottlenecks (3 labs): You can work a slowness report against a baseline, read vmstat and load average for CPU saturation, blocked processes, swapping and I/O wait, spot a memory leak and an out of memory kill, measure packet loss and jitter, and recognise slow startup, failed log-in floods and hardware errors, with the tools and tuning for each.

Mock And Review

  1. Three PBQs Against The Clock: A Performance-Based Mock On Both Families (3 labs): You can work performance-based questions under time pressure: read every task first, gather evidence before changing anything, make each change persist, verify it as the grader will after a reboot, and recover partial credit when a task will not finish.
  2. Ninety Minutes, Five Domains: The Full Mock And The Week Before The Exam (1 lab): You can pace a ninety-minute Linux+ attempt, decode BEST, FIRST and MOST likely questions, eliminate distractors across all five domains, mark a practice set by domain to choose what to revise, and recall the acronyms the released objectives add, including CUPS printing.

Certification courses