Linux Administration Course — Start Here and Lesson Index

Learn Linux from your first terminal session through server administration and recovery. The 33 numbered lessons use examples and topics from the Open Education archive, with new labs where the older examples need updating or the topic is missing.

AI disclosure — AI-generated content, posted as is. AI can make mistakes. The lessons link to original Open Education articles and identify related background for new topics. The newly written explanations and lab examples may be freely reused. Linked source material retains its own terms.

How to work through the course

  1. Start with Basics 01 if you are new to the shell. If you already know navigation, permissions, and pipes, try the Basics assessments before moving on.
  2. Run the worked example and compare your results to the possible output. Paths, versions, process IDs, timestamps, and log formatting may differ.
  3. Answer the questions-only section before reading the repeated questions with answers. Keep short notes on the test, evidence, and outcome of each lab.
  4. Use disposable virtual machines and snapshots for administration exercises. Keep DNS, DHCP, and other service labs on the specified isolated segment rather than your normal network.
  5. Suggested pacing is two or three lessons per week, with extra lab time for networking, storage, and the capstone.

Linux Basics — 8 lessons

Start with the terminal and end by recovering a file from an archive. No administrator privileges are needed for the Basics exercises. Browse the category.

  1. Linux, the Shell, and Your First Lab — Tell the kernel, distribution, terminal, and shell apart, then identify the system you are actually using.
  2. Paths, Files, and Links — Navigate confidently, copy and rename a file, and explain the difference between hard links and symbolic links.
  3. Editing Text and Reading Files — Edit a text file in a terminal and verify the exact lines you saved.
  4. Pipes, Redirection, and Exit Status — Route input, normal output, and errors, then detect a command failure inside a pipeline.
  5. Finding Files and Filtering Text — Choose find for names, grep for lines, cut for fields, and sed for transforming text.
  6. File Permissions and umask — Read a permission string, predict umask results, and choose a minimal permission change.
  7. Processes, Jobs, and Signals — Identify a process you own, inspect its state, and stop it gracefully.
  8. Archives, Compression, and a Restore Test — Create and inspect an archive, then prove that you can recover a file from it.

Linux Intermediate — 9 lessons

Write and debug Bash, manage access without broad permissions, and diagnose services, networks, remote access, and mounted storage. Browse the category.

  1. Users, Groups, sudo, and Special Permissions — Inspect identity records, understand sudo, and build a group-inheriting directory in a disposable VM.
  2. Access Control Lists and Shared Directories — Grant and remove a narrowly scoped named-user ACL and distinguish a grant from effective access.
  3. Bash Variables, Quoting, and Input — Write Bash variables, capture a command result, and accept input without losing spaces or misinterpreting nonnumeric input.
  4. Bash Conditions, Loops, Functions, and Debugging — Use a case statement, a function, and a loop to generate a multiplication chart and test invalid input.
  5. Package Managers and Repositories — Inspect installed packages and repositories before taking action, and tell a package database from a dependency resolver.
  6. Boot, Services, Logs, and Timers — Trace the boot-to-service path, inspect logs, and create a timer that runs a tiny user service.
  7. IP Addresses, Routes, and Name Resolution — Separate the problems of link state, addressing, routing, name resolution, and listening services.
  8. SSH Keys, Host Identity, and File Transfer — Verify an SSH host’s identity, use a passphrase-protected key, and transfer a non-sensitive file.
  9. Block Devices, Filesystems, and Mounts — Distinguish a block device from a filesystem and a mount point, and inspect each layer without changing it.

Linux Advanced — 9 lessons

Build and verify Linux server features in a disposable VM. Use the Ubuntu or Red Hat-family lab identified in each lesson. Browse the category.

  1. LVM and Controlled Filesystem Growth — Create and expand an isolated LVM stack without touching the system disk.
  2. NFS and On-Demand Mounting with AutoFS — Create an indirect AutoFS map and distinguish a running automounter from a successful NFS mount.
  3. SELinux Contexts, Booleans, and Denials — Diagnose ordinary permission and SELinux policy problems separately and set a persistent file context.
  4. Firewall Zones and Runtime Rules — Identify the active zone and compare a timed runtime firewall rule with permanent policy.
  5. Authoritative DNS with BIND — Build an authoritative forward zone and distinguish an authoritative answer, NXDOMAIN, and no response.
  6. DHCP Leases and a Kea Lab — Validate a Kea DHCPv4 pool and verify a lease issued to a VM on an isolated segment.
  7. Time Synchronization with chrony — Distinguish clock display from synchronization and show whether chrony selected a source.
  8. Apache Virtual Hosts and HTTPS — Test Apache name-based routing locally and verify HTTPS with certificate and renewal checks.
  9. MariaDB Service Accounts and Restore Verification — Check a Linux-hosted MariaDB service, identify least-privilege database roles, and test a logical restore.

Linux Advanced 2 — 7 lessons

Extend the archive with modern tools and a capstone. Work through isolation, repeatability, performance, and recovery before running the final incident drill. Browse the category.

  1. Hardening a systemd Service — Run a small systemd service with a dedicated dynamic identity and a narrow writable directory.
  2. Rootless Containers with Podman — Serve a fixture with rootless Podman and verify that its port is published only on loopback.
  3. Repeatable Configuration with Ansible — Convert a small configuration task into an Ansible playbook and demonstrate idempotence.
  4. Performance Triage with vmstat and PSI — Use related signals to decide whether to investigate CPU, memory, disk I/O, or an application bottleneck.
  5. Kernel Modules and Resource Limits — Read kernel module information and identify the current process’s resource-control group without changing the kernel.
  6. Encrypted Backups and Restore Drills — Create an encrypted Restic snapshot and verify a real restore into a separate directory.
  7. Capstone: Build, Diagnose, and Recover a Linux Service — Demonstrate Linux service deployment, evidence-led incident diagnosis, and recovery in one lab.

Explore the source archive

The new series groups older posts by learning level. Original posts and their categories remain unchanged. The archive includes English and Bengali material, historical command logs, and some cross-posted versions. Follow the source links inside each lesson for the examples most relevant to that topic.

Leave a Reply