Master CompTIA Linux+: Complete Zero-to-SysAdmin Course

Meet your instructor and gain practical IT insights from two decades across product, industrial, and banking sectors, with hands-on learning and open discussions.

Begin your learning adventure with challenging, inspiring content, practical exercises, and expert insights. Connect with fellow learners, benefit from a supportive environment, and set personal goals for growth.

Course delivery presents a modular, self-paced structure with modules, lessons, video lectures, quizzes, practical exercises, and projects, plus on-demand 24/7 access and interactive Udemy features.

Explore the regular lesson structure that blends theory with practical application. Experience step-by-step demonstrations, real-world scenarios, and hands-on exercises with resources that reinforce linux administration skills.

Explore Red Hat Enterprise Linux’s enterprise stability and security, long term support, and integrated management tools like cockpit, systemd, firewalld, SELinux, and KVM in a Hyper-V lab.

Install VirtualBox on macOS to run multiple operating systems, verify system requirements, download from the official site, complete the dmg installer, grant kernel extension permissions, and launch virtual machines.

install red hat enterprise linux 9 on a Hyper-V virtual machine, choose server with gui, configure networking with a static IP and hostname, and register for free development benefits.

Register Red Hat Enterprise Linux from the command line, attach and manage subscriptions with subscription-manager, verify status, view available subscriptions, and access updates, support, and repositories.

Learn to install Red Hat Enterprise Linux 9, enable cockpit, connect remotely, create and manage virtual machines for an Ansible lab, and handle subscriptions and registration during setup.

Learn to customize RHEL hostnames using nmcli, clone and rename two virtual machines, verify IPs via SSH, and create snapshots to preserve initial installations.

Install and configure vagrant on a RHEL 9 VM by enabling the CodeReady Linux Builder repository, installing virtualization tools and Libvirt, and launching two VMs with vagrant up.

Trace Linux history from Multics and Unix to the open source revolution, shaped by hacker culture and the Free Software Foundation. Linus Torvalds released Linux under the GNU Public License.

Explore Linux licensing models, including open source and copyleft licenses like the GNU General Public License, and permissive licenses such as BSD, MIT, and Apache, plus closed source and freeware.

Explain what a Linux distribution is and why it matters, then summarize core components: kernel, libraries, packages, package managers, and desktop environments such as GNOME and KDE.

Explore the common uses of Linux across cybersecurity, development, servers, and supercomputing, including web, DNS, time, mail, file and print services, databases, authentication, and mobile IoT devices.

Explore cloud computing fundamentals and Linux's pivotal role in hosting dynamic web apps. Learn cloud types—public, private, hybrid—and delivery models—IaaS, PaaS, SaaS—and how CI/CD and DevOps run on Linux.

Master basic Linux shell commands by understanding command structure—name, options, and arguments—then navigate command output and history with practical examples like ls, date, and clear.

Master basic linux commands for user info and system details, such as who, w, who am I, id, uname -a, date, cal, and ls; learn su, sudo, and passwd.

Explore Linux shell metacharacters, including the dollar sign for variables, tilde for the home directory, and symbols for background execution and command chaining; master quoting and backtick command substitution.

Learn to navigate linux help systems using man pages, sections, and info, plus built-in help and keyword searches like apropos; master safe shutdown with shutdown, wall, and reboot.

Navigate the Linux file system from root / to directories such as /home, /etc, /var, /bin, /sbin, and /tmp, and master the concepts of absolute versus relative paths using cd.

Navigate the Linux file system confidently by using pwd to locate your current directory, cd with absolute and relative paths, tilde shortcuts, and tab completion, including home and root directories.

Explore how Linux organizes files and the key file types: text, binary, executable, directory, linked, and device files, named pipes and sockets; naming conventions and essential commands.

Explore linux file listing techniques by mastering ls, including -l, -a, -F, -R, reveal hidden files, and use file and stat to identify file types and metadata.

Master wildcard metacharacters in Linux file management, including asterisk, question mark, and square brackets. Apply them with ls and cat to list and view files, using redirection as needed.

Master Linux file viewing with cat, head, tail, more, less, and strings; practice navigating and analyzing contents, including binary files, using pipes and grep.

Explore text processing with grep in Linux, mastering pattern search, regular expressions, case sensitivity, inverse and count options, and extended regex with egrep.

Learn essential Linux file and directory operations, including creating files with touch or cat, building directories with mkdir and -p, and viewing content with ls, head, tail, and less.

Copy, move, and remove files and directories using cp, mv or env, including recursive copies and interactive prompts with -i, then rm or rmdir for removal.

Learn how to use file and directory attributes to control operations on ext file systems, including append, compress, immutable, and synchronous flags, using attribute management commands.

Master Linux file search with the find and locate commands, learning recursive directory traversal, criteria by name, user, permissions, size, type, and actions on matched files.

Learn to leverage the find command to execute actions with -exec, including changing permissions to 644, deleting files, and locating empty, hidden, or user-owned files.

Learn to locate files in linux by modification or access times using find with -mtime, -atime, and -exec for actions, plus time ranges and size filters.

Install mlocate on Red Hat, update the database, create a file, and use locate with -n, -c, and -i to find files quickly, with root privileges and cron updates.

Learn to use the find command to locate files larger than 100 MB, create test large files with dd, and save a long listing to /tmp/big_files while handling permissions.

Explore Linux file system security by learning file and directory permissions, how to read them with ls -l, interpret owner, group, and others, and use chmod to change access rights.

Master Linux file access control by creating directories and files, setting permissions with chmod, and using chown, chgrp, and umask to manage owners, groups, and access recursively.

Create and manage groups with groupadd and usermod, using -G and -aG for primary and supplementary groups. Apply set id bit to project dirs with 775, then verify with ls.

Configure a secure shared development directory with a dev team group, a new developer user, and 3770 permissions, using the sticky bit to protect files and ensure collaboration.

Master basic vim navigation to move efficiently through text, switch between normal and insert modes, and use commands for words, paragraphs, search, and file operations.

Practice vim installation across Ubuntu, macOS, and Windows and master basic navigation with h j k l, word and line moves, insert mode, and exiting with :q.

Learn practical vim editing basics, from moving around the screen and document to searching, highlighting, copying, pasting, deleting, and inserting or appending text with familiar commands.

Practice vim navigation with hands-on exercises, moving between paragraphs using opening and closing curly braces, and jump to line starts and ends with 0 and $..

Master vim navigation and editing through practical exercises: search with n/N, delete with dw and D, delete to end of file with G, and use insert, undo, and redo.

Master vim search and replace, copy, and insert operations to boost text editing efficiency, including substituting across all lines or specific ranges with confirmations and global options.

Learn vim copy and insert techniques using yank and yy, word motions, and paste with P; undo with U; read files with :r and insert at specific lines.

Master vim fundamentals by leveraging its modal design—normal and insert modes—alongside efficient navigation, text editing, search and replace, yanking, and the repeatable dot command.

Explore vim editing from basics to advanced text manipulation, including file creation, navigation, deletion, copying, undoing, substitutions, and multiple windows, with practical exercises.

Practice vim text editing techniques, from entering insert mode and editing lines to using delete, undo, search, and block visual commands to batch-edit multiple lines.

Master vim editing by rearranging sections, deleting and pasting blocks, and using visual and normal mode commands for system administration and scripting languages for web development.

Practice editing in Vim by deleting lines, replacing scripting with programming, and adjusting indentation for bullets. Copy non-contiguous lines, use visual modes, yank and paste, and change inside parentheses.

Master vim with advanced editing techniques: open at a line, use multi-window mode, compare files, insert lines, save with wq or x, and repeat edits with the dot command.

Open Vim with multiple files, navigate between them using :next and :previous, view with :args, split windows, edit new files, and save all changes with :wqa.

Master grep and wc to locate words or phrases in files and quantify results. Use grep on logrotate.conf to find matches and count lines with -c and words with wc.

Learn how the cat command reads standard input from the keyboard and redirects it to a file with the > operator, and how to append with >> and concatenate files.

Learn to use pipes to connect command outputs, making who | sort quick and clean, and count users with who | wc -l using the vertical bar.

Explore how processes allocate memory in their own address space, form a hierarchical parent-child tree, and can be viewed with ps and top using pid, ppid, uid, and daemon status.

Learn to manage linux processes and jobs by identifying pids, running foreground or background tasks with &, suspending with ctrl z, and controlling them with fg, bg, kill, and ps.

Explore how the top command displays real-time Linux processes, CPU, memory, and swap usage, with filters and keys to sort, hide idle tasks, adjust view, and customize colors.

Explore how Linux processes transition through five states—running, sleeping, waiting, stopped, and zombie—and learn to list PIDs by process name, user, or group with pgrep, pidof, and ps.

Spawn a process with a niceness value that sets its priority, zero by default, where higher niceness lowers cpu attention and lower niceness increases it, using nice and renice.

Explore how signals manage processes in Linux, using kill and pkill to issue graceful or forceful terminations, reload configurations, and work with common signals like sighup, sigterm, and sigkill.

Change your password with the password command, which prompts for new password twice. Learn about shell and environment variables, assign values with =, and manage path so commands are found.

Master Linux special characters and command-line keystrokes, including asterisks, dot, dollar, quotes, brackets, and key combos like Ctrl B and Ctrl F to navigate and edit the command line.

Explore command chaining with ampersand background execution, semicolon sequencing, and logical operators (and, or, not) to control success, failure, and conditional flow.

Explore sed for search and replace in files, including replacing the first instance and applying global substitutions, and use awk to extract the first field from lines.

Explore advanced set command usage to view, exclude, and print specific line ranges (7–12, 20–35), replace words (case-insensitive), and compare outputs using pipes like ip route show.

Use the exit command to log off the console and end your shell session; reboot, power off, and shutdown require root privileges and authentication.

Review how bash loads the dot bash history file into memory at startup and writes it back on exit, enabling command viewing, repeating, and editing with fc, vim, or nano.

Learn to use the alias command to set, list, and remove aliases in bash, apply temporary aliases for a session, and persist them in the .bashrc.

Use the watch command to monitor changing output in real time, with -n to adjust refresh and -D to show changes; pair with tail -f to follow log file growth.

Explore gaining administrative privileges in Linux with sudo, su, and root login, and learn configuring the sudoers file, adding users to the sudo group, and testing privilege escalation.

Manage software packages with the rpm command on Red Hat Enterprise Linux, covering naming and dependencies. Explore the package database at /var/lib/rpm and how tools install, upgrade, and uninstall.

Learn how to manage rpm packages by querying installed packages, listing files, viewing docs and config files, checking dependencies and what provides, and using install and upgrade options.

Install and manage packages with rpm, including handling dependencies, upgrading, freshening, replacing, and removing packages; verify integrity with md5 and gpg, and import keys for credibility.

View gpg keys with rpm -q gpg pubkey, then verify installed package attributes with rpm -V, comparing owner, group, permissions, size, modification date, digest, and type.

Discover how yum, a front end to rpm, manages packages and repositories via Ume, with directives for caching, logging, architecture filtering, and GPG checks.

Explore yum, the Linux package manager, with commands like install, update, remove, group operations, search, and repo list, plus creating a local repository from the installation DVD.

Install, update, and manage packages and groups with yum, including local installs and group operations. Search by file and view header info, then track history.

Configure and verify a Linux system’s hostname as a unique network label, apply temporary changes with the hostname command, then permanent changes via hostnamectl or /etc/hostname, and update /etc/hosts.

Explore IPv4 addressing, including static and dynamic addresses, subnet masks, and gateways, and learn to use ping and traceroute to troubleshoot networks.

Use the ip command to view link and address info, assign ip addresses with ip addr add, and manage interfaces and routes with ip link set and ip route.

Learn to validate and troubleshoot network configuration using ip, ping, traceroute/tracepath, and ss or netstat, inspecting interfaces, addresses, routing, and ports.

Practice lab examines network configuration by displaying ip addresses and net masks for all interfaces, routing information, and router reachability, then tracing hops and listing listening tcp sockets.

Learn to configure networks using the Network Manager command line interface (nmcli) and the Network Manager daemon, including displaying, creating, modifying, and activating connections for DHCP and static IPs.

Validate Linux network configuration by using ip link and ip addr to map interfaces and addresses, then test connectivity with ping, tracepath, and ip route, and inspect sockets with ss.

Configure network settings with nmcli and ifconfig by editing sysconfig network scripts and ifcfg files, then reload and bring the interface up to apply ipv4 static or dhcp with dns.

Ensure a backup connection to the server before changing settings; configure two static IPv4 addresses, gateway, DNS, and hosts file using nmcli, then reboot and verify connectivity.

Explore user accounts, including superuser, system, and regular users, and learn how uid, gid, and /etc/passwd inform file ownership, login, and process access using id, ls, and ps commands.

Learn how to gain superuser access in Linux using su and sudo. Compare root vs normal user privileges, and apply secure practices when using sudo, wheel group, and login shells.

Configure sudo access by editing the sudoers file and using supplementary files in /etc/sudoers to grant user or group privileges, including passwordless options and environment behavior differences.

Experience a guided exercise on gaining superuser access with sudo and su, comparing non-login and login shells, and observing how HOME and PATH change for root.

Create and manage users with useradd, usermod, and userdel, configuring home directories, groups, shells, passwords, and UID ranges. Delete users safely and manage unowned files and password changes with passwd.

Practice creating, modifying, and deleting Linux user accounts using useradd, usermod, and userdel, including setting passwords and verifying entries in /etc/passwd.

Create, modify, and delete local groups with groupadd, groupdel, and groupmod; assign gids, designate system groups, and manage group memberships with usermod, including primary and supplementary groups.

Create and manage local group accounts by adding users to the operators and admin groups, verify membership and GID 30,000, and configure the sudoers file to grant full administrative privileges.

Explain how Linux stores and verifies passwords in /etc/shadow, uses salt and encryption, and applies password aging and expiration; configure policies, lock accounts, and use no-login shells.

Practice managing user passwords by forcing password change on first login, enforcing 90-day password changes, expiring accounts after 180 days, locking/unlocking accounts, and applying system-wide password aging in /etc/login.defs.

Master local user and group management with the consultants group and sudo rights. Enforce 30-day and 15-day password policies, 90-day expirations, and first-login password updates for consultants.

Understand Linux file permissions across user, group, and other categories, with read, write, and execute rights, how ownership and precedence affect access, and hints from ls -l.

Master the change mode command to adjust file and directory permissions using symbolic and numeric methods. Apply read, write, and execute rights for user, group, and others, including recursive changes.

Use the own command with owner:group syntax to change ownership, apply -R for files and directories, and note root can grant ownership while regular users must belong to the group.

Apply file system permissions to enable a group shared directory by creating /home/consultants, setting group ownership to consultants, enabling write access with chmod 770, and verifying access across consultant users.

Manage default permissions for new files and directories, apply special permissions (setuid, setgid, sticky), and use umask to tailor initial permissions and group ownership.

Set default permissions with umask and apply setgid so new files inherit the operators group in a shared directory. Tune umask for the operator one user and persist via .bashrc.

Configure file access by creating a home tag docs directory, setting group ownership to tag docs, and applying setgid with 7/7/0 permissions; verify group collaboration.

Learn to list and monitor Linux processes on Red Hat Enterprise Linux, determine status, resource use, and ownership, and understand process states and signals to manage and terminate processes.

Master bash job control to manage foreground and background processes in a terminal session. Use ampersands to run pipelines, and commands like fg, bg, and ctrl+z to suspend and resume.

Learn to manage processes on Linux by sending signals with kill, pkill, and pgrep, terminate daemons, end user sessions, and view process trees.

Monitor Linux process activity by understanding load average, its calculation from runnable and IO-waiting processes, and use uptime, lscpu, and top to identify high resource usage.

Perform lab exercises to monitor and manage linux processes using top, ps, and pkill; create cpu-load scripts, suspend and resume processes, and save top configurations.

Learn to control and monitor Linux system services and daemons with systemd, using systemctl to manage service, socket, and path units and understand startup, dependencies, and control groups.

Learn to control linux services with systemctl by listing units and sockets, checking status, and starting, stopping, restarting, reloading, enabling at boot, managing dependencies, and masking or unmasking conflicting services.

Configure ssh key based authentication by generating a private key and matching public key, copying the public key to remote servers, and using ssh-agent or passphrases for secure passwordless login.

Learn to configure OpenSSH to restrict root logins and disable password authentication, enabling private key logins by editing /etc/ssh/sshd_config and reloading sshd.

Explain how Red Hat Linux logs system events with systemd journal and syslog, maintain the system journal across reboots, and synchronize time with NTP and time zone settings.

Explore how syslog uses facilities and priority levels (0–7) to categorize and route messages. Learn to configure rsyslog rules, monitor with tail, and test debug logging.

Use journalctl to retrieve and interpret system journal entries for troubleshooting. Understand that on Red Hat Enterprise Linux 8, the run log directory stores the journal and clears after reboot.

Configure the system journal to persist across reboots by setting storage to persistent, volatile, or auto in /etc/systemd/journald.conf, then verify with journalctl and reboot.

Configure NTP synchronization and time zone to ensure accurate system journal timestamps, then verify with Chrony sources and NTP pool for consistent time across systems.

Learn to update a server's time zone to Europe/Paris, display recent logs with journalctl, and configure rsyslog to route authentication and security messages to /var/log/auth-errors.

Master archiving and transferring files with tar, using gzip, bzip2, or xz compression, extracting and listing archives, and securely syncing local files with a remote server via ssh.

Transfer files securely between systems using ssh, scp, and sftp, with key-based authentication or passwords, specifying remote paths, and copying files or directories recursively.

Learn how to schedule deferred tasks with the at package, using add to queue jobs, specify times with now plus minutes or t time, and review with add queue.

Learn to schedule recurring user jobs with crontab, configure cron daemon behavior, manage per-user and system files, and handle output via email or redirection.

Schedule recurring system jobs using systemwide crontab files in /etc, organize with run-parts and etc/cron directories, and leverage systemd timer units with safe update practices like daemon-reload and enable.

Create a job in /etc/cron.daily to count active users with w -h | wc -l and log with logger; configure systemd timer for sysstat to run every two minutes.

Enable and configure systemd tmp files to manage temporary directories and purge stale data, using timers to run cleanup after boot and at set intervals.

configure systemd tmp files to clean the tmp directory and purge run momentary files using five days and 30 seconds rules, with root ownership and 1777/070 permissions.

Boost system performance by configuring tuned daemon profiles, adjusting process priorities with nice and renice, and switching between static and dynamic tuning to match workloads.

Explore how Linux uses time slicing to schedule multiple processes across cores with sched_normal and nice values from -20 to 19, and how renice or top adjusts priorities.

Adjust process scheduling with the nice command, launch multiple sha1sum processes on available CPU cores, and use ps, pgrep, jobs, pkill, and the pseudo resize command to observe CPU usage.

Learn to manage access with ACL using setfacl, add or modify user, group, and other entries, set recursive permissions, and apply default ACLs to enforce file security.

Grant the consultants group full access on shares content with setfacl entries, deny consultant one, and set default acl for inheritance. Verify permissions with consultant two and consultant one.

Learn to create and manage storage partitions, file systems, swap spaces, and persistent mounts from the command line, covering MBR and GPT partitioning and fstab configurations.

Guided exercise adds a 1 gb zfs partition on /dev/sdb, configures persistent mounts at /archive via fstab, and verifies with mount and reboot.

Size swap space according to memory workload to supplement ram and support virtual memory. Create a Linux swap partition, activate with swapon, and persist via fstab.

Partition a new disk with GPT, format a 2 gb partition as zfs, and mount it at the backup directory. Create two swap partitions and enable them at boot.

Master linux storage with lvm by creating and managing physical volumes, volume groups, and logical volumes, then format as file systems or swap spaces.

Extend a volume group by adding physical volumes and extending logical volumes, then resize file systems with zfs grow fs or resize to fs, while safely reducing the volume group.

Guide to extending a volume group with a new physical volume, resizing the logical volume, and growing the ZFS filesystem on /mnt/data while it remains mounted.

Extend server1-lv1 in server1-vg1 to 768 mebibytes while preserving its persistently mounted location at /storage/data1, and create a new 128 mebibyte lv2 formatted with zfs at /storage/data2.

Explore Stratis storage management for Red Hat Linux, creating pools, thin provisioned file systems, and snapshots, and manage block devices with the Stratis CLI and D-Bus service.

Hands-on with Stratis to manage layered storage: create pools, volumes, and thin provisioned file systems, and use snapshots to access data as the file system grows.

Explore how the Red Hat Enterprise Linux eight Virtual Data Optimizer (Video) reduces storage with zero block elimination, deduplication, and lz4 compression, using video volumes on block devices.

Create thinly provisioned file systems with straight storage management and virtual data optimizer volumes, verify dynamic growth, and explore snapshots, deduplication, and compression with mount and fstab configurations.

Identify and mount network attached storage using NFS, configure version 4.2 with the NFS conf tool, and persist mounts via fstab for Linux and Unix systems.

Configure NFS shares with /etc/exports and persist mounts via /etc/fstab for reboot persistence. Test by mounting from the client, editing a test file, and rebooting to verify NFS v4.

Master the Linux boot process by describing firmware initialization, boot loader selection, kernel, initramfs, systemd, and target configurations, including troubleshooting and repairing boot issues.

Identify the system’s default boot target and switch between graphical and multi-user modes using systemctl. Practice rescue mode via the bootloader and verify transitions with root login and read-write root.

Learn to reset the root password from the bootloader via an initramfs shell, remount root as read-write, perform selinux relabeling, and review boot logs with journalctl.

Master the boot process in this lab by resetting the root password, diagnosing boot faults, and setting the default target to graphical, including emergency mode, fstab fixes, and SELinux relabel.

Explore fundamental networking concepts in Linux, including the tcp/ip four-layer model, ipv4 addressing, subnetting, routing, and interface naming, with hands-on labs using nmcli and static and dhcp configurations.

Master IPv4 fundamentals by learning how 32-bit addresses map to dotted decimal notation, how subnet masks define network and host IDs, and how classful and classless subnetting use CIDR notation.

Master IPv4 addressing by distinguishing classful and classless, calculating network IDs and first usable and broadcast addresses, and designing campus subnets from 10.34.0.0/16 for four buildings and a data center.

Plan an IPv4 addressing scheme for adatum's three branch offices, determining wired and wireless address needs and allocating slash 24 subnets within the 172.16.x.0/24 ranges for Houston, Mexico City, and Portland.

Use OpenSSL on Red Hat Linux to generate a private key and a self-signed X509 certificate, protect the key with a passphrase, and set a 1-year validity.

Create a root certificate authority with a self-signed certificate, generate a private key, optionally configure openssl.conf, and prepare to sign additional certificates.

Perform a hands-on lab to create a self-signed CA and a server certificate with OpenSSL, including CSR, private key, signing, and deploying for Apache TLS.

Learn to create and run your first bash script, make it executable, and explore the shebang, echo, and command substitution with user input for interactivity.

Make your first bash script executable with chmod +x, run it with ./ or bash, and use a shebang for bash execution while reading a name and greeting the user.

Explore bash syntax fundamentals, including variables, data types, command substitution, and special variables; practice with examples, and learn about local versus global scope and basic function usage.

Learn how bash treats all data as strings, use quotes to safeguard spaces, perform arithmetic with $(( )), and work with arrays and command substitution using $() and ${array[index]}.

Explore bash special variables, script arguments, and command substitution in practical scripts. Master variables, exit status, and the shebang as you prepare for control structures.

Map the unix like file system as a tree with root and home, and learn core bash commands—pwd, ls, cd, mkdir, touch, cp, mv, rm, rmdir—for file management and permissions.

Explore unix-like file permissions, including owner, group, and others, learn to view them with ls -l, and modify them using symbolic and numeric chmod methods.

Develop a practical bash exercise that creates a project directory structure with src, docs, and tests, adds main.py and readme.md, and sets permissions with 755 and 644.

Build and run an enhanced bash file operations script that uses special variables, command substitution, user input, timestamps, and file permission changes, and modify bashrc for aliases.

Explore conditional statements in bash by using if, elif, and else, the test command, and checking file existence and numeric comparisons to build flexible scripts.

Master bash condition testing using file checks (-f, -d, -r), string checks (-z, -n, =, !=), and numeric checks (-eq, -lt, -gt). Practice combining with && and || in if-elif-else.

Master bash loops by using for, while, and until loops, practice loop control with break and continue, and apply nested loops to count processes and handle files.

Explore bash loops, including until, while, break, and continue, with nested patterns and practical file-processing examples. Learn how to structure for loops and conditionals in scripts.

Build a bash menu script in this hands-on lab, applying while loops and case statements for Linux system administration, with options like date, list files, and exit.

Develop an interactive bash menu script in a hands-on lab, adding options for clearing the screen, a guess-the-number game, case handling, while loops, random numbers, and input validation.

Build a bash-script driven Linux system administration interactive menu. Run tasks from uptime, disk usage, CPU load, memory checks, logs, and large-file searches.

Create a hands-on Linux system administration lab by building a menu-driven bash script with case statements, read input, and perform tasks like uptime, disk usage, and large-file search.

Explore how bash functions are defined and called, pass parameters, return values, and use local variables, with best practices and practical examples like greeting, calculations, and a number guessing game.

Explore bash functions and local variables to keep scripts modular, build reusable blocks like check_even_odd and generate_random_number, and improve readability and maintainability.

Master Bash error handling and debugging by applying exit status checks, custom functions, traps, verbose output, and the Bash debugger to write robust scripts with graceful error reporting.

Learn practical bash error handling and debugging techniques, including using set -e, custom error functions, and traps to exit on failure and perform cleanup.

Learn to debug bash scripts with set -x for verbose output, add debug echoes, handle errors with traps and exit statuses, and use bash gdb for line-by-line debugging.

Explore advanced bash scripting techniques, including parameter expansion, indirect references, associative arrays, process substitution, brace expansion, advanced input/output redirection, traps and signals, command-line option parsing, and recursive functions.

Master advanced bash scripting techniques such as indirect references, associative arrays, array slicing, process substitution, and brace expansion to automate tasks.

Explore advanced bash scripting techniques, including input/output redirection, here documents, subshells and command grouping, traps, recursive functions, and getopts parsing.

Explore advanced bash scripting techniques through a practical example, including recursive file traversal, an associative array, traps, here documents, and counting file extensions.

Discover bash script optimization and performance techniques, from basic to advanced, to handle large data sets, profile bottlenecks, and use built-in commands, avoiding unnecessary commands, and efficient arithmetic and conditionals.

Learn to optimize bash scripts by using arrays, improve parsing with the read command for multi-line output, and accelerate large-data processing with awk, sort -u, and parallel.

Profile bash scripts with the time command and trace mode (-x), then demonstrate printf, shell arithmetic, date formatting, awk, grep, and sort -u, while addressing permissions and file errors.

Master bash script optimization and debugging as you fix typos and generate data.csv, large_file.txt, and names.txt through simple, automated scripting.

Explore bash script optimization and performance techniques by integrating small scripts, generating data files and names, and measuring before-and-after results to improve readability and maintainability.

Learn to automate command line tasks with bash scripting, using loops, conditionals, and piping; master grep and regular expressions for log analysis.

Write a simple bash script with a shebang and echo commands using vim, write to output.txt, then make it executable, run it, and review results with cat output.txt.

Learn to automate tasks with for loops, perform tests using operators, evaluate exit codes, and build robust conditional scripts using if, else, and elif in bash.

Use loops to print hostnames from multiple servers, building a for loop and a shell script in ~/bin to run ssh hostname. Verify the script is executable.

Learn to craft regular expressions that match dates and text, apply them with grep, vim, and less to files and piped data, and master syntax, anchors, wildcards, and quantifiers.

Learn to search Linux system and postfix logs with grep and regular expressions, filter by date and time, and verify postfix status and configuration using ps, last, and relevant files.

Master grep with regular expressions to isolate matches, combine commands via pipes, and apply options like -i, -v, -r, and -e for flexible searches in files such as httpd.conf.

Create a bash script to collect host info with hostname -f and lscpu, filter /etc/selinux/config and /var/log/secure with grep, and save outputs for server one and server two using loop.

Discover shell scripting basics: use echo with quotes, apply command substitution, display date and who, and manage environment and user variables plus input/output redirection.

Master the if-then statements in bash scripts by testing exit statuses and using then, else, and elif; explore case as a cleaner alternative.

Learn to use the test command within if-then statements, evaluate numeric and string conditions, and handle zero and non-zero exit statuses, escaping, and square-bracket syntax for robust shell scripting.

Learn to test files and directories in shell scripts using tests (-d, -e, -f, -r, -s, -w, -x) and date comparisons (-nt, -ot) to verify existence, ownership, and permissions.

Explore compound testing in bash by using and and or operators in if statements, subshells, advanced math with double parentheses, and double brackets for string matching.

Explore replacing long if-then-else chains with a case statement to match a variable against multiple patterns, and detect Red Hat or Debian base distributions.

Explore bash looping with the for, while, and until commands to automate repeated tasks. Learn to read lists from values, variables, and command outputs, and handle quotes and spaces correctly.

Master bash looping with the for statement, adjusting IFS and restoring it safely. Use file globbing, test with -d/-f, and explore C-style for loops with multiple variables.

Master bash loops with while and until, testing conditions with the test command and square brackets, managing exit statuses, and nesting loops to control script flow.

Use nested loops with IFS to process file lines and parse fields. Use break and continue to control inner and outer loops and redirect output.

Explore practical shell scripting with loops to list executable files from the path and automate user creation from a CSV using for, while, and until loops with IFS.

pass data to bash scripts using command line parameters and positional parameters, including handling spaces with quotes and using braces for parameters beyond the ninth.

Explore how to handle bash command line parameters with variables such as $#, $*, and $@, test parameter counts, retrieve the last parameter, and iterate with shift and for loops.

Master the art of processing command line options and parameters in shell scripts using case statements, double dash separation, and the getopt and getopts tools.

Use the bash read command to capture input, assign to variables, prompt with -P, -n, and -T options, hide input with -s, and read from files via pipe.

Demonstrates a practical script that tests connectivity to multiple IP addresses using ping, with options for command line input or a file, and explains getopts, read, and parameter handling.

Explore how Linux handles input and output using standard input, output, and error, and master redirection with >, >>, and 2>, including combining stdout and stderr with &> for logging.

Master redirecting stdout and stderr in scripts with temporary and permanent file descriptor redirections. Use exec to change and restore redirections, including stdin and extra descriptors (3–8).

Master how to redirect and reuse file descriptors in bash, including saving stdin and restoring originals. Open a single descriptor for input and output, then close it safely.

Suppress script output with /dev/null, manage temporary files in /tmp using mktemp and mkstemp, and log data to stdout and files with the T command.

Demonstrate file redirection in bash by reading a CSV and producing MySQL insert statements, then show how to redirect stdin, stdout, and stderr and manage file descriptors.

Learn how to control bash scripts via signals, including handling sigint, sigquit, sigkill, and sigterm. Use ctrl-c and ctrl-z for interrupting and pausing, manage jobs with ps and kill.

Use the trap command to monitor and handle Linux signals in shell scripts, including Sigint, trap on exit, ignore interruptions, and modify or remove traps to control script flow.

Learn to run shell scripts in background mode on Linux using ampersand, view job numbers and PIDs, and detach with nohup to keep jobs running after logout.

Run scripts in background with nohup to detach from the terminal and ignore sighup signals. It redirects stdout and stderr to a nohup file so you can review output later.

Master Linux job control by viewing, stopping, killing, and resuming shell jobs with the jobs command, PIDs, and signals, including plus and minus signs that mark default jobs.

Learn to install openSUSE Leap using the lib offline image, set up a Hyper-V or VirtualBox VM, choose KDE or GNOME, enable online repositories, and configure partitions.

Explore managing users and groups with YaST, including creating and editing users, assigning groups like DevOps, configuring authentication, and handling root and login settings for a Linux system.

Learn to manage Linux users and groups with YaST by creating a new user, configuring password policies, disabling auto login, and assigning group memberships for secure access.

Learn to configure primary and secondary languages in YaST, switch language and regional settings, adjust time zone, hardware clock, and NTP synchronization for a multilingual Suse Linux KDE desktop.

Explore cloud based computing, file sharing, and online collaboration, and learn how services like OneDrive, iCloud, and Google Drive enable syncing and remote access over the internet.

Learn YaST, the yet another setup tool for SUSE Linux Enterprise Server administrators, with ncurses and graphical modes. Master the YaST control center, module navigation, and software installation.

Understand CAC config as a front end to rpm and system services, translating changes into /etc/sysconfig and final config files, and acting as a YaST backend.

Learn to use udevadm to query device attributes, monitor udev events in real time, and understand kernel and block device details for hands-on Linux administration.

Explore how /proc/interrupts reveals current IRQ assignments and how devices share IRQs across CPU cores. Use watch and grep to monitor interrupts in real time for troubleshooting on Linux systems.

Explore udev configuration with the udevadm command, query attributes of block devices, and monitor real-time events to troubleshoot hardware interactions.

Master kernel module management with modprobe to load modules and their dependencies, verify loaded modules with lsmod, and remove modules as needed, while detaching loop devices using losetup for troubleshooting.

Install the btrfs file system module and utilities on Red Hat Enterprise Linux, and master package management and troubleshooting with dnf, repositories, and snap packaging.

Detect usb devices on linux with lsusb, view verbose details with lsusb -v and udevadm, and monitor real-time changes using watch lsusb and the usb devices tree.

Use dmesg for real-time Linux kernel monitoring and troubleshooting with human-friendly timestamps and color, then filter with grep, view logs via tail, and watch with -w.

Explore Linux runlevels for maintenance and troubleshooting, from single-user mode to multi-user with networking or GUI, and learn how to check, switch, and recover using runlevel and rescue target commands.

The lspci command reveals PCI devices and provides IRQ settings, PCI bus speed, and vendor identification to analyze hardware configuration.

Learn how systemd handles manually mounted file systems not listed in fstab: create a mount unit with systemctl mount sync, and integrate mounts into systemd management for control and monitoring.

Learn to filter log entries between 8:00 and 8:59 a.m. using grep -E with an extended regex, matching the 08:xx:xx time pattern in the server log file.

Explore Linux command redirection using the greater than operator to write command output to files, creating or overwriting them; use double greater than to append.

Learn to rename files with a regex substitution that replaces a trailing txt with .bug.txt, inserting the dot before the .txt extension to transform output.

Learn how to use the man command to access section 1 manual pages for user commands, and specify sections to read the correct command or password file documentation.

Learn hard and symbolic links with the ln command, create hard links sharing an inode, and distinguish soft links by their different inodes for Linux file management.

Learn to use the grep -v option to invert matches and output non-matching lines in Linux, with hands-on practice filtering logs and refining text searches.

Demonstrate how mkfs creates the default ext2 file system when run with only a block device name, and verify it with the file command on a Debian 11 setup.

Inspect system v init configuration by examining symbolic links in rc runlevel directories to see when S (start) and K (kill) scripts, like apache2, execute.

Discover how to locate the package that owns a file on Debian using dpkg -S, with examples like debian_version, bin/bash, and etc/passwd to identify origins and issues.

Explore archive manipulation with gzip and tar, showing that gunzip on a gzip compressed tar containing a.txt and b.txt decompresses to a tar file, leaving the tar in the directory.

Understand the bios boot sequence and how some boot steps are configurable in the bios, and how the bios initiates the boot process after power on.

Understand how dpkg purge removes a package and its configuration files for a thorough clean-up. The lecture demonstrates this with htop and contrasts it with the standard remove.

Discover how Linux process management uses nice levels to adjust priority. Starting a process with the nice command yields a default nice value of zero, demonstrated by ps output.

Master bash output redirection on standard streams, learning how to redirect stdout to stderr with 1>&2. Explore how 2>&1 redirects stderr to stdout.

Discover how to print the current working directory in bash using the PWD command and the PWD environment variable with echo ${PWD}.

Identify root-owned processes using pgrep with -u root and with -f root, and compare outputs to see how user-based and full search differ.

Extract usernames and their login shells from the /etc/passwd file using cut with a colon delimiter, selecting fields 1 and 7, and format the output with column for readability.

Discover how to locate executables in Linux using the which command to display the full path and identify the correct command version across multiple installations.

Learn how to uninstall a package while retaining its configuration files using dpkg -r package name, and understand how this differs from a complete purge.

Identify the init process ID as 1 on system V init based systems, the first process at boot that remains PID 1 across reboots.

Learn to prevent a faulty kernel module from loading at boot by adding a blacklist line for the module to /etc/modprobe.d/blacklist.conf, ensuring a permanent solution.

Learn to use the zipper package manager for pattern-based installation on openSUSE and SUSE Linux Enterprise, matching names ending in foo with an asterisk, and try a dry run.

Master CompTIA Linux+ course teaches how to save in vi by using colon w with a filename, and exit with q or wq to preserve changes.

Learn to extract usernames and primary group IDs from /etc/passwd using cut with a colon delimiter and fields 1 and 4, and review related commands like cat and paste.

Master vi editor reverse and forward search, and basic text manipulation with R, F, and s. Practice on a test script to search echo and substitute characters.

Learn how unix-like process signals enable inter-process communication, with ctrl z sending sigstop to the foreground process to suspend it, while sigterm, sigkill, and sigint perform other actions.

Use the tee command to display command output on screen and save it to a file, enabling real-time viewing and logging for debugging and monitoring.

Identify the two key grub2 installation files: the LVM module and grub.cfg, the main configuration containing menu entries for a standard grub2 setup.

Locate root-owned files in /tmp and its subdirectories with the find command using -user root. Note the -print option versus implicit printing and the difference between -user and -uid.

Use the vi delete command with a numeric prefix to remove the current line and the following line, switching to normal mode when needed and practicing on a multi-line file.

Learn about the default reserved space in ext4 file systems: 5% for the root user, supporting essential tasks and reducing fragmentation, and how to adjust with tune to fs command.

Learn to use here documents in Linux, an input redirection method with cat and a delimiter to input multi-line text until end of file, without external files.

Learn how to modify the ext3 file system check interval to 200 days for /dev/sda1 using the tune to fs command, balancing system integrity with boot efficiency.

Learn to convert Windows line endings to Linux format using the tr command by deleting carriage returns, demonstrated on a text file such as userlist.txt with output to newlist.txt.

Learn how process signals control execution: pressing ctrl+C sends SIGINT to interrupt and terminate a process gracefully, while ctrl+Z suspends it and fg resumes.

Install grub boot files into the active file system and the boot loader onto the first disk with grub install dev SDA, using sudo privileges.

Learn how apt-get dist upgrade updates all installed packages, intelligently handles dependencies, and may remove obsolete packages to keep Debian-based systems current.

Learn how to list all installed packages on an RPM-based system using rpm --query --all, the go-to tool for querying the Red Hat Package Manager.

Install Grub2 into the master boot record of the third disk using the grub install dev sdc command with sudo, noting device names may vary.

Append an ampersand to a command to run it in the background of the shell, freeing the terminal for other tasks and enabling foreground control with the bg command.

When cloning a virtual machine, modify the D-Bus machine ID and SSH host keys to maintain security, while partition scheme, filesystem, and root permissions typically need not change.

Learn how process niceness affects CPU scheduling: regular users can set a maximum niceness of 19 with the nice command, lowering priority, while only root can assign negative values.

Learn to recover an inconsistent ZFS file system after a power outage by running ZFS repair on an unmounted dev sda3, avoiding forced mounts and unnecessary mount options.

Identify valid reasons not to use hard links in Linux, with the key point that hard links are restricted to a single filesystem and cannot link files across filesystems.

learn the standard location of man pages in linux: the usr share man directory, per the filesystem hierarchy standard, and how the man command searches this path for documentation.

Remove the directory named backslash dir from the home directory with rmdir, treating the backslash as an escape character.

Explore how the shell processes commands using the type command, distinguishing built-ins from external executables located in paths like /bin and /usr/bin, with practical examples.

Learn to display inode numbers using ls -i and the stat command to view file metadata. Practice with a file like archive to see the inode and metadata in action.

View the contents of a gzip compressed tar archive using tar -ztf archive, enabling inspection without extraction. Create archives with tar -czf and list their contents with tar -ztf.

Master the split command to divide a large file into smaller chunks of a specified size. The lecture shows splitting a sample log into 100-line pieces.

Explore how initramfs, a compressed archive, powers the Linux boot by temporarily loading drivers before the kernel mounts the real root filesystem, with contents accessible post-boot in /run/initramfs.

Configure yum repositories across multiple files in /etc/yum.conf and /etc/yum.d using variables like baseurl, basearch, and releasever; changes take effect immediately.

Identify the Linux boot process, noting that sbin init is the first program started by the kernel under System V init, with PID 1, acting as parent of all processes.

Explore how grep uses regular expressions to search file contents. Grep stands for global regular expression print and searches for patterns, like IP addresses and status code 200.

Explore how hard links in backup software improve storage efficiency by sharing data and speeding backups through metadata operations, with limitations across file systems.

Explore how the find command uses the max depth option to limit search depth in nested directories, improving efficiency.

Explore how Linux containers use kernel-level process isolation and resource management for efficiency, while fully virtualized machines rely on hypervisors to run any operating system with emulated hardware.

Learn to use label and UUID in /etc/fstab to mount partitions reliably, replacing explicit device names and handling changes in hardware.

learn how to paste the previously deleted or yanked text below the current line in vi using the lowercase p command, with hands-on practice on a sample file.

Master the etc/fstab file structure and how six fields govern mounting during boot, including device name, mount point, filesystem type, options, dump frequency, and fs order.

Execute shell scripts without a subshell by using source or the dot operator to modify the current shell environment, and practice exporting variables in a script.

Restrict a user's interactive login by changing their shell to /bin/false, causing immediate logout on login attempts, and learn practical steps with a test user.

Master the tcp wrapper by configuring host-based access control to limit ssh and other services, including installing and enabling ssh, editing /etc/hosts.allow and /etc/hosts.deny, and testing restricted access.

Explore private ipv4 networks and the iana reserved ranges for private address assignment and private routing, including 10.0.0.0/8, 172.16.0.0/12, and 192.168.0.0/16; note that loopback and link-local ranges are not private.

Learn about braille display as a tactile interface for visually impaired users. A braille display physically represents characters with small raised dots, translating digital text into touch for accessible computing.

Learn how Linux assigns a user's primary group by inspecting the /etc/passwd password file, which stores primary group data and other user information in colon-separated fields.

Learn to identify valid IPv6 addresses by eight groups of four hexadecimal digits separated by colons, use a single double colon to compress zeros, and avoid invalid separators.

The hop limit field in the IPv6 header is decremented by each forwarding router to limit a packet's lifetime, and it sits in the main header, not an extension header.

Configure the dot forward file to route mail to additional recipients, with changes taking effect immediately; root can set forwarding for any address, while regular users modify only their own.

Explore IPv4 subnetting with a /28 example, identifying the network and broadcast addresses and the 65–78 host range with 14 usable addresses, plus the 255.255.255.240 mask.

Discover how the echo dollar dollar command displays the process ID of the current shell, enabling basic process management and scripting in Linux.

Explore Linux dns resolution by configuring /etc/resolv.conf keywords such as search and nameserver, with examples like adding a nameserver 8.8 and a search google.com.

Learn how to view all environment and shell variables in Linux with the env command, inspect common variables like PATH and HOME, and set new variables with export for debugging.

Explore how the /etc/services file maps service names to port numbers and protocols to enable network services. See http on 80 tcp, https on 443, ssh 22, and ftp 21.

Learn to create Linux user accounts with useradd, specifying the absolute path to the home directory (-d) and a numeric UID (-u), noting SSH keys require extra steps.

Use the dig dns query tool with the -t option to fetch records such as ns, mx, and a, and interpret output including nameserver references and text records.

Use systemctl list timers to view all active systemd timers, showing last and next trigger times and the units they activate; then check individual timer status with systemctl status.

Understand how IP routing relies on the most specific routing table match, directing to gateway 192.168.1.1 on eth0 for the 192.168.2.0/24 network, with default routes as fallbacks.

Explore DNS debugging on Linux by using the dig command to view name server responses and full query details, and compare it with other tools to diagnose DNS issues.

Linux stores passwords using shadow passwords: the /etc/passwd field shows an x, with the encrypted password kept in /etc/shadow, viewable only with sudo, enhancing security.

Identify the default ssh client options in the /etc/ssh/ssh_config file. Create a user-specific ssh config in ~/.ssh/config with host, hostname, and user entries.

Learn how Network Manager in Linux respects existing interface configurations by default and can be configured to use the distribution's network configuration mechanism, enabling seamless integration across distributions.

Explore file system comparison operators for the test command in Linux, focusing on dash a to check file existence and dash f to test regular files with bash scripting examples.

Learn how to constrain journalctl outputs using the since and until time frame parameters, with practical examples from the last hour, yesterday to now, and specific timestamps.

Explore network manager states for Linux connectivity, focusing on portal and full connectivity, and learn to verify states with the NetworkManager CLI.

Discover how to display and monitor print queue jobs in Linux using lpstat and lpq, with hands-on practice checking current jobs and queue status.

Modify password expiry with the chage command to set minimum and maximum days, last password change date, account expiration, and warning days for secure multi-user management.

Discover the virtual machine video output protocol and how spice delivers low-latency, high-quality graphics from a VM's video card, unlike general desktop environments and remote protocols.

Understand the xorg.conf X11 configuration file's section-based structure, where each section begins with a line containing section name and ends with a line containing end section, with options placed between.

Discover how ipv6 eliminates broadcast addresses and relies on multicast for efficient network communication, while tcp and udp stay the same and ipv4 addresses require translation or encapsulation for coexistence.

Explore the bash login shell file reading order and why .bashrc is not read directly; learn how bash_profile and other startup files source it.

Learn how nmcli device wifi connect creates and activates a new wifi connection, demonstrating Network Manager CLI usage, listing connections, and troubleshooting wifi on Linux.

Configure nsswitch.conf to control host name resolution by prioritizing local files before DNS, illustrating hosts: files DNS and how to modify the file with root access.

Explore how Network Manager uses Nmcli to manage connections, focusing on Ethernet, Wi-Fi, and bridge types, and learn to create, modify, and activate connections.

Configure global shell variables by editing /etc/profile to set environment variables for all users; define and export environment variables in the login shell startup file.

Learn to configure system-wide locale settings in locale.conf by setting LC_ALL and LC_TIME to control language, encoding, and date/time formats, with practical troubleshooting tips.

Understand sudo configuration syntax and user permissions, showing how no password and password directives govern Jane running bin kill and bin id without a password, while bin fdisk requires root password.

Explore Spice protocol features for remote computing: remote application access, USB device integration, and installing apps from a remote host, with X11 server interaction and no replacement of Xorg.

Learn how systemd timer units define when to activate services using timer section, including on boot seq, on unit activate seq, and on calendar, and practice creating a hello timer.

Explore how bash pipelines and a while read loop produce output from a six-number sequence. The lecture demonstrates reading three variables and echoing them in reverse to yield 345621.

Master the date command in Linux to set the system date and time and display time in a custom format. It cannot calculate time spans or print calendars.

Learn to use the find command to locate root-owned files with the setuid bit by running find / -user root -perm 4000, aiding security audits and system administration.

Set the linux system time zone to Canada eastern time by linking /usr/share/zoneinfo/Canada/Eastern to /etc/localtime with ln -s, and verify changes using time date ctl.

Explore the dot profile file in a user's home directory and why it must use valid shell script syntax since it is sourced at login, not executed.

Identify the standard tcp port for https: 443, enabling secure encrypted web communication. Contrast it with ports 25, 80, 8080, and 636.

Examine the etc. group file to identify the group name, group id, and the user list, noting that home directories and group descriptions are not included.

Explore how SSH host keys establish server identity to clients, enabling trust and preventing man-in-the-middle attacks, by presenting keys and their fingerprints.

Learn how to assign the output of the date command to a shell variable using command substitution, with the correct syntax mydate=$(date).

Identify the duties of display managers like Xdm and KDM: handling user logins and launching the desktop environment. They do not configure hardware or manage screen locking.

Learn how the ping command uses ICMP echo requests and responses to test host reachability, measure round-trip time, and analyze packet loss.

Learn how the iburst option in Chrony speeds up initial synchronization by sending a burst of packets to an NTP server.

Explore systemd journald's capabilities, including coexistence with syslog, forwarding logs to syslog, preserving metadata like UID and PID, and supporting syslog facilities such as kernel, user, and auth.

Set core file size limits with the ulimit command to prevent large dumps while preserving debugging data, and verify with ulimit -c before making changes permanent in shell config.

Discover how the /etc/shadow file securely stores hashed passwords separate from /etc/passwd, explains hash formats, and why direct edits are discouraged in favor of using passwd.

Learn how to list all defined bash variables and functions with the set command, and distinguish shell variables from environment variables.

When cron allow and cron deny are absent in /etc, cron adopts an open policy, letting all users create crontabs. Administrators should apply access controls.

Learn how to restrict a user from scheduling tasks with the at command by adding their username to /etc/at.deny, demonstrating the blacklist approach and validating with a test.

Discover how the bash shebang line (#!) in the first script line specifies the interpreter path and optional arguments, enabling flexible script execution.

Explain SSH key pairs, where the private key must never be revealed and the owner creates the pair; show RSA 4096 key generation and adding the public key to authorized_keys.

Use udevadm monitor to view kernel udev events in real time, and inspect current IRQ assignments with cat /proc/interrupts; the proc filesystem provides kernel data for hardware details.

Explore udev configuration in Linux by locating files in /etc/udev and the rules.d directory. Learn how modprobe loads kernel modules with dependencies.

Learn to list USB devices with lsusb and to query device details via udevadm info, the go-to tool for examining the udev database.

Learn how to use the dmesg command to view the kernel ring buffer on Linux, including real-time monitoring with -w, filtering by level, and locating logs in /var/log/dmesg.