Linux

94 courses, 1539 lessons. A real Kali Linux lab in the browser.

Linux quick start (Level 101, 13 lessons): In one short, focused tour you practise the basics of files, permissions and accounts on a Linux server from day one.
Linux fundamentals (Level 101, 18 lessons): The terminal, the file system, file operations, redirection and pipes.
Linux commands practice (Level 101, 28 lessons): You try the most used Linux commands one by one and combine them in a real admin task at the end of each section.
Users, groups and permissions: chmod, chown, sudo (Level 101, 18 lessons): Accounts, groups, file permissions, ownership and sudo.
PowerShell fundamentals: cmdlets, pipeline, scripting (Level 101, 24 lessons): Learn from scratch to use PowerShell on Windows and Linux for object-based commands, data filtering and small automation scripts.
First steps on the Linux desktop (Level 101, 15 lessons): Windows, the file manager, apps and the terminal: you learn to use Linux comfortably on a graphical desktop, then step into the terminal.
Linux distributions and release cycles (Level 101, 13 lessons): You get to know Debian, Ubuntu, the Red Hat family, Arch and Alpine, and learn about support lifetimes, package formats and choosing well for a server.
How Linux is put together: hardware, kernel and user space (Level 101, 14 lessons): What happens behind the scenes when you type a command? You learn Linux's layers, from hardware to kernel and from system call to process, through analogies and live observation.
Vim fundamentals (Level 101, 19 lessons): You learn modes, movement, editing, searching and saving in Vim, which is on every server, and edit config files without fear.
Terminal sessions with tmux (Level 101, 14 lessons): You run several jobs from one terminal with sessions that survive a dropped connection, split panes and windows.
Files and disks: inodes, mounts and disk space (Level 101, 16 lessons): You learn from the ground up how a file sits on disk, what partitions, file systems and mount points are, and how to keep track of disk space.
Installing software on Linux: apt, dnf, Snap and Flatpak (Level 101, 14 lessons): You learn from the ground up what a package is, why repositories are trusted and how to install, update and remove software with command-line and graphical tools.
Regular expressions and grep: first steps (Level 101, 15 lessons): You learn to search text for patterns from scratch and use character classes, repetition and anchors to find what you need in logs, lists and config files.
First steps in Bash scripting (Level 101, 14 lessons): You learn to turn commands you type by hand into small scripts: creating and running the file, variables, input and simple decisions.
A first look at processes and services (Level 101, 13 lessons): You learn from the very beginning how to see running programs, close a frozen one, send work to the background and tell whether a service is running.
A first look at logs (Level 101, 13 lessons): You learn from scratch where Linux writes down events, how to read a log line and how to follow a problem's trail through the logs.
Troubleshooting fundamentals (Level 101, 14 lessons): You learn to work with method rather than panic when something breaks: defining the symptom, forming a hypothesis, testing one variable at a time and keeping notes.
First steps in backups (Level 101, 12 lessons): You learn with simple tools why we back up, what to back up and how to tell whether a backup really works.
Job role: Linux support technician (Level 101, 13 lessons): You live through a support technician's week: a forgotten password, a full home directory, an app that won't open and a printing problem; you solve each ticket and keep a record.
Linux skills assessment: beginner (Level 101, 12 lessons): Timed, hands-on questions measure your basic skills with files, permissions, text and processes, and after each section you get study suggestions for your gaps.
Processes and systemd: ps, top, systemctl (Level 201, 18 lessons): Watching processes, signals, background jobs and managing services.
Packages and storage: apt, dnf, LVM, tar (Level 201, 25 lessons): Software with apt and dnf, disks, partitions and mounting.
Text processing: grep, sed, awk (Level 201, 18 lessons): Searching files, transforming text and building reports.
Shell scripting (Bash) (Level 201, 19 lessons): Bash scripts with variables, conditions, loops and functions.
Logs and scheduled tasks: journalctl, cron, at (Level 201, 15 lessons): journalctl, syslog, cron, systemd timers and backups.
100 days of Linux (Level 201, 20 lessons): A short, real Linux task every day.
Linux practice challenges: workplace scenarios (Level 201, 19 lessons): You solve short problems from a real sysadmin’s day, finding the cause and applying a lasting fix each time.
Command line mastery: the shell, history and workflow (Level 201, 20 lessons): You learn the shell's expansion rules, readline shortcuts, history expansion and job control in depth, and finish your daily work in half the time.
Advanced Vim: macros, registers and text objects (Level 201, 18 lessons): You multiply your editing speed with text objects, registers, macros, multiple files and windows, and write your own .vimrc.
Bash scripting challenges (Level 201, 16 lessons): You solve short scripting tasks taken from real admin problems on your own, check them against test data and get them ready for review.
PowerShell scripting: functions, modules and error handling (Level 201, 18 lessons): You write reusable PowerShell scripts with advanced functions, parameter validation, modules and robust error handling.
Server monitoring basics: vmstat, iostat and sar (Level 201, 16 lessons): You learn to read CPU, memory, disk and process metrics, look back in time with sar and set up simple threshold alerts.
Hardware and drivers: udev, modules and devices (Level 201, 17 lessons): You learn how devices are detected, how drivers load as kernel modules and how to give devices stable names and permissions with udev rules.
Virtual machines with KVM and libvirt (Level 201, 16 lessons): You turn Linux into a virtualisation host, build VMs with virsh and virt-install, and manage their disks, networks and snapshots.
Publishing a website on Linux (Level 201, 15 lessons): Starting from an empty server, you put a website live: the web server, file permissions, the host name, the logs and your first HTTPS.
System settings: time, locale, host name and kernel parameters (Level 201, 16 lessons): You set up a server's identity and core settings correctly: host name, time zone and time sync, language and keyboard, sysctl and persistent configuration.
Backups on Linux: tar, rsync and snapshots (Level 201, 16 lessons): You set up full, incremental and differential backups with tar and rsync, take consistent backups with LVM snapshots, automate the work and run regular restore tests.
Advanced access control: ACLs, attributes, capabilities and sudoers (Level 201, 16 lessons): Where classic permissions fall short, you apply least privilege with ACLs, immutable attributes, file capabilities and fine-grained sudoers rules.
Linux desktop administration (Level 201, 15 lessons): You manage how the graphical session starts, the display manager, Wayland versus X11, printing, sound and remote desktop, and solve users' desktop problems.
Job role: junior system administrator (Level 201, 16 lessons): As a newly hired system administrator you spend your first month: taking over servers, account and backup work, daily checks and your first on-call shift.
Linux skills assessment: intermediate (Level 201, 15 lessons): You measure your intermediate skills with packages, storage, scripts, logs and services through timed, real server tasks.
Boot process and recovery: GRUB, systemd (Level 301, 18 lessons): Boot loader, kernel, initramfs and rescuing a system that won’t boot.
Web servers: Nginx and Apache (Level 301, 17 lessons): Installation, virtual hosts, TLS and configuration.
Centralised log management: Loki, Promtail, Grafana (Level 301, 16 lessons): Collecting, keeping and reviewing logs with rsyslog.
Advanced Bash scripting: reliable and secure automation (Level 301, 24 lessons): You write production-grade Bash scripts that stop safely on errors, validate input and run several jobs at once.
The command-line toolbox: ripgrep, fd, fzf and parallel (Level 301, 18 lessons): You meet fast modern counterparts of the classic tools, bulk work with GNU parallel and small helpers such as watch and entr, and build your own toolbox.
Vim on servers: remote editing, large files and ex scripts (Level 301, 15 lessons): You use Vim efficiently on huge logs, remote files and bare systems, and move editing into scripts with ex and vim -es.
Advanced storage: LVM, RAID, LUKS and snapshots (Level 301, 20 lessons): You build, grow and repair logical volumes, thin provisioning, snapshots, RAID and encrypted disks the way it is done in production.
Package repositories and version pinning (Level 301, 18 lessons): You manage signed repositories, local mirrors, version pinning and priorities, and run your own repository for offline networks.
Programming with awk (Level 301, 18 lessons): You take awk beyond one-line filters and write real reporting programs with variables, arrays, functions and multi-file processing.
Automation with PowerShell: remoting, testing and scheduling (Level 301, 16 lessons): You build reliable automation across many servers with remoting over SSH, parallel runs, Pester tests, classes and secret management.
systemd in depth: units, dependencies and socket activation (Level 301, 20 lessons): You learn unit files, dependencies and ordering, drop-in changes, socket and path activation, user services and tmpfiles to production standard.
rsyslog and journald in depth (Level 301, 17 lessons): You learn journald's structured fields and rsyslog rules, templates and reliable forwarding, and filter, split and keep logs without losing any.
Server monitoring with Prometheus and Grafana (Level 301, 18 lessons): You collect metrics with node_exporter, query them with PromQL, build Grafana dashboards and watch your servers' health on one screen.
Linux performance tuning: CPU, memory and disk (Level 301, 18 lessons): You find the bottleneck with the USE method, tune the scheduler, memory, swap, I/O and kernel parameters by measurement, and prove the effect of every change.
Breakage scenarios: solve them yourself (Level 301, 17 lessons): On pre-broken servers you find the cause without hints, fix it and write a short report; each scenario tests a different subsystem.
System containers with LXC and Incus (Level 301, 15 lessons): You build lightweight containers that behave like a full Linux system, manage them with profiles, storage, networking, snapshots and limits, and measure how they differ from VMs.
Enterprise backups: restic, Borg and immutable backups (Level 301, 16 lessons): You build deduplicated, encrypted, remote backup repositories with restic and Borg and put retention policy, immutable copies and ransomware-resistant design into practice.
PAM and NSS: the login chain (Level 301, 15 lessons): You learn which modules a user passes through at login and where account information comes from, and safely configure password policy, account lockout and two-step verification.
Release upgrades and distribution migration (Level 301, 15 lessons): You upgrade end-of-life servers to a new release or move them to another distribution, following pre-checks, backups, the upgrade itself, validation and a rollback plan.
Job role: Linux system administrator (Level 301, 16 lessons): You are responsible for a mid-sized company's Linux infrastructure: new services, capacity, backups, updates, access and incidents, living a real workload through a quarter's worth of tasks.
Linux skills assessment: advanced (Level 301, 15 lessons): You measure your advanced skills in boot recovery, advanced storage, systemd, performance and web services through timed scenarios with no hints.
Build challenges: a working system from scratch (Level 301, 15 lessons): Each task gives you an empty server and a requirements list; with no hints you build, test and hand over: restricted users, scheduled reports, encrypted archives, websites and more.
File systems in depth: ext4, XFS, Btrfs and ZFS (Level 401, 19 lessons): You compare journaling, allocation, repair and tuning options, and put snapshots, compression and replication to work with Btrfs subvolumes and ZFS pools.
Patch management: planned updates and live patching (Level 401, 15 lessons): You follow security advisories, split updates into test and production rings, and manage automatic updates, restart requirements and live kernel patching.
Structured data on the command line: jq, yq, CSV and XML (Level 401, 17 lessons): Instead of hacking at JSON, YAML, CSV and XML with grep, you query, convert and validate them with the right tools and handle API output and configs safely.
Building tools in Bash: testing, libraries and distribution (Level 401, 18 lessons): You turn Bash scripts into tools teams trust: library structure, testing with bats, configuration, logging, versioning and CI checks.
Advanced PowerShell: performance, runspaces and tool design (Level 401, 13 lessons): You measure performance on large data, manage concurrency with runspaces, use .NET directly and design safe PowerShell tools ready for release.
Resource control and service isolation with systemd (Level 401, 17 lessons): You set CPU, memory and I/O limits with cgroups v2, isolate services with options such as DynamicUser and ProtectSystem, and tighten them while measuring the effect.
Alerting and on-call: Alertmanager, SLOs and post-incident reviews (Level 401, 14 lessons): You write quiet alert rules, route and silence with Alertmanager, and decide what deserves an alert from data, using SLOs and error budgets.
Performance analysis with perf and eBPF (Level 401, 17 lessons): You sample with perf and draw flame graphs, watch the inside of the kernel and applications live with bpftrace and BCC, and find problems with evidence rather than guesses.
Outage drills (Level 401, 16 lessons): You work like the on-call engineer: an alert arrives, the clock runs and problems chain across several servers; you handle diagnosis, communication and the lasting fix together.
The Linux kernel: building, configuring and tuning (Level 401, 16 lessons): You fetch, configure, build and boot the kernel source, and safely practise kernel parameters, module signing and writing a small module of your own.
Container internals: namespaces, cgroups and chroot (Level 401, 15 lessons): Without a container engine, you build your own container step by step from the kernel's isolation building blocks and see what each layer protects and what it doesn't.
Advanced Nginx: load balancing, caching and rate limiting (Level 401, 17 lessons): You turn Nginx into a production front end that spreads load across backends, caches responses, limits abuse and gets TLS right.
Advanced Apache: MPMs, PHP-FPM and performance (Level 401, 14 lessons): You tune Apache's process models, module management, PHP-FPM integration, reverse proxying and hardening for production load.
Server disaster recovery: back from bare metal (Level 401, 14 lessons): When a server is lost entirely, you bring it back from nothing with a documented, tested procedure: system images, configuration backups, Relax-and-Recover and recovery drills.
Central identity: LDAP, SSSD and Kerberos (Level 401, 17 lessons): Instead of creating users on every server, you manage them from a central directory: OpenLDAP, the SSSD client, single sign-on with Kerberos and access rules.
Fleet operations: managing many servers (Level 401, 15 lessons): You manage dozens of servers as a fleet rather than one by one: inventory, parallel commands, configuration drift, versioned /etc, golden images and standard builds.
Job role: site reliability engineer (SRE) (Level 401, 15 lessons): You tie reliability to measurable goals: SLOs, error budgets, cutting toil through automation, capacity and controlled failure experiments, raising a service's reliability over a quarter.
Linux skills assessment: expert (Level 401, 13 lessons): You measure your expert skills in identity, storage recovery, performance analysis and multi-server operations through long, linked tasks.
Linux expert challenges (Level 401, 16 lessons): Long tasks that start with little information and span several subsystems: recovering lost data, solving performance mysteries, rebuilding identity and storage together.
Storage failures and data recovery (Level 501, 16 lessons): Following the "copy first" rule, you recover a corrupted file system, a lost partition table, a deleted logical volume and a dying disk without losing data.
Building packages: .deb and .rpm (Level 501, 18 lessons): You turn your own tools and configuration into signed .deb and .rpm packages, getting maintainer scripts, dependencies and reproducible builds right.
Working with huge logs: speed, scale and accuracy (Level 501, 15 lessons): You process tens of gigabytes of logs without running out of memory and with correct results, making locale, sorting, parallelism and sampling decisions by measurement.
Bash internals: parsing, performance and portability (Level 501, 17 lessons): You learn in depth how the shell parses and runs a line, what subprocesses cost, how to stay portable to POSIX sh and which subtleties lead to security bugs.
Process internals: /proc, signals, strace and ptrace (Level 501, 17 lessons): You examine a process's memory map, file descriptors, signal masks and system calls live, and diagnose processes that hang, leak or hide.
Hard failures in production (Level 501, 17 lessons): You solve hard failures such as memory leaks, OOM loops, hung I/O, descriptor exhaustion, clock skew and kernel warnings under pressure and on the evidence.
Kernel debugging: kdump, crash and ftrace (Level 501, 15 lessons): You capture a memory dump when the kernel crashes and examine it with crash, read oops, panic and lock-up messages, and trace what happens inside the kernel with ftrace.
Advanced virtualisation: performance, live migration and high availability (Level 501, 15 lessons): You tune VM performance with virtio, CPU pinning, huge pages and NUMA, migrate live and keep VMs running when a host fails.
Running the web stack: deployments, certificates and capacity (Level 501, 15 lessons): You run a web stack end to end with zero-downtime deployments, automatic certificate renewal, capacity measurement and traffic management during incidents.
Joining Linux to Active Directory (Level 501, 16 lessons): You join Linux servers to a Windows domain and handle login with realmd and SSSD, group-based access, sudo, Kerberos keytabs and mixed-estate problems.
Job role: senior Linux engineer (Level 501, 14 lessons): You are the technical owner of an organisation's Linux platform: you set standards, write architecture decisions, run hard incidents, grow the team and defend the long-term roadmap.
Linux mastery challenges (Level 501, 13 lessons): The hardest level: undocumented systems, missing tools and time pressure, and you find solutions at every layer from kernel to application.

Projects

A standard toolkit for a new server: You install the basic tools every team needs on a freshly built Linux server and hand over a checklist showing the server is ready.
Shared folders for departments: users, groups and permissions: You set up the users, groups and shared folders for teachers, accounting and management on the new file server of Gelincik Okulları. You hand over a permission table showing who can read and write what.
A first backup routine for a small office: You back up the case folders of Sedirli Hukuk Bürosu with tar, place the backup on a separate disk and bring a deleted file back from it. You finish by writing the one-page backup instruction the office will follow.
Support desk: solve three tickets and write them up: You work through three tickets opened for the booking server of Mercanköşk Otelcilik (a full disk, a stopped service, a wrong file permission) and fix them one by one. For each ticket you write a note with the symptom, the cause and the fix.
Server health monitor in Bash: You write a Bash script that checks a company Linux server's disk, memory and processor load, and prints a clear warning when something looks wrong.
Convert and verify a document archive in bulk: You convert the company's document archive to a new format in one run and deliver a check report showing no file was lost or damaged.
Move a data folder without losing local changes: You move a data folder to a new place without losing the changes made locally, then verify that nothing is missing afterwards.
Free disk space before it runs out: quotas and clean-up policy: You set up user quotas and an old-file clean-up policy before a server disk fills up, and show with measurements that space was freed.
A release with a rollback plan: You publish a new version of an application to a server and prepare a rollback plan that quickly returns to the old version if something goes wrong.
Package docs for offline use and verify their integrity: You package documents for an environment without internet and prove with checksums (file fingerprints) that nothing changed on the way.
Turn a raw export into a report (awk, sed): You clean up a messy raw data export with awk and sed and turn it into a short report a manager can read.
Continue a long job from another terminal (tmux): You start a job that runs for hours inside tmux and show it keeps running if the connection drops and can be reattached from another terminal.
A batch script: run in parallel, collect failures: You write a script that processes many files at the same time and gathers the ones that failed into a separate summary list.
A check that catches a broken release before it ships: You write an automatic check that catches a broken release before users get it, and show it stops a deliberately broken version.
Alert when users cannot reach the service: You set up a check that raises an alert when users cannot reach a service, and prove it fires by switching the service off in the lab.
Automate the daily report (cron, systemd timer): You make a report that is prepared by hand every day run automatically with cron or a systemd timer, and show it is produced on time.
Repair a broken download and verify its checksum: You repair a half-finished or damaged download and prove the file is correct when its checksum (file fingerprint) matches the published one.
Build a login audit report from the auth logs: You filter one month of prepared login records from the student server of Saklıvadi Üniversitesi with grep, sed and awk. You produce an audit report that summarises failed attempts by account, source and hour.
Give the help desk limited rights: sudoers and ACLs: You give the help desk team of Lavinya Klinikleri the right to restart only certain services and read only certain folders. You build it with sudoers rules and ACLs (file access lists) and show with tests that no extra rights remain.
A virtual machine template for the test team (KVM, libvirt): You build a virtual machine with KVM and libvirt for the test team of Göktaşı Yazılım, take a snapshot and derive two clones from it. You show the clones start under their own names and that the snapshot can be restored.
A server inventory report with PowerShell: You write a PowerShell module that collects disk, memory, running service and user details for the store servers of Turnalı Perakende. The module handles errors and outputs the result as CSV and JSON.
Rescue a server that will not boot: You find out why a Linux server will not start, repair it from a rescue environment, and show that it boots normally again.
Web server deployment and a disaster recovery plan: You set up a web server, write down its backup and recovery steps, then rebuild it from scratch to prove the plan really works.
Observability: metrics, logs and alerts: You build a small monitoring setup that collects measurements (metrics), records (logs) and alerts for a service, and show that a fault triggers an alert.
Trace a failed request across two services: You follow one user's failed request through the logs of two services step by step and write a note explaining which service the problem started in.
Try a new release on a small share of traffic: You expose a new release to a small share of traffic first, watch the results, and give a reasoned decision on whether to roll it out to everyone.
Build encrypted, redundant storage: RAID, LUKS and LVM: On the archive server of Yelkovan Bankası you mirror two disks (RAID 1), encrypt the result with LUKS and divide it with LVM. You deliberately fail one disk to show the data stays available and that a volume can be grown while in use.
An internal package repository with version pinning: You build a signed internal package repository for the servers of Demirsu Enerji that have no internet access and point two clients at it. You pin the version of a critical package and show the clients install only the approved version.
Collect server logs in one place (rsyslog over TLS): You send the logs of two servers of Selvikent Belediyesi to a central rsyslog server over an encrypted connection (TLS). You write them to per-host files, set rotation and retention, and show that a host going silent is noticed.
Move a legacy application to systemd units: You move the hand-started order application of Ayçiçeği Gıda to systemd units: a service, its dependencies, socket activation (start on first connection) and a timer for nightly maintenance. You show it restarts by itself after a crash and comes up in the right order.
Backups that cannot be deleted: restic and a restore drill: You back up the design server of Karaçam Mobilya with restic, encrypted, to a separate backup server. You set a retention rule and an append-only (undeletable) repository, then delete a folder and time its restore from backup.
Investigate a slow server: CPU, memory and disk: The production tracking server of Ilgıntepe Tekstil slows down every afternoon. You use measurement tools to find whether the bottleneck is CPU, memory or disk, fix the setting, and write a performance report with before-and-after measurements.
Plan and run a patch window for a mixed server fleet: You plan a patch window for the Debian and Rocky Linux fleet of Yakamoz Telekom: a pilot group first, then the rest, with a health check and a way back at every step. You run the plan and deliver a report showing which server moved to which version.
Set up central login for servers: LDAP and SSSD: You connect two servers of Lodoskaya Denizcilik to the central directory (LDAP) and set up login through SSSD with sudo rights by group. You show that cached login keeps working while the directory is unreachable and that an account disabled in the directory can no longer log in.
A service objective, alert rules and an on-call runbook: You define a service level objective (SLO) for the parcel tracking service of Kuzeyyıldızı Kargo and build the alert rules and Alertmanager routing that follow from it. During a prepared fault you show the alert reaches the right person, then write the on-call runbook and the post-incident review.
Nginx for campaign day: load balancing, caching and rate limiting: You place Nginx in front of three backend servers for the campaign site of Turnalı Perakende and configure load balancing, caching and request rate limiting. With a load test you show the site keeps working when one backend stops and that a client sending too many requests is limited.
Limit and isolate services on a shared host (systemd, cgroups): You put memory, CPU and I/O limits on three services sharing one server of Mercanköşk Otelcilik with systemd and tighten each with sandboxing settings. With before-and-after measurements you show the others are unaffected when one service tries to use everything, and that the security score improves.
Recover data from damaged disk images: You work on damaged disk images taken from the failed file server of Sedirli Hukuk Bürosu. You copy the image first, repair the file system and LVM metadata damage, and write a recovery report listing the files that were and were not recovered.
Package an in-house tool as .deb and .rpm: You turn the monitoring tool of Göktaşı Yazılım, until now distributed by copying files, into both a .deb and an .rpm package. The package carries the service unit, the configuration file and the removal steps, passes the lint tools without warnings, and installs and removes cleanly on a fresh system.
Find the root cause of a service that hangs now and then: The reconciliation service of Yelkovan Bankası stops responding a few times a day and recovers after a restart. You find the root cause with /proc, strace and the system logs, apply a lasting fix and write a post-incident report backed by evidence.