All Episodes

Welcome to the Linux+ Audio Course

Episode 105 — Memory pressure: swapping, OOM, killed processes, memory leaks

Episode 104 — CPU and load: high CPU, load average, context switching, slow startup

Episode 103 — Secure connectivity breakage: SSH, certs, repos, ciphers, negotiation issues

Episode 102 — Permission failures: ACLs, attributes, account access, why it used to work

Episode 101 — SELinux failures: policy vs context vs booleans, how to think, not panic

Episode 100 — Link problems: link down, negotiation failures, can’t ping server reasoning

Episode 99 — Interface issues: MTU mismatch, bonding, dual-stack surprises

Episode 98 — DHCP failures and IP conflicts: symptoms and best-next-step logic

Episode 97 — DNS vs routing vs firewall: fast isolation with minimal commands

Episode 96 — System and service failures: systemd unit failures, PATH misconfig, missing drivers

Episode 95 — Package and dependency breakage: what fails, what to check first

Episode 94 — Mount and write failures: won’t mount, read-only, partition not writable

Episode 93 — Disk full puzzles: filesystem full vs inode exhaustion vs runaway logs

Episode 92 — Corruption and weird crashes: kernel or data corruption, segmentation faults

Episode 91 — Boot failures: GRUB misconfig, kernel panic, and first-response triage

Episode 90 — Alerting design: thresholds, events, notifications, logging, aggregation patterns

Episode 89 — Data collection concepts: SNMP, traps, MIBs, agent vs agentless

Episode 88 — Monitoring language: SLA vs SLI vs SLO and what healthy means

Episode 87 — AI best practices for ops: safe use cases, verification, governance, prompt habits

Episode 86 — Recovery skills: reset vs stash, tags, safe undo thinking

Episode 85 — Branching and merging: merge vs rebase, squash, conflict mindset

Episode 84 — Daily Git workflow: init, clone, add, commit, log, diff, config, gitignore

Episode 83 — Python for admins: venvs, dependencies, modules, data types, PEP 8 awareness

Episode 82 — Return codes and arguments: $?, positional params, error handling patterns

Episode 81 — Functions and IFS/OFS: why scripts break on spaces and how to avoid it

Episode 80 — Loops: for, while, until with real admin-style use cases

Episode 79 — Conditionals: if, case, string vs numeric comparisons, common test flags

Episode 78 — Expansion and substitution: variables, quoting, subshells, command substitution

Episode 77 — Bash script structure: shebang, execution, safety defaults, readability

Episode 76 — Orchestration overview: Kubernetes objects plus Swarm and Compose mental models

Episode 75 — CI/CD and GitOps: pipelines, shift-left testing, DevSecOps vocabulary

Episode 74 — OpenTofu and Terraform concepts: providers, resources, state, drift, APIs

Episode 73 — Puppet at exam depth: classes, modules, facts, certificates, agent vs agentless

Episode 72 — Ansible at exam depth: inventories, playbooks, modules, ad hoc, facts, agentless

Episode 71 — IaC overview: what problems it solves and how exams describe it

Episode 70 — Integrity and destruction: AIDE, rkhunter, verification, secure erase, supply chain, banners

Episode 69 — Vulnerability and standards thinking: CVE/CVSS, OpenSCAP, CIS Benchmarks

Episode 68 — Data in transit and certs: TLS stacks, WireGuard basics, hashing, weak algorithms

Episode 67 — Data at rest: GPG vs LUKS2, keys, and what good enough means

Episode 66 — Safer accounts: restricted shells, avoiding root habits, practical guardrails

Episode 65 — Password policies and lockouts: complexity, history, pam_tally2 concepts

Episode 64 — SELinux and secure access: contexts, booleans, plus SSHD hardening and fail2ban themes

Episode 63 — Permissions and control: chmod, chown, special bits, umask, ACLs, file attributes

Episode 62 — Sudo and privilege: sudoers structure, safe delegation, common misconfig patterns

Episode 61 — NAT and forwarding: DNAT, SNAT, PAT, ip_forward, troubleshooting frames

Episode 60 — Netfilter concepts: iptables, nftables, ipset, stateful thinking, rule intent

Episode 59 — Logging pipeline: journald, rsyslog, logrotate, how logs stay useful

Episode 58 — Audit basics: what auditd is for, and what audit rules capture

Episode 57 — ufw approach: rule intent, common mistakes, and why it blocks traffic

Episode 56 — firewalld mental model: zones, services vs ports, runtime vs permanent

Episode 55 — Directory-backed auth: LDAP vs Kerberos vs Samba, in exam language

Episode 54 — Identity integration concepts: SSSD, Winbind, realm basics, and where they fit

Episode 53 — Linux auth story: PAM, polkit, and what controls what

Episode 52 — Container networking: port mapping, network types, privileged vs unprivileged tradeoffs

Episode 51 — Volumes and storage: persistence, mapping, overlay concepts, SELinux context awareness

Episode 50 — Running containers: env vars, logs, exec, inspect, and what each is for

Episode 49 — Image operations: pull, build, tag, layers, and Dockerfile directive behavior

Episode 48 — Container fundamentals: runtimes and the image/container boundary

Episode 47 — systemctl troubleshooting mindset: status, logs, daemon-reload, enable, mask patterns

Episode 46 — systemd units and targets: services, timers, mounts, targets, dependencies

Episode 45 — Basic service configs at exam level: DNS, NTP, DHCP, HTTP, mail, what breaks

Episode 44 — Language ecosystems: pip vs cargo vs npm, and how they fail differently

Episode 43 — Repositories and trust: enabling/disabling, third-party risk, signatures, exclusions

Episode 42 — Packages vs source: dependencies, conflicts, and clean rollback thinking

Episode 41 — Scheduling: cron vs anacron vs at, and choosing the right one

Episode 40 — Signals and job control: stop, continue, kill, foreground/background decisions

Episode 39 — Reading process reality: ps/top/htop/proc and what to look for first

Episode 38 — Password aging and lockouts: expiration, chage concepts, and common gotchas

Episode 37 — Account lifecycle: add, modify, delete, shells, and least-privilege habits

Episode 36 — Users, groups, and identity: UID, GID, EUID, EGID explained simply

Episode 35 — Links and metadata: hard vs symbolic, stat thinking, and why it matters

Episode 34 — Finding things fast: locate vs find, and which tool fits decisions

Episode 33 — File operations you’re tested on: create, move, copy, remove safely

Episode 32 — libvirt and virsh mental model: what these tools manage and how questions frame them

Episode 31 — VM storage and lifecycle: images, snapshots, migrations, and network modes

Episode 30 — Virtualization basics: KVM/QEMU, VirtIO, and where performance comes from

Episode 29 — Backups without labs: archive vs sync vs image, restore validation thinking

Episode 28 — Text processing decision drill: grep, awk, sed, sort, uniq, cut, xargs in context

Episode 27 — Redirection and pipes: how data flows through stdin, stdout, stderr

Episode 26 — Shell environment essentials: PATH, HOME, PS1, and startup files

Episode 25 — Interface configuration concepts: NetworkManager vs Netplan, what changes where

Episode 24 — Network tools by intent: test connectivity, inspect sockets, capture packets

Episode 23 — Name resolution internals: hosts, resolv.conf, nsswitch.conf, failure modes

Episode 22 — Network troubleshooting workflow: link → IP → route → DNS → service bind

Episode 21 — Capacity vs inodes: disk full when it isn’t, and the mental checklist

Episode 20 — Network mounts overview: NFS vs SMB/Samba and what symptoms look like

Episode 19 — Mount options that matter: security and stability tradeoffs

Episode 18 — Mounting mastery: fstab, transient mounts, and avoiding boot-time surprises

Episode 17 — RAID basics for Linux+: what it protects, what it doesn’t, status thinking

Episode 16 — LVM part 2: grow, extend, resize safely, and common failure patterns

Episode 15 — LVM part 1: PV, VG, LV concepts and why LVM exists

Episode 14 — Filesystems in practice: ext4 vs xfs vs btrfs vs tmpfs, when and why

Episode 13 — Partitioning decisions: MBR vs GPT, growth, identifiers, verification

Episode 12 — Storage mental model: block devices → partitions → filesystem → mount

Episode 11 — initrd tools and custom hardware contexts: embedded and GPU use cases

Episode 10 — Hardware discovery mindset: CPU, memory, devices, and what looks wrong

Episode 9 — Kernel modules: what they are, when they load, how to reason about them

Episode 8 — Architectures and GUI stack: x86_64 vs AArch64, X vs Wayland, licensing basics

Episode 7 — Distros and packages: RPM-based vs dpkg-based thinking

Episode 6 — FHS tour: why where things live matters on exam questions

Episode 5 — PXE boot in plain English: where it fits and what can fail

Episode 4 — Boot configs and kernel parameters: what they change and why it breaks

Episode 3 — Boot flow story: bootloader → kernel → initrd/initramfs → userspace

Episode 2 — Audio-only study method: recall loops, pause-and-answer drills, exam-day mindset

Episode 1 — How Linux+ (XK0-006) tests you: domains, PBQs, pacing