linux

Linux, the operating system

You can drive the shell — now learn the system under it: how Linux boots, runs services, manages users and storage, and how to keep it alive when it breaks.

12 units·46 lessons·~16 h

Start track →

What is Linux

"Linux" is a kernel plus a userland assembled by a distribution. The kernel owns the hardware and the syscall boundary; everything above it — including the system's own state — is a file you can read.

01 Kernel and userland 20 min 02 Distributions 19 min 03 The filesystem hierarchy 21 min 04 procfs and sysfs 22 min

Boot and init

A Linux box boots in a chain: firmware → bootloader → kernel → initramfs → PID 1. PID 1 (systemd) then brings the system up to a target. Understanding that chain is exactly how you fix a machine that won't boot.

01 The boot sequence 20 min 02 GRUB — the bootloader 22 min 03 PID 1 and init 22 min 04 Targets and runlevels 20 min

systemd and services

systemd models the whole system as units with explicit dependencies. systemctl is how you start, enable, and inspect them — and a unit file is how you turn your own process into a first-class, supervised service.

01 Units and systemctl 20 min 02 Writing a service unit file 22 min 03 Dependencies and ordering 22 min 04 Socket activation and custom targets 24 min

Package management

A package manager turns 'I want nginx' into a resolved, versioned, removable set of files plus dependencies. apt is the front-end, dpkg is the engine — and every distro family has the same two layers.

01 apt and repositories 20 min 02 dpkg internals 22 min 03 Dependencies, holds, and pinning 22 min 04 dnf and the RHEL side 20 min

Users, groups, PAM

Identity on Linux is UID/GID stored in passwd and shadow. Permissions go past plain rwx — setuid, setgid, sticky, ACLs — and sudo plus PAM are the policy layer that decides who may become whom.

01 passwd and shadow 20 min 02 permissions deeper 22 min 03 sudo and privilege 20 min 04 PAM and login 24 min

Filesystems and mounts

A block device holds a filesystem; mounting grafts that filesystem into the single directory tree at a path. fstab makes mounts survive a reboot — and one bad fstab line is a classic way to lock yourself out at boot.

01 Block devices and partitions 20 min 02 Filesystems 22 min 03 Mounting 22 min 04 fstab and boot mounts 22 min

Storage and LVM

LVM inserts a layer between disks and filesystems so you can grow, snapshot, and span volumes without repartitioning. RAID adds redundancy — and the senior skill is recovering a degraded array without losing data.

01 Why LVM 20 min 02 Growing LVs and LVM snapshots 22 min 03 RAID basics with mdadm 22 min 04 Disk failure and RAID recovery 24 min

Processes and resources

A process is a fork/exec lineage the kernel schedules and accounts. Signals are how you talk to it, cgroups and rlimits are how you cap it, and the OOM killer is what happens when you don't.

01 Process lifecycle 20 min 02 Signals — deeper 20 min 03 cgroups and resource limits 22 min 04 The OOM killer 22 min

Networking

A host's network is interfaces, a routing table, and a name-resolution path. The modern ip/ss suite inspects them, and nftables/firewalld is the kernel packet filter you configure — protocol theory lives in the networking track.

01 Interfaces and ip 20 min 02 Routing 20 min 03 DNS resolution 20 min 04 Firewalls and nftables 22 min

Logs and journald

journald is the system's structured log store; journalctl queries it by unit, time, and priority. Persistent journals and logrotate keep history bounded — and reading a failure backwards from the logs is the core operator skill.

01 journald and journalctl 20 min 02 Persistent journals and log rotation 22 min 03 Syslog and rsyslog 22 min 04 Reading a failure from the logs 24 min

Scheduling

Recurring work runs under cron or systemd timers. cron is the portable classic; timers are the systemd-native option with better logging and dependency handling — and 'why didn't my job run?' is a debugging skill of its own.

01 cron and crontab 20 min 02 systemd timers 22 min 03 Choosing between cron and timers, and debugging missed jobs 24 min

Kernel tuning

The kernel exposes thousands of tunables through sysctl and loads hardware and feature support as modules. Namespaces and cgroups are the same primitives containers are built from — which is exactly where the Docker track picks up.

01 Kernel parameters with sysctl 20 min 02 Kernel modules — loading, inspecting, and blacklisting 20 min 03 Namespaces and cgroups — the container primitives 24 min

Build with this track

Guided projects that exercise what you learn here.

◆ Projects

A Service systemd Trusts

Anyone can write a script that runs. The job is to make it a service the operating system will keep alive, restart sanely, log honestly, and box in when it misbehaves. You take a small daemon from 'works when I run it in my terminal' to a real systemd unit — started at boot, watched by PID 1, its logs in journald, its blast radius capped. This is the difference between code and a service.

Next track

Architecture Patterns

How to structure an application so it survives change — coupling and cohesion, dependency direction, hexagonal and clean architecture, DDD, CQRS, event sourcing, and decomposing a monolith without building a distributed one.