LFCS practice exam 1
A timed, hands-on practice exam.
Level 301 · 20 lessons · 18 practice labs
Lessons
Task sets
- Task set A: commands and users: In the first part of the timed practice exam, you solve command and user management tasks in your own lab.
- Task set B: storage and networking: In the second part of the timed practice exam, you solve storage and networking tasks and verify the results.
- Task set C: services and operations: In the last part of the timed practice exam, you solve service and operations tasks and verify that they work.
- Short task: redo your hardest task set against the clock
Scenarios: services, packages and networking
- Scenario: fixing the dependency fault of a health-check service: You will find and repair a service’s dependency fault using systemctl and journalctl.
- Scenario: setting and verifying a persistent kernel parameter: You will change a parameter with sysctl and write it to a file so it survives reboots.
- Scenario: installing a package from an internal repository and checking its signature: You will add a repository key and install a package after confirming its signature.
- Scenario: testing name resolution in both directions: You will verify with dig and getent that names resolve to IPs and back, using hosts and resolv.conf.
- Scenario: limiting the SSH server to keys and chosen users: You will turn off password login in sshd_config and allow only a chosen group of users.
- Scenario: adding a static route and verifying an IPv6 address: You will add a route to a remote network with ip route and test IPv6 reachability.
- Short task: restrict SSH, add the route and verify name resolution
Scenarios: storage, certificates and maintenance
- Scenario: building LVM on a new disk and mounting it persistently: You will create a physical volume, volume group and logical volume, and mount the file system via fstab.
- Scenario: rescuing a system that will not boot because of a bad fstab line: You will find the faulty line in rescue mode, fix it and return to a normal boot.
- Scenario: tracing the source of a disk-full alert: You will compare df, du and inode use to find the directory filling the disk and clean it safely.
- Scenario: checking a certificate’s expiry and chain: You will use openssl to report whether a certificate is about to expire and whether its chain is complete.
- Scenario: giving a developer account limited sudo and resource limits: You will limit an account’s privileges and resource use with sudoers.d and limits.conf, and test them.
- Scenario: setting up a nightly maintenance job with cron and logging: You will write a cron entry, redirect its output to a log file and confirm that the job ran.
- Short task: rescue a system that won’t boot and set up nightly maintenance
Review and final
- Review and closing the gaps: You will review the mistakes and skipped tasks from the practice, identify the weak topics and draw up a plan to close them.
- Capstone: a timed 2-hour full mock exam
Practice labs
- Find an installed package's version and origin: With apt-cache policy and dpkg you report a package's installed version, candidate version and source repository.
- Hold a package that must not change on upgrade: On Gelincik Fırın's till server you hold the database package and prove its version is unchanged after a full upgrade.
- Recover a half-finished apt install: You clear the lock, half-configured package and missing dependency left by an interrupted install in turn and return apt to a clean state.
- Open an account with an expiry date for a temp: You open an account with an end date for a three-month contractor and verify the date in chage output.
- Create ten users with their groups from a list: You write a short loop that creates ten employees from a CSV file with primary and supplementary groups and verify with getent.
- Separate two accounts with a colliding UID: You give one of two accounts sharing a UID a new ID, migrate file ownership without breaking it and test access.
- Print a service's dependency tree: With systemctl list-dependencies you write which units an application service depends on and its start order.
- Make a worker start after the database: You add After and Requires to a queue worker that crashes by starting before the database and show it comes up clean on reboot.
- Fix a service that starts before its disk mounts: You stop a service whose data directory lives on a separate volume writing to an empty directory using RequiresMountsFor and prove the boot order from the journal.
- Find the exit path in a routing table: With ip route get you find which interface and gateway three destinations use and put them in a table.
- Add a second address and a persistent route: With netplan you add a second IPv4 address to an interface and a static route to the warehouse network and verify after a reboot.
- Return replies on the right link of a two-homed server: On a server on two networks you show replies leaving the wrong interface get dropped and fix it with a source-based routing rule.
- Report free space in a volume group: From pvs, vgs and lvs output you write how much free space each volume group has and which disks it spans.
- Snapshot before an upgrade and roll back: You snapshot application data, deliberately damage the data and return it to its previous state from the snapshot.
- Empty a failing disk and remove it from the group: You move data off a physical volume that has started erroring onto another disk without downtime and remove it from the volume group.
- Fix a cron line running at the wrong time: You correct a faulty cron line that runs every minute so it runs at 02:30 on weekdays and verify the syntax.
- Write a rotation rule for an application log: You write a weekly, compressed, eight-copy logrotate rule for a growing application log and test it with a forced run.
- Solve a job that runs by hand but fails silently in cron: You find the backup script failing under cron because of PATH and working-directory differences, redirect its output to a log and fix it.
About this course
A timed, hands-on practice exam.
What you will learn
- Task sets
- Scenarios: services, packages and networking
- Scenarios: storage, certificates and maintenance
- Review and final
Prerequisites
You should be comfortable with the level 101 and 201 topics of the same path.
Lab environment
Lessons run in your own Kali Linux terminal in the browser, connected to a private lab network. Nothing to install.
Frequently asked questions
- Is this course right for my level?
- The course is at level 301; it assumes you know the topics of the lower-level courses.
- Is there anything to install?
- No. Every lesson runs in your own lab environment that opens in the browser.
- How do lessons work?
- Each lesson has 8 to 10 steps and a short quiz. Early steps show the command to type, later steps give less help; if two attempts fail, the solution opens.
- Can I try it for free?
- Yes. The first three lessons of every course are free.