Linux

You can navigate the Linux directory hierarchy, open a terminal, and run your first command-line utilities with confidence.

1. What Linux is: the kernel, distributions and open source90 min
   • Linux kernel architecture
   • GNU userland utilities
   • Distributions: Ubuntu, Debian, Red Hat
   • Open source licensing model
2. Installing Linux: virtual machines, WSL and the cloud90 min
   • VirtualBox and hypervisors
   • Windows Subsystem for Linux (WSL2)
   • Cloud instance initialization
   • Basic terminal configuration
3. The shell, the terminal and your first commands90 min
   • Prompt anatomy and terminal emulators
   • echo, pwd, date, and history
   • Command syntax, flags, and arguments
   • Keyboard shortcuts for terminal navigation
4. Navigating files and directories90 min
   • cd, ls, and absolute paths
   • Relative paths and shorthand (., .., ~)
   • mkdir, rmdir, and rm -rf precautions
   • Directory tree traversal patterns
5. Getting help: man, --help and info90 min
   • man page sections and navigation
   • --help usage for quick flags
   • apropos for searching command descriptions
   • info command documentation structure

Hands-on project: Provision a local Linux virtual machine or WSL instance, explore the root directory structure, and use man pages to inspect core utilities.

You can create, link, edit, and search through files across the Linux filesystem hierarchy.

1. The Linux Filesystem Hierarchy (FHS)90 min
   • /etc, /var, /bin, /usr directories
   • /tmp, /home, and /root layout
   • Virtual filesystems (/proc and /sys)
   • Mount points and file tree mounting
2. Creating, copying, moving and removing files90 min
   • touch and cat for file creation
   • cp recursive and interactive flags
   • mv for moving and renaming
   • Safe deletion practices
3. Viewing and editing files: cat, less, nano and vim basics90 min
   • head, tail, and less paging
   • nano editor shortcuts
   • Vim insert, normal, and command modes
   • Vim saving, quitting, and basic text manipulation
4. Hard links and symbolic links90 min
   • Inodes and directory entries
   • ln for hard links
   • ln -s for symbolic links
   • Resolving broken symlinks
5. Finding files: find, locate and which90 min
   • find with -name, -type, and -size
   • Executing commands on find results with -exec
   • locate database updates with updatedb
   • which and type for executable paths

Hands-on project: Organize a messy directory structure according to the FHS, create hard and symbolic links, and locate files using find and grep.

You can manage local users and groups, configure file permissions, and secure privileged access using sudo.

1. Users, groups and the /etc/passwd and /etc/group files90 min
   • useradd, usermod, and userdel
   • groupadd and groupmod
   • /etc/passwd, /etc/shadow, and /etc/group formats
   • UIDs, GIDs, and primary vs secondary groups
2. File permissions: read, write and execute (chmod)90 min
   • Symbolic permission notation (u+rwx)
   • Numeric permission notation (octal 755)
   • Default umask configuration
   • Recursive permission changes
3. Ownership with chown and chgrp90 min
   • chown user:group syntax
   • Recursive ownership updates
   • Transferring file ownership safely
   • Troubleshooting permission denied errors
4. Special permissions: setuid, setgid and the sticky bit90 min
   • setuid on executables like passwd
   • setgid on shared project directories
   • Sticky bit on /tmp to prevent unlinking
   • Numeric representation of special bits
5. sudo and privilege escalation90 min
   • /etc/sudoers file editing with visudo
   • Granting specific command privileges
   • Switching users with su and sudo -i
   • Auditing sudo access logs

Hands-on project: Configure a multi-user server environment with specific group access controls, restricted file permissions, and audited sudoers privileges.

You can filter, transform, and extract data from log files and streams using pipes, regular expressions, sed, and awk.

1. Standard input, output and error; redirection90 min
   • File descriptors (stdin 0, stdout 1, stderr 2)
   • Redirection operators (> and >>)
   • Redirecting stderr with 2>&1
   • Here documents (<<) and here strings
2. Pipes and chaining commands together90 min
   • The pipe operator (|)
   • Connecting multiple filters
   • tee for splitting streams to files
   • Command chaining with &&, ||, and ;
3. grep and regular expressions90 min
   • Basic vs extended regular expressions
   • Anchors (^, $) and character classes
   • Quantifiers (*, +, ?)
   • Recursive grep with -r and line numbers with -n
4. Transforming text with sed and awk90 min
   • sed stream substitution (s/old/new/g)
   • In-place editing with sed -i
   • awk field separators and printing columns
   • awk conditional filtering and pattern matching
5. sort, cut, uniq, wc and tr90 min
   • sort numeric and reverse order
   • cut fields by delimiter
   • uniq counting and duplicate filtering
   • wc word and line counting

Hands-on project: Write a pipeline command to parse a raw web server access log, extract error codes, and format a summary report.

You can inspect running processes, control job execution, send signals, and monitor CPU, memory, and disk utilization.

1. Processes, PIDs and the process tree90 min
   • Process lifecycle and states
   • Init process (PID 1) and parenting
   • ps command flags and process tree view (pstree)
   • Orphan and zombie processes
2. Foreground, background and job control90 min
   • Running tasks in background (&)
   • Suspending jobs with Ctrl+Z
   • jobs, fg, and bg commands
   • Persistent background execution with nohup
3. ps, top, htop and kill90 min
   • ps aux output analysis
   • Interactive process management in top
   • htop color interface and filtering
   • kill command syntax
4. Signals and process priority (nice and renice)90 min
   • SIGTERM vs SIGKILL (signals 15 and 9)
   • SIGHUP for configuration reloads
   • CPU scheduling priority with nice
   • Modifying running process priority with renice
5. Monitoring CPU, memory and disk usage90 min
   • free -h for RAM and swap usage
   • df -h and du -sh for disk utilization
   • vmstat and iostat for performance diagnostics
   • uptime and load average interpretation

Hands-on project: Identify a resource-leaking runaway process on a test server, adjust its priority using nice, and terminate it cleanly with appropriate signals.

You can install, update, and remove software packages across Debian and Red Hat systems while managing repositories and dependencies.

1. Package managers: APT (Debian/Ubuntu) and DNF/YUM (RHEL)90 min
   • APT package cache and lists
   • DNF transaction history and rollback
   • DEB vs RPM package formats
   • Repository configuration files in /etc/apt/sources.list.d
2. Installing, updating and removing packages90 min
   • apt update and apt upgrade
   • dnf install and dnf remove
   • Purging configuration files with apt purge
   • Cleaning local package caches
3. Repositories and dependency management90 min
   • Adding GPG keys for signed repositories
   • PPA repositories on Ubuntu
   • Resolving dependency conflicts
   • Holding packages at specific versions
4. Compiling software from source (overview)90 min
   • Build essentials and compiler toolchains
   • configure script execution
   • make and make install workflow
   • Limitations of unmanaged source installations
5. Snap and Flatpak90 min
   • Containerized package formats
   • Installing applications via snap
   • Managing permissions of universal packages
   • Comparing traditional packages with containerized formats

Hands-on project: Add a third-party package repository to an Ubuntu server, resolve a broken dependency state, and install a required web stack.

You can write robust Bash automation scripts featuring variables, conditionals, loops, functions, and error handling.

1. Writing and running your first Bash scripts120 min
   • Shebang lines (#!/bin/bash)
   • Making scripts executable with chmod +x
   • Executing scripts and debugging with bash -x
   • Using strict mode (set -euo pipefail)
2. Variables, arguments and reading user input120 min
   • Local and environment variables
   • Positional parameters ($1, $2, $@, $#)
   • Prompting for user input with read
   • String manipulation and default values
3. Conditionals: if, case and test120 min
   • if/elif/else syntax and test brackets ([ ])
   • String, numeric, and file test operators
   • case statements for multi-branch logic
   • Exit status codes ($?)
4. Loops: for, while and until120 min
   • for loops over lists and command output
   • C-style for loops
   • while and until loops for reading lines
   • break and continue control statements
5. Functions, exit codes and practical automation scripts120 min
   • Defining and calling Bash functions
   • Local variable scoping with local keyword
   • Returning values and exit statuses
   • Structuring modular automation scripts

Hands-on project: Build an automated server backup script that archives critical directories, compresses them, and logs success or failure statuses.

You can configure network interfaces, troubleshoot connectivity, establish secure SSH tunnels, and secure servers with firewalls.

1. Networking basics: IP addresses, ports and DNS90 min
   • IPv4 addresses, subnets, and gateways
   • TCP vs UDP ports
   • DNS resolution and /etc/hosts configuration
   • Loopback interface
2. Configuring interfaces and checking connectivity90 min
   • ip command suite (ip addr, ip route)
   • Network Manager and Netplan overview
   • Testing routing and ping
   • Tracing network paths with traceroute
3. ss, netstat, ping, curl and wget90 min
   • Inspecting listening ports with ss -tulnp
   • Testing HTTP endpoints with curl
   • Downloading files with wget
   • Analyzing network socket states
4. Secure remote access with SSH90 min
   • SSH client and server configuration (/etc/ssh/sshd_config)
   • Generating ED25519 key pairs with ssh-keygen
   • Authorized keys management
   • SSH tunneling and port forwarding basics
5. Firewalls: iptables and ufw90 min
   • Uncomplicated Firewall (ufw) rules and status
   • iptables chains (INPUT, OUTPUT, FORWARD)
   • Allowing and denying ports and IPs
   • Persisting firewall rules across reboots

Hands-on project: Configure static networking, set up passwordless SSH login with key pairs, and write iptables rules to restrict inbound access.

You can partition disks, format filesystems, mount storage volumes via fstab, and understand the Linux boot sequence.

1. Disks, partitions and filesystems90 min
   • Device naming conventions (/dev/sda, /dev/nvme0n1)
   • MBR vs GPT partition tables
   • Partitioning with fdisk and parted
   • Filesystem creation with mkfs (ext4, xfs)
2. Mounting drives and configuring /etc/fstab90 min
   • Manual mounting with mount and unmount
   • UUID identification with blkid
   • /etc/fstab entry syntax and mount options
   • Troubleshooting boot failures from fstab errors
3. Logical Volume Management (LVM) overview90 min
   • Physical volumes (PV), volume groups (VG)
   • Logical volumes (LV) allocation
   • Expanding logical volumes online
   • LVM snapshotting concepts
4. The boot process and GRUB90 min
   • UEFI vs BIOS boot sequence
   • GRUB2 bootloader configuration and rescue mode
   • Kernel initialization and initramfs
   • System boot targets (multi-user vs graphical)
5. An introduction to systemd and services90 min
   • systemd architecture and unit files
   • Managing target states
   • Analyzing boot performance with systemd-analyze
   • Debugging failed systemd services

Hands-on project: Attach an unformatted storage disk to a Linux instance, partition it with parted, create an ext4 filesystem, and configure persistent mounting.

You can manage daemons with systemd, schedule automated tasks with cron, rotate system logs, and harden server security.

1. Managing services and daemons with systemd (systemctl)90 min
   • systemctl start, stop, restart, and reload
   • Enabling and disabling service autostart
   • Checking service status and journal logs
   • Writing custom systemd unit files
2. Scheduling tasks with cron and at90 min
   • Crontab syntax (minute, hour, day, month, weekday)
   • User crontabs vs system crontabs (/etc/crontab)
   • System cron directories (cron.daily, cron.weekly)
   • One-off job execution with at
3. Logs, journald and log rotation90 min
   • Querying system logs with journalctl
   • Filtering logs by unit, priority, and time
   • /var/log log files inspection
   • Logrotate configuration and policies
4. User and system security hardening90 min
   • Disabling root password login over SSH
   • Setting password complexity policies
   • Auditing open ports and listening services
   • Basic intrusion detection with fail2ban overview
5. Backups, recovery and troubleshooting90 min
   • Archiving and compression with tar and gzip
   • Incremental backups with rsync
   • Disaster recovery preparation
   • System troubleshooting methodologies

Hands-on project: Harden a Linux server by disabling root SSH login, configuring automated log rotation, and setting up cron maintenance jobs.

You can write a service unit and recover a server that will not boot cleanly.

1. Units, targets and dependencies90 min
   • Unit file sections
   • Wants vs Requires
   • systemctl enable vs start
2. Writing a reliable service unit90 min
   • Restart and RestartSec
   • User and WorkingDirectory
   • MemoryMax and CPUQuota
3. Reading the journal90 min
   • journalctl -u and -b
   • Persistent journal
   • Priority filtering
4. When the machine will not boot90 min
   • Rescue and emergency targets
   • Broken fstab recovery
   • initramfs basics

Hands-on project: Package a script as a hardened systemd unit with restart policy and resource limits, break the boot deliberately by corrupting fstab, then recover the machine from rescue mode and explain the failure from journalctl.

You can find which resource is saturated on a slow server and prove the fix.

1. A method, not guesswork90 min
   • Load average meaning
   • USE method walkthrough
   • Baseline before change
2. CPU and memory saturation90 min
   • vmstat run and block queues
   • Page cache vs used memory
   • OOM killer evidence
3. Disk and network90 min
   • iostat await and %util
   • ss -s and retransmits
   • Identifying the hot process
4. Tracing and tuning90 min
   • strace on a stuck process
   • sysctl network and vm knobs
   • ulimit and file descriptors

Hands-on project: Given a server under synthetic load, identify whether CPU, memory, disk or network is the bottleneck using vmstat, iostat and ss, apply one sysctl or ulimit change, and report the measured before-and-after.

You can independently set up, secure, automate, and troubleshoot a production Linux server from scratch.

1. Set up and secure a Linux server on the cloud or a VM90 min
   • Initial server provisioning and hostname setup
   • SSH key-only authentication enforcement
   • Firewall baseline configuration
   • System update and patch management
2. Manage users, services, networking and storage90 min
   • Configuring least-privilege user groups
   • Deploying and verifying custom systemd services
   • Validating network connectivity and DNS
   • Mounting persistent storage volumes
3. Automate routine tasks with shell scripts and cron90 min
   • Writing and scheduling maintenance scripts
   • Error handling and logging in scripts
   • Automated backup verification
   • Cron execution output management
4. Configure logging, monitoring and a firewall90 min
   • Reviewing journald and application logs
   • Setting up disk and memory health checks
   • Refining ufw firewall rules
   • Simulating and fixing common server failures
5. Portfolio, GitHub, mock interviews and career prep90 min
   • Structuring your capstone repository on GitHub
   • Documenting infrastructure setups in README files
   • Common Linux interview questions and technical walkthroughs
   • Resume and portfolio reviews for infrastructure roles

Hands-on project: Build and harden a complete Linux server deployment featuring custom user access control, firewall rules, automated backup scripts, and systemd services.