LFCS prep
You work through the LFCS objectives on a real Ubuntu server: commands, networking, services and storage tasks.
Level 201 · 23 lessons · 21 practice labs
Lessons
Commands, operations and users
- Essential commands: You will use comfortably the essential commands expected on the LFCS exam: file handling, searching, text processing and archiving.
- Operations and deployment: You will consolidate operations topics such as boot, processes, scheduled jobs and software deployment, following the LFCS objectives.
- Users and groups: You will apply user and group management, permissions and delegated privileges, following the LFCS objectives.
- User resource limits: ulimit and limits.conf: You will cap how many files and processes a user can open, using ulimit and limits.conf.
- Looking up users from a central directory: an LDAP client: You will understand central user directories and configure a client to look up accounts from one.
- Setting kernel parameters persistently with sysctl: You will change kernel network and memory parameters with sysctl and keep them across reboots.
- Managing virtual machines with libvirt: You will list and start virtual machines with virsh and adjust their CPU and memory.
- Short task: open a developer account with limits and make a kernel setting persistent
Networking and services
- Networking: You will configure and check network interfaces, addressing, name resolution and firewall settings, following the LFCS objectives.
- Assigning IPv6 addresses and verifying dual stack: You will give an interface an IPv6 address and verify with ping6 and ip that it works alongside IPv4.
- Packet filtering, saving and NAT with iptables: You will write iptables rules, save and restore them across reboots, and redirect one port to another.
- Bridge and bond devices: You will group interfaces in a bond for redundancy and build a bridge for virtual machines.
- Services and systemd: You will start and stop services with systemd, set them to run at boot and read their logs, following the LFCS objectives.
- Service resource limits and writing systemd units: You will write your own service unit with memory and CPU limits and diagnose a service that hits them.
- Inspecting a TLS certificate with openssl: You will read a server certificate’s expiry, chain and name with openssl and spot problems.
- Short task: turn the server into a NAT gateway and constrain its service
Storage
- Storage: You will partition disks, create file systems and mount them at the level the LFCS exam expects.
- Swap files, tmpfs and on-demand mounts: You will add a swap file, create a memory-backed tmpfs, and set up on-demand mounts with systemd.
- Remote storage: network block devices and remote file systems: You will attach a disk offered over the network and know what happens when the connection drops.
- Monitoring storage performance with iostat: You will read wait time and utilisation in iostat output and identify a slowing disk.
- Short task: mount a remote share on demand and measure disk performance
Exam preparation
- Exam strategy and practice: You will pick up how the hands-on exam works, how to manage your time and the habit of verifying each task, through practice runs.
- Capstone: apply every exam objective on one server against the clock
Practice labs
- Read and raise a user's open-file limit: On an Ubuntu server you read a developer account's soft and hard open-file limits, raise them for the session and verify the new value.
- Put a persistent process cap on the build team: You define process and memory limits for Yelkenli Yazılım's build group under limits.d and prove they apply in a new session.
- Rein in an account that freezes the server: In a scenario where a runaway script freezes the server you find the account, set a persistent limit and rerun the script to show the server stays up.
- Read a kernel setting and change it temporarily: You read the current IP forwarding and swappiness values, change one temporarily and see it revert after a reboot.
- Make a setting persistent with sysctl.d: You make swappiness and the file-handle maximum persistent for a database server in a separate sysctl.d file and verify after a reboot.
- Resolve two sysctl files overriding each other: You find in the files' load order why a setting returns to an unexpected value at boot and reduce it to one correct source.
- List virtual machines and read their state: With virsh you tabulate the virtual machines on a server, their memory and CPU shares and autostart state.
- Start a VM at boot and increase its memory: You set Karabatak Denizcilik's reporting VM to start at boot, double its memory and verify from inside the guest.
- Clone a VM and attach a new disk: You clone a template VM, attach a second virtual disk to the clone and format and persistently mount it inside the guest.
- Read a netplan file and apply it safely: You read an Ubuntu server's netplan configuration and apply a small DNS change with rollback using netplan try.
- Give an interface a static IPv6 address: You define a static IPv6 address and gateway on the second interface with netplan and reach a neighbouring server over IPv6.
- Repair a netplan that drops the network on bad indentation: On a server that gets no address after reboot you find the indentation and key errors in the netplan file from the console and restore dual stack.
- Read rule chains and their counters: On a gateway you list the filter and nat table rules with counters and find the rule matching the most traffic.
- Send the internal network out with masquerade: On a two-interface Ubuntu server you enable forwarding, write a masquerade rule for the internal network and reach an outside server from a client.
- Make NAT rules survive a reboot: You save forwarding and NAT rules lost at reboot with iptables-persistent and prove they return at boot together with the sysctl setting.
- Read a service's unit file and status: With systemctl cat and status you find a service's start command, user account and last error message.
- Write your own systemd service for a script: You write a unit file that runs a monitoring script as a separate user, restarts on crash and is enabled at boot.
- Cap a service's memory and CPU: You give a memory-hungry report service MemoryMax and CPUQuota through a drop-in file and show with systemd-cgtop that the caps hold under load.
- Add and enable a swap file: You create a 1 GB swap file on a memory-starved server, enable it with correct permissions and make it persistent in fstab.
- Move a build directory onto tmpfs: You persistently mount a temporary build directory as a size-capped tmpfs with noexec and test that the cap holds.
- Mount a remote share on first access: You define the archive share with x-systemd.automount in fstab and show it mounts on first access without delaying boot and unmounts when idle.
About this course
You work through the LFCS objectives on a real Ubuntu server: commands, networking, services and storage tasks.
What you will learn
- Commands, operations and users
- Networking and services
- Storage
- Exam preparation
Prerequisites
Finishing the level 101 courses of the same path, or knowing those topics, is enough.
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 201; 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.