Table of Contents
Overview
Part IV is about going beyond daily usage and basic administration into the skills that let you customize, automate, debug, and deeply understand Linux systems. You’ll connect what you already know (shell, services, filesystems, networking) and start using it the way power users, SREs, and senior admins do.
This part assumes you are comfortable with:
- Navigating the shell and writing very simple scripts
- Managing packages and services at a basic level
- Understanding users, permissions, partitions, and basic networking
You do not need to be an expert already; the goal of this part is to bridge the gap between “I can manage a Linux system” and “I can shape, debug, and extend a Linux system.”
Part IV is structured into the following major topics:
- Advanced Shell Scripting
- The Linux Boot Process
- Kernel Management
- Advanced Filesystems and Storage
- Network Services
- Logging and Auditing
- Virtualization and Containers
Each of these topics has its own chapter; here we’ll explain what you should expect to gain from each and how they fit together.
Learning Goals for Part IV
By the end of this part, you should be able to:
- Design non-trivial shell scripts that are robust, maintainable, and automated.
- Understand what happens from power-on to login, and troubleshoot common boot problems.
- Reason about kernel versions, modules, and parameters, and make safe configuration changes.
- Plan and manage more sophisticated storage layouts (LVM, RAID, encryption, snapshots).
- Operate common network services and understand their role in infrastructure.
- Build logging and auditing setups that support debugging, compliance, and incident response.
- Use virtualization and container technologies to isolate workloads and build modern environments.
You are moving from “knowing commands” to “knowing how the system is put together and controlled.”
How the Chapters in Part IV Fit Together
Advanced Shell Scripting
You’ve already met shell scripting and basic constructs. In this part you focus on:
- Structuring larger scripts with clear entry points
- Reusing code with functions and libraries
- Handling errors and exit codes systematically
- Debugging scripts and tracing their behavior
- Scheduling scripts with
cronand related tools
This chapter turns ad-hoc one-liners into reliable tools. The skills here are directly reusable later when you automate backups, monitoring, log handling, or deployment tasks.
The Linux Boot Process
Earlier, you learned to install Linux and troubleshoot basic issues. Here you learn how the system actually boots:
- How firmware passes control to the bootloader
- What GRUB2 does with kernel and initramfs
- How the kernel hands off to
init/systemd - How to reason about and fix boot problems
This understanding is essential if a server suddenly fails to reach a login prompt, if you need to adjust kernel parameters for performance or debugging, or if you’re working with disk encryption and complex storage layouts.
Kernel Management
You already know what the kernel is conceptually. Now you:
- Work with kernel modules: load, unload, query
- Adjust kernel parameters at runtime and persistently
- Understand kernel versioning and compatibility
- Learn the workflow for building or installing custom kernels
You rarely need to compile a kernel in everyday operations, but knowing how modules and parameters work lets you enable features, tweak performance, and diagnose low-level issues.
Advanced Filesystems and Storage
Basic partitions and filesystems are enough for desktops and simple servers. More complex environments need:
- Flexible resizing and allocation using LVM
- Redundancy and performance tuning with RAID
- Full-disk or partition-level encryption with LUKS
- Snapshotting and rollback strategies
This chapter is about designing storage that is resilient and adaptable, not just “making a partition and formatting it.”
Network Services
Earlier, you saw fundamental networking commands and basic firewall ideas. Here you step up to running services that other machines rely on:
- Secure shell access with an SSH server
- Sharing files over NFS or Samba
- Providing classic file-transfer services via FTP/SFTP
- Building and hardening firewall rulesets
You’re no longer only a user of network services; you become the person who deploys and maintains them in a networked environment.
Logging and Auditing
System logs were introduced earlier, and you used journalctl and /var/log at a basic level. This chapter focuses on:
- How logging is structured in modern Linux (systemd journals and traditional logs)
- Using auditing frameworks (e.g., auditd) to track security-relevant events
- Rotating, retaining, and organizing logs for long-term use
- Creating custom logs for your own applications and scripts
These skills are essential for compliance, security, forensics, and serious troubleshooting.
Virtualization and Containers
You have used virtual machines in earlier parts to test Linux. Now you focus on running them and containers as infrastructure:
- Creating and managing full virtual machines with KVM/QEMU
- Using system-level containers (LXC/LXD) and application containers (Docker, Podman)
- Understanding container images, registries, and networking
- Knowing when to choose VM, container, or bare metal
This is foundational for DevOps, cloud computing, and modern deployment practices, and it prepares you for the DevOps and Cloud part of the course.
Prerequisites and Recommended Practice
Before starting Part IV, you’ll get the most out of it if you:
- Are comfortable working in a terminal for most tasks
- Can install packages and manage system services without step-by-step instructions
- Have a test machine or a set of virtual machines where breaking things is acceptable
As you progress, it helps to:
- Keep a “lab notebook” of commands, configuration snippets, and gotchas.
- Deliberately create small “failures” (e.g., misconfigured services, broken boot entries) and practice fixing them.
- Reuse and extend your previous scripts and configurations instead of always starting from scratch.
How Part IV Connects to Later Parts
The skills developed here underpin the remaining, more specialized parts:
- Server Administration depends on your understanding of services, storage, logging, and networking at the level introduced in Part IV.
- DevOps and Cloud assumes you are comfortable with scripting, containers, and kernel/boot basics so you can reason about CI/CD, automation, and cloud infrastructure.
- Master Topics (hardening, forensics, performance tuning) require you to already know how to read logs, manage the kernel, and interpret the system’s behavior.
In other words, Part IV is the “general advanced toolkit” that you’ll reuse in every specialization that follows.