Linux Level 2 – Engineering

This course develops operational Linux engineering skills: understanding the boot process in detail, systemd and journald, hardware discovery, interface configuration, storage layering, LVM, mounting, and remote filesystems.

Course purpose

Build practical Linux engineering capability so learners can inspect, configure and troubleshoot hosts with confidence, especially around boot, services, logging, networking, storage and mount-related failures.

Duration

2 days

Target audience

infrastructure engineers
systems administrators
virtualisation/storage engineers
support staff who need to troubleshoot Linux hosts

Prerequisites

Linux Foundations or equivalent experience
confidence with shell basics
basic understanding of storage and networking

Learning outcomes

explain the Linux boot process in operational detail
use systemd, journalctl, udev and hardware discovery tools for troubleshooting
configure and inspect network interfaces and common host networking models
understand SSH and SFTP, including password, key-based and certificate-based authentication models
explain Linux storage layering from physical device to mount point
work with LVM concepts and basic LVM recovery
configure local and remote mounts safely
troubleshoot fstab problems and recover from mount-related boot issues
distinguish between local block, local filesystem and remote/network storage

Detailed module structure

Module 1: Boot process in depth

Topics:

firmware and boot mode awareness
GRUB or other bootloader role
kernel loading
initramfs role
handoff to systemd
targets and unit activation
where boot commonly fails
reading boot-time messages and state

Positioning: this is the deeper engineering version of the foundations boot module.

Module 2: systemd and service management

Topics:

units and unit types
targets
enabling and disabling services
start, stop, restart and reload
dependencies and ordering
reading service state
common troubleshooting workflow

Useful commands:

systemctl
journalctl

Module 3: Journald and logging

Topics:

system log flow
persistent vs volatile journals
filtering logs by boot, unit, time and priority
identifying storage, network and service failures
when to look at the journal vs other logs in /var/log

Module 4: udev, hardware discovery and the Linux device model

Topics:

device discovery
persistent naming
how hardware appears in Linux
/dev, /sys and /proc
why hardware is a file is useful, and where that concept is true vs simplified
hardware inventory and inspection tools:
- lspci
- lsusb
- lsblk
- blkid
- dmidecode if appropriate
- udevadm

Module 5: Local networking on Linux

Topics:

interface naming
link state
IP configuration
routing table basics
DNS resolver basics
bridges
bonding
VLANs at a high level
persistent config approaches:
- Debian-style /etc/network/interfaces
- NetworkManager
temporary vs persistent changes
SSH service basics and secure remote administration
SFTP as an SSH subsystem for file transfer
authentication methods:
- password authentication
- public key authentication
- certificate-based authentication at a high level
when password and key-based access may coexist, and how to reason about both safely

Important framing: networking concepts are common, but configuration method is distro-specific.

Module 6: Storage architecture and filesystems

Topics:

block devices
partitions
filesystems
mount points
device mapper
/dev/mapper
UUIDs and labels
ext4 vs xfs operationally
swap
inspection tools:
- lsblk
- blkid
- mount
- findmnt
- df
- du

Module 7: LVM engineering

Topics:

physical volumes, volume groups and logical volumes
PV → VG → LV structure
device-mapper relationships
how LVM fits between disk and filesystem
standard naming conventions
thin provisioning awareness at a high level
operational inspection:
- pvs
- vgs
- lvs
activation and deactivation basics
basic recovery with scanning and activation concepts such as vgchange

Module 8: Mounting and /etc/fstab

Topics:

manual mounts
persistent mounts
fstab field-by-field
mount options
UUID vs device path
failure impact at boot
dependency on remote storage
testing fstab safely before reboot

Module 9: Emergency mode and mount failures

Topics:

what emergency mode is
common causes
broken fstab
missing disks
failed remote mounts
recovery workflow
validating the fix before returning to service

Module 10: Remote filesystems and storage access

Topics:

SMB/CIFS
NFS
iSCSI
file-level vs block-level remote storage
authentication basics
mount and persistence concepts
use cases and limitations
operational differences between:
- remote filesystem
- remote block device
- clustered/distributed storage

Useful framing: explain what each storage type is, what it is not, and where it fits operationally.

Module 11: Package management, naming and time services

Topics:

package management and repositories
why Linux engineers need to install, verify and update tools safely
hostname and name resolution basics
how naming affects services, clustering and mounts
time sync and NTP basics
why time drift causes operational problems, especially in distributed systems

Labs

inspect the current boot chain and service state
troubleshoot a failed service using systemctl and journalctl
identify hardware with lspci, lsblk and udevadm
configure an interface or bridge
test SSH access and compare password, key-based and certificate-based authentication at a practical level
inspect SFTP behaviour as an SSH subsystem
inspect and build an LVM stack
break and repair an fstab entry
mount an NFS share
connect and inspect an iSCSI device
recover a VG that is not active

Assessment

Practical engineering exercise

inspect boot and service state
interpret journal output for a failed service or mount
identify storage layers from device to filesystem to mount point
explain the next safe action in an fstab or LVM issue

Troubleshooting scenario

Diagnose a host that fails to mount storage correctly at boot, explain the likely cause, and outline a safe recovery workflow.

Stronger Linux troubleshooting - Better storage understanding - Safer host engineering

Designed for engineers who need to work confidently below the surface of day-one Linux administration

Training scope and tailoring

The training plan shown above is provided as a structured guide to the typical scope and direction of the course. Our training content is reviewed and refined over time, so the precise balance of modules, examples and exercises may vary when the course is delivered.

Where there are specific topics, technologies or operational outcomes that are particularly important to your team, these can normally be incorporated into the delivery plan by prior agreement. Training is not treated as a rigid, fixed package; it is adapted where appropriate to reflect the client environment, delegate experience level, group size and the objectives agreed in advance.