Total: CompTIA Linux+ (XK0-006)

This episode explains Linux’s history, philosophy, and the major ideas that shaped its development. Learners see how Linux evolved into a core operating system for modern IT environments and understand the typical roles it fills across servers, cloud platforms, and devices. This foundation prepares viewers for the skills built throughout the course.

This episode compares the major Linux distributions and explains how each balances stability, usability, and package management. Learners understand how differences in package tools and system design influence everyday administration. This helps them choose the right distribution for testing, learning, or deployment.

This episode introduces the principles behind open‑source software and the licensing models that support collaborative development. Learners understand the rights and responsibilities associated with common licenses and how they affect the use and distribution of Linux tools. This perspective helps administrators make informed decisions about software adoption.

This episode compares Linux graphical interfaces with command‑line environments and shows where each one is most effective. Learners understand how the CLI provides precision and automation, while GUIs offer quick access to common tasks. Michael demonstrates both environments to highlight their strengths in daily system management.

This episode explains the stages of the Linux boot process, from firmware initialization to the bootloader, kernel, and init system. Learners understand how each component hands off control during startup and how configuration issues can affect system behavior. Michael walks through the sequence to help viewers recognize and troubleshoot boot problems.

This episode explores the Linux directory structure and the purpose of the key system paths defined by the Filesystem Hierarchy Standard. Learners understand where system data, configuration files, logs, and binaries are stored and how this structure supports predictable administration. This knowledge prepares them for navigation and troubleshooting tasks later in the course.

This episode walks through the Linux installation process using a modern Ubuntu release in a virtualized environment. Learners see how to configure essential settings and complete a clean installation suitable for testing or daily use. The demonstration helps them build confidence in setting up their own Linux labs.

This episode explains how to update a Linux system using distribution‑specific tools and package managers. Learners understand how regular updates improve security and stability, and they see multiple methods for applying patches on Ubuntu. These skills form the basis for reliable system maintenance.

This episode covers common post‑installation tasks administrators perform to personalize and secure a new Linux system. Learners understand how to adjust system settings, install essential tools, and configure the environment to match their workflow. These steps lay the groundwork for effective system usage.

This episode reviews key considerations when tailoring a Linux system for different use cases and environments. Learners understand how factors such as hardware, security requirements, and user needs influence configuration choices. These insights help them prepare systems that fit specific operational goals.

This episode demonstrates practical customization steps that follow a fresh Linux installation. Learners see how to apply configuration changes, adjust preferences, and prepare a system for everyday administration tasks. The walkthrough reinforces concepts from the earlier customization episodes.

This episode explains how Linux identifies hardware and manages devices through kernel modules. Learners understand how tools like lsmod, modprobe, and dmesg reveal system‑level details and help diagnose issues. These skills form the foundation for managing hardware in any Linux environment.

This demonstration shows how common Linux tools are used to inspect hardware, load or remove modules, and analyze device behavior. Learners follow the practical steps administrators take when troubleshooting drivers or confirming device functionality. The demo reinforces concepts from the previous episode through real command‑line examples.

This episode introduces core storage terminology and shows how Linux organizes physical disks using partitions. Learners see how to create, modify, and inspect partitions with tools like parted, helping them understand how storage is prepared for filesystems and LVM. These concepts are essential for reliable disk management.

This episode explains how the Logical Volume Manager abstracts storage into flexible layers. Learners understand how physical volumes, volume groups, and logical volumes work together and learn how to resize or create volumes using standard LVM commands. These skills allow administrators to adapt storage without disrupting system operations.

This episode covers software RAID concepts and shows how RAID levels provide performance benefits or redundancy depending on configuration. Learners understand how to create and manage RAID arrays using mdadm and see where RAID fits in a larger storage strategy. These techniques help protect data and improve system reliability.

This episode compares common Linux filesystems—such as ext4, XFS, and Btrfs—and highlights their strengths and use cases. Learners see how to create, inspect, and manage filesystems with utilities like mkfs, tune2fs, and fsck. This knowledge prepares them to choose the right filesystem for various workloads.

This episode shows how Linux mounts local and network‑based storage, including NFS and SMB shares. Learners understand how mount points work, how to create persistent entries in /etc/fstab, and when to use automation tools like autofs. These skills ensure that storage is available and managed correctly across reboots and network environments.

This episode introduces fundamental Linux networking concepts and walks through configuring hostnames, interfaces, and basic network parameters. Learners see how common tools reveal network status and help validate connectivity. These skills form the foundation for diagnosing and managing network behavior on Linux systems.

This episode examines essential network troubleshooting commands such as ping, traceroute, netstat, and tcpdump. Learners understand how each tool provides different levels of visibility into connectivity, routing, and traffic flow. These utilities give administrators the insight needed to quickly isolate and resolve network issues.

This episode explores advanced diagnostic tools including tcpdump, Wireshark, tshark, nmap, and iperf3. Learners see how these utilities uncover deeper performance or security issues that basic tests may miss. The techniques demonstrated help administrators analyze complex network environments with confidence.

This episode explains how the Linux shell initializes user environments through profiles, configuration files, and variables. Learners understand how redirection, environment settings, and startup scripts influence command behavior and workflow. These concepts support efficient and predictable interactions with the system.

This episode demonstrates how environment variables, profiles, and redirection work in practice. Learners follow realistic examples that show how shell settings shape user behavior and automation. The demo reinforces earlier concepts by connecting configuration details to real command‑line outcomes.

This episode introduces key text‑processing tools such as grep, sed, awk, sort, and cut. Learners understand how these commands transform, filter, and analyze data directly from the terminal. These utilities enable efficient handling of logs, configuration files, and command output.

This demonstration shows how essential text tools work together to extract and manipulate information quickly. Learners see practical examples of combining commands to solve common administration challenges. The walkthrough highlights how command‑line utilities streamline everyday Linux tasks.

This episode covers the use of vi/vim and nano for editing configuration files and managing text on Linux systems. Learners understand when each editor is most effective and follow examples that demonstrate key editing workflows. These skills support reliable system administration in graphical and non‑graphical environments.

This episode explains the core ideas behind virtualization and compares bare‑metal deployments with virtual machine environments. Learners understand how virtualization abstracts hardware, improves resource utilization, and supports flexible infrastructure design. These concepts help viewers recognize where virtualization fits in modern Linux operations.

This episode explores the major Linux hypervisor technologies, including KVM, QEMU, and libvirt. Learners see how these components work together to create and manage virtual machines on a Linux host. Michael demonstrates key tools so viewers understand how Linux systems support virtualization at the kernel and user‑space levels.

This episode covers essential virtual machine management tasks such as starting, stopping, pausing, migrating, and allocating resources. Learners understand how to use common management tools to modify VM behavior and respond to changing operational needs. These skills are important for maintaining stable and responsive virtual environments.

This episode explains how to plan backup and recovery processes for Linux systems. Learners understand key concepts such as RPO, RTO, backup frequency, and data retention needs. These principles form the foundation for building reliable backup strategies that align with business requirements.

This episode demonstrates common Linux backup tools including rsync, tar, dd, and related utilities. Learners see how each tool supports different backup scenarios, from incremental file‑level copies to full system imaging. The walkthrough helps administrators choose the right approach for protecting data across varied environments.

This episode introduces the core tools used to manage files, directories, and links in Linux. Learners understand how to create, move, copy, and inspect filesystem objects using standard command‑line utilities. These skills support reliable navigation and organization across all Linux environments.

This episode demonstrates how graphical file managers can streamline everyday file tasks on Linux systems. Learners see how GUI tools compare to command‑line workflows and understand when a graphical approach is most efficient. This perspective helps administrators work effectively across both interfaces.

This episode explains how to create, modify, and remove user and group accounts in Linux. Learners understand the commands and configuration files that control account behavior and permissions. These skills are essential for managing access and maintaining secure multi‑user environments.

This demonstration walks through the practical use of account files to verify user details and troubleshoot authentication issues. Learners watch how Michael examines password hashes, UID/GID mappings, and system account properties. The demo reinforces the concepts covered in the previous episode through real examples.

This episode explains how Linux manages running programs, background jobs, and scheduled tasks. Learners understand how to monitor system activity, send signals, and control task execution using standard process utilities. These capabilities help administrators maintain system performance and stability.

This episode covers how Linux installs, updates, and removes software using distribution‑specific package tools. Learners understand how repositories, dependencies, and package metadata work together to ensure consistent software delivery. These skills support secure and maintainable system configurations.

This episode demonstrates how to configure core network services such as DNS, DHCP, HTTP, and SMTP on Linux systems. Learners see how service files, configuration parameters, and supporting tools work together to enable reliable service delivery. These concepts are central to administering and troubleshooting Linux‑based infrastructure.

This episode explains how systemd manages services, units, and system behavior on modern Linux distributions. Learners understand how to use systemctl to start, stop, enable, and inspect services, along with how unit files control service configuration. These concepts form the foundation for reliable service administration in Linux environments.

This episode explores key systemd tools such as systemd‑analyze, timedatectl, and resolvectl and shows how they support system performance analysis and configuration. Learners see how these utilities provide insight into boot times, time synchronization, and network resolution. These skills help administrators fine‑tune and troubleshoot system behavior more effectively.

This episode introduces container technologies such as Docker, Podman, and containerd and compares how each manages workloads. Learners understand how containers isolate processes, share the host kernel, and provide lightweight alternatives to virtual machines. This knowledge prepares viewers for working with containerized applications in modern environments.

This episode explains how container images are built, stored, and managed across different runtimes. Learners see how layering works, how to retrieve images from registries, and how tools like Docker or Podman create reproducible application environments. These concepts support consistent deployment and version control in container workflows.

This episode walks through common container tasks including starting, stopping, inspecting, and connecting containers to networks and storage. Learners understand how to manage running workloads and troubleshoot container behavior using standard container tools. These skills are essential for administering containerized applications in development and production environments.

This episode introduces essential security principles that apply across modern IT environments. Learners understand how risk reduction, layered defenses, and secure defaults shape system protection strategies. These concepts provide a foundation for the Linux‑specific security techniques covered throughout the chapter.

This episode explains how Linux handles authentication, authorization, and accounting to control access. Learners understand how credentials, permissions, and auditing interact to safeguard resources. These fundamentals support secure user and system management across all Linux deployments.

This demonstration shows how Linux authentication and authorization mechanisms function in practice. Learners see how to inspect user identities, validate access rights, and observe how system logs capture authentication events. The demo reinforces the concepts introduced in the previous episode through real command‑line examples.

This episode covers the core techniques used to strengthen Linux systems, including permissions, sudo policies, ACLs, and SELinux. Learners understand how each control reduces attack surface and protects system resources. These practices form the basis of secure Linux administration.

This demonstration walks through the practical application of Linux hardening tools. Learners see how Michael inspects permissions, configures sudo, applies ACLs, and works with SELinux to enforce security policy. The walkthrough shows how theoretical concepts translate into real-world protections.

This episode explains how to configure Linux firewalls using tools such as firewalld, iptables, and ufw. Learners understand how rule sets, zones, and policies regulate network traffic and prevent unauthorized access. These skills are essential for securing Linux systems in networked environments.

This episode covers security practices for managing remote access through SSH and related tools. Learners understand how to disable insecure protocols, enforce key‑based authentication, and configure tools like fail2ban to protect against brute‑force attacks. These settings help ensure safe and controlled remote administration.

This demonstration shows how to implement secure remote access controls on a Linux system. Learners see how to adjust SSH settings, review key‑based authentication, and apply intrusion-prevention tools to reduce risk. The demo provides practical context for securing remote entry points.

This episode explains how Linux captures system activity using tools such as journalctl, rsyslog, and auditd. Learners understand how to review logs, trace events, and build a meaningful audit trail to support monitoring and forensic analysis. These capabilities are critical for detecting issues and maintaining operational integrity.

This demonstration guides learners through real-world log review and auditing workflows. Michael shows how to query systemd journals, inspect log files, and use auditd to monitor important system changes. The walkthrough reinforces how logging tools contribute to security visibility and incident response.

Michael explains how to strengthen user accounts by controlling authentication patterns, credential aging, and shell assignments. Learners explore how to mitigate threats like brute force and insider misuse using PAM modules and account metadata files. These practices form a baseline for securing multi-user Linux environments and minimizing privilege exposure.

This demonstration shows how to apply account hardening techniques on a live Linux system using standard utilities like chage and usermod. Learners watch as Michael configures password aging, enforces account expiration, and verifies PAM-based lockout behaviors. The demo reinforces the importance of maintaining strict account controls to prevent credential abuse.

Michael introduces foundational cryptographic principles, emphasizing the operator’s perspective on confidentiality, integrity, and authenticity. Learners understand when to apply symmetric versus asymmetric encryption and how tools like OpenSSL and GPG establish trust for network protocols and file security. These concepts prepare administrators to choose the correct cryptographic control for various organizational threat models.

This demonstration walks through practical examples of using cryptographic tools to verify file integrity and authenticity. Learners see how to generate SHA-256 hashes, detect tampering, and manage GPG key pairs for digital signatures. The walkthrough helps connect theoretical concepts like "fingerprints" to real-world system administration tasks.

This episode explains how detective controls like AIDE and rkhunter provide early warning when unauthorized changes occur to system binaries or configurations. Learners understand the critical distinction between preventing a change and detecting one through cryptographic baselining. These techniques are essential for maintaining a trustworthy environment and supporting rapid incident response.

Michael demonstrates how to initialize and use the AIDE database to monitor for suspicious filesystem modifications. Learners watch as a reference snapshot is created and then tested against simulated unauthorized changes to verify the detection workflow. The demo reinforces best practices for establishing and maintaining a "known good state" baseline.

This episode introduces major security frameworks like CIS benchmarks and OpenSCAP, which provide prescriptive guidance for system hardening. Learners understand how to distinguish between hardening a system and proving compliance through automated scanning and reporting. These insights help administrators align their systems with industry best practices and organizational regulatory requirements.

Michael explains how to protect data throughout its lifecycle using encryption at rest and secure deletion tools like shred. Learners also explore supply chain security, understanding how package signing and GPG keys establish trust for installed software. These practices ensure data confidentiality and help prevent the deployment of tampered software from unverified sources.

Michael introduces Infrastructure as Code (IaC) as a method for provisioning and managing systems using machine-readable definition files. Learners explore the differences between configuration management and orchestration while examining tools like Ansible, Puppet, and Terraform. This approach helps administrators ensure repeatability and eliminate configuration drift in modern environments.

Michael introduces Bash scripting as the primary method for automating repetitive tasks and ensuring consistent system behavior across Linux environments. Learners explore essential syntax components including shebangs, variables, and logical operators such as && and || for conditional execution. The lesson emphasizes using exit codes and precise string comparisons to create reliable scripts that minimize human error.

This demonstration walks through the creation, permission management, and execution of functional Bash scripts using real-world examples. Michael shows how to capture user input with read and process positional parameters to build flexible automation tools. Learners see the practical application of standard streams and redirection to manage script output and log errors effectively.

Michael positions Python as a complementary tool for administrators when automation requires complex logic or structured data handling. Learners explore basic Python syntax, data types, and the use of virtual environments to isolate project dependencies. This foundation allows administrators to build more maintainable automation than traditional shell scripting alone.

This demonstration shows how Python can automate tasks such as file operations, system checks, and simple data processing. Learners watch how Michael constructs scripts step by step and applies Python features to solve real administrative problems. The walkthrough highlights when Python is a better choice than shell scripting.

This episode introduces Git as an essential safety mechanism for tracking changes to scripts, configurations, and documentation. Learners see how to initialize repositories, manage commits, and use branches to isolate experimental work from stable production environments. These version control practices provide the auditability and rollback capabilities required for modern Linux administration.

Michael outlines how administrators can responsibly integrate artificial intelligence into their workflows as a productivity and decision-support tool. Learners understand that while AI can draft scripts or summarize logs, final accountability for validating and testing all changes remains with the human administrator. This lesson highlights the necessary controls and ethical considerations for using AI-generated output in production.