CompTIA Linux+

A system that will not boot is the hardest to fix. You follow startup from firmware to login, manage the kernel and its modules, and see how devices are detected and exposed to programs.

• UEFI, BIOS and the bootloader
• The initial RAM disk and kernel startup
• systemd targets and boot messages
• Kernel modules and parameters
• The /proc and /sys file systems
• Device detection with udev

You build A documented boot sequence for one machine, with a recovery step for a broken bootloader.

Disks fill, fail and need resizing. You partition drives, build file systems, mount them persistently, and use logical volumes and software RAID so storage can change without downtime.

• Partition tables and partitioning tools
• ext4 and XFS file systems
• Mounting and the fstab file
• LVM: volumes, groups and resizing
• Software RAID with mdadm
• Quotas and checking disk usage

You build A logical volume layout that you grow online and test with a simulated failed disk.

A server is useful only when it can be reached. You configure interfaces, routes and name resolution, inspect connections, and combine links for redundancy using the tools current distributions provide.

• Interfaces and addresses with the ip command
• Persistent configuration with NetworkManager and files
• Routing tables and default gateways
• DNS resolver settings and hostnames
• Bonding and bridging
• Inspecting sockets and open ports

You build A server configured with a static address, bonded links and a routing change you can verify.

Linux runs on virtual machines more often than on hardware. You back up and restore data with standard tools, run guests under KVM, and prepare images that configure themselves on first boot.

• Archiving and compressing with tar
• Synchronizing data with rsync
• Snapshots and backup strategy
• KVM and libvirt basics
• Cloud images and first-boot configuration
• Verifying a restore

You build A scripted backup with a tested restore, plus a virtual machine launched from a prepared image.

Permissions decide who can read, change or run anything. You manage accounts and groups, set and reason about file modes, use special bits and access control lists, and delegate administration with sudo.

• Creating and managing users and groups
• File modes, ownership and umask
• Setuid, setgid and the sticky bit
• Access control lists
• sudo and the sudoers file
• Shells, profiles and default environments

You build A shared project directory with group permissions, ACL exceptions and a sudo rule.

Software has to be installed, started and watched. You manage processes and priorities, install and update packages from repositories, and write and control services and scheduled jobs under systemd.

• Viewing, signaling and prioritizing processes
• Package managers: rpm, dpkg, dnf and apt
• Repositories and package signing
• Writing and managing systemd units
• Timers and cron jobs
• Logging with journald and syslog

You build A custom systemd service and timer, with logging you can search.

Containers package an application with what it needs. You pull, run and build images, manage storage and networking for containers, and learn where they are better than a virtual machine and where they are not.

• Images, containers and registries
• Running and inspecting containers
• Building an image from a definition file
• Volumes and persistent data
• Container networking and published ports
• Rootless containers and resource limits

You build A container image for a small service, with persistent data and a published port.

Logging in is the main way into a Linux host. You configure pluggable authentication, connect to central directories, secure SSH with keys, and record activity with logs and the audit framework.

• PAM modules and the stack order
• LDAP and SSSD for central accounts
• SSH keys, agents and daemon settings
• Password aging and account lockout
• The audit framework and rules
• Reading authentication logs

You build An SSH and PAM configuration that requires keys, locks out guessing and logs each login.

A host must defend itself. You write firewall rules, enforce mandatory access control, harden services and kernel settings, protect data with encryption and certificates, and check a host against a benchmark.

• Firewall tools: nftables, firewalld and others
• SELinux and AppArmor modes and policy
• Disabling services and hardening the kernel
• Disk encryption with LUKS
• Keys, certificates and GPG with OpenSSL
• Compliance scanning against benchmarks

You build A hardened host that passes a benchmark scan, with firewall rules and SELinux decisions explained.

Anything done twice deserves a script. You write dependable shell scripts with variables, conditions, loops and functions, use Python for tasks that outgrow them, and review code from AI assistants before you trust it.

• Variables, quoting and exit codes
• Conditions, loops and functions in bash
• Arguments, input and error handling
• Python for files, processes and APIs
• Reviewing AI-generated code before running it
• Packaging and scheduling scripts

You build A script that audits user accounts and permissions and writes a dated report.

Configuration belongs in version control. You use Git branches and merges, write Ansible inventories and playbooks that can run repeatedly without harm, and see how pipelines apply them automatically.

• Git workflow: commit, branch, merge and resolve
• Remote repositories and pull requests
• Ansible inventories and ad hoc commands
• Playbooks, roles and idempotence
• Templates, variables and secrets
• Running automation from a pipeline

You build An Ansible role in Git that configures a web server identically on three hosts.

Faults show up as symptoms, and logs explain them. You monitor system health, read logs, and work methodically through boot, mount, network, permission, security-policy and performance problems.

• journalctl, dmesg and log files
• Boot failures and rescue mode
• Mount, file system and disk errors
• Network and name resolution faults
• SELinux denials and permission failures
• CPU, memory and I/O bottlenecks
• Monitoring with vmstat, iostat and sar

You build A runbook that lists symptom, command, likely cause and fix for twelve common faults.

One project joins every skill. You provision a server, secure it, deploy a service in a container, automate its configuration, back it up and diagnose a fault that is introduced afterwards.

• Provisioning and storage layout
• Hardening and access control
• Deploying the service and its container
• Automating with Git and Ansible
• Backup, monitoring and a fault drill

You build A running service built from code, hardened, automated, backed up and documented.