Linux Server Admin with Fexingo: Sysadmin, Bash, and Server Engineering
Linux Server Admin with Fexingo is a podcast about practical Linux server administration, hosted by Lucas and Luna. Each episode focuses on a single sysadmin problem, such as diagnosing slow database queries, fixing failing cron jobs, tuning Nginx, hardening SSH, or automating backups with rsync and rclone. Lucas brings journalistic context from real-world outages, while Luna adds hands-on experience and challenges unnecessary complexity. The show avoids vendor hype and favors simple, stable tools and habits that keep production services online. It is aimed at solo IT generalists, DevOps engineers, and anyone responsible for managing servers.
Episodes
How Linux Servers Handle Disk I/O Bottlenecks
We dig into the silent killer of server performance: disk input and output bottlenecks. While CPU and memory get all the attention, a saturated storage subsystem can bring even the most powerful Linux machine to its knees. We look at how modern block layer scheduling, specifically using the Ky scheduler versus mq-deadline, impacts throughput under heavy load. We also examine the role of NVMe drive
Linux Server Storage Efficiency With ZFS
We look at how modern Linux servers are shifting from traditional RAID controllers to software-defined storage pools like ZFS, using the example of a mid-sized data firm that cut hardware costs by forty percent while improving data integrity. We explore deduplication ratios, snapshot overhead, and why read-heavy workloads benefit most from this architecture, especially as storage prices remain vol
How Linux Servers Prevent Silent Data Corruption
Most sysadmins worry about servers crashing or slowing down, but the real nightmare is silent data corruption—where a server writes bad data without any error logs. In this episode, Lucas and Luna dive into the mechanics of how modern Linux filesystems like ZFS and Btrfs use end-to-end checksumming to detect and fix these invisible errors before they compromise your database integrity. We look at
Linux Server Security Hardening Without Breaking Production
This episode examines the specific friction between modern Linux security frameworks and legacy application compatibility. We focus on a concrete case involving SELinux policy enforcement failures in containerized environments, analyzing how misconfigured boolean flags caused production outages for mid-sized fintech firms. Lucas breaks down the mechanics of mandatory access control versus discreti
Linux Filesystem Journaling Explained
We break down why ext4 and XFS journaling matters for data integrity during unexpected power loss. Lucas walks through the mechanics of metadata vs. data journaling, while Luna shares a war story about restoring a corrupted database after a server crash. We cover how to check your current journal status using tune2fs and xfs_info, and discuss when full data journaling is actually worth the write-a
Linux Cgroup v2 Resource Limits Explained
We break down Linux cgroup v2 hierarchical resource control. Unlike the older cgroup v1 setup, version two simplifies how servers manage CPU, memory, and I/O limits for containers and processes. Lucas and Luna walk through a real-world scenario where a misconfigured web server starved the database of resources, causing latency spikes across the stack. We explain why unified hierarchy matters, how
How Linux Servers Handle CPU Contention
We explore the invisible mechanics of CPU contention on Linux servers, focusing on how the kernel’s scheduler manages competing processes when resources are scarce. Using a concrete case study from a major cloud provider in October two thousand twenty-six, we break down how cgroups v2 and real-time scheduling priorities prevent critical services from starving during peak load. You will learn exact
Linux Kernel Live Patching Without Downtime
How enterprises like Red Hat and Canonical are keeping Linux servers running without reboots by injecting code directly into the kernel memory. We break down the mechanics of kpatch and live patching, why security teams finally stopped fearing midnight updates, and the specific risks of breaking state when you modify running code. This is a deep dive into the engineering that makes zero-downtime i
How Linux Servers Handle Network Time Protocol Sync
Most sysadmins treat clock drift as a background nuisance until it breaks authentication tokens or skews distributed logs. This episode drills into the mechanics of Network Time Protocol on Linux, focusing on why a ten-second drift can cascade into total service failure in microservices architectures. We examine how chrony replaces ntpd, how stratum levels propagate time from hardware timestamps,
Why Linux Servers Stall Under Load
We look at the specific moment a Linux server stops responding not because of hardware failure, but due to kernel scheduling latency. Using a real-world case of a database server experiencing microsecond delays during peak traffic, we explore how CPU frequency scaling and interrupt coalescing create invisible bottlenecks. This episode explains why your monitoring tools show healthy CPU usage while
Linux Server Performance Tuning Secrets
Lucas and Luna dive into the often-overlooked world of Linux server performance tuning, focusing on the critical role of kernel parameters in optimizing system responsiveness. They explore how small adjustments to settings like net.core.somaxconn can prevent connection drops during high-traffic events, using a real-world example of an e-commerce platform that saw a 30 percent improvement in throug
How Linux Servers Scale Without Breaking
Most sysadmins think scaling is about throwing more hardware at a problem. But when traffic spikes during a flash sale or a viral product launch, the bottleneck isn't always CPU or memory—it's often the kernel itself. In this episode, we look at how major infrastructure providers handle connection storms using specific kernel parameters like tcp_tw_reuse and backlog tuning. We break down why your
Why Linux Servers Fail Under Load
We dig into the specific mechanics of why Linux servers stall under load, focusing on the often-overlooked issue of CPU scheduler latency and context switching overhead. Lucas breaks down how high-concurrency environments hit a wall not because of memory or disk, but because the kernel spends more time managing processes than executing them. Luna challenges the common advice to simply add more cor
Linux Network Namespaces and Container Security
We drill into how Linux network namespaces isolate container traffic, using a specific case study of a misconfigured ingress gateway that leaked internal API keys. Lucas walks through the mechanics of veth pairs and iptables rules, while Luna challenges the assumption that isolation equals security. We look at the real-world cost of assuming default deny policies work without explicit enforcement,
Linux Server Security Hardening Without Breaking Production
In this milestone episode, we move past the usual panic of midnight outages and disk rot to tackle a quieter but more persistent threat: configuration drift. We examine how major tech infrastructure teams use immutable infrastructure patterns and automated compliance scanning to keep Linux servers secure without manual intervention. Lucas walks through the specific shift from patching individual b
How Linux Servers Handle Silent Data Corruption
We talk about how Linux servers handle silent data corruption, specifically the risks of storage stacks and the role of end-to-end checksumming. Lucas and Luna explore why traditional RAID isn't enough to prevent bit rot from affecting your application layer. We look at specific cases where silent errors in disk caches or network transfers lead to silent database corruption, and how tools like ZFS
How Linux Kernel Patching Prevents Midnight Crashes
Most sysadmins think patching is just about security, but Lucas and Luna explore how kernel updates solve silent performance degradation. They dive into a specific case where a single cgroup v2 fix reduced latency spikes by forty percent in high-concurrency environments. This episode breaks down the difference between stable releases and long-term support kernels, explaining why waiting for the ne
Why Linux Servers Leak Memory Without Crashing
We explore the silent killer of Linux server uptime: memory leaks that don't trigger OOM kills. Using a specific case study of a Python web service leaking file descriptors, we break down how to use smem and systemd-analyze to find the bleed before it hits swap. This is not about crashes; it is about the slow death of performance where the server stays alive but becomes unusable.
#LinuxServerAdmi
Why Linux Servers Fail at Midnight
We dig into the specific mechanics of why Linux servers often appear to fail or degrade precisely around midnight. It is not magic, nor is it always a ghost in the machine. We examine how cron jobs, log rotation policies, and database maintenance windows collide in high-traffic environments. Lucas walks through a real-world case where a routine logrotate task triggered a file descriptor leak, caus
Why Linux Servers Need Better Logging
Lucas and Luna dive into the silent crisis of log rotation failures in modern Linux server environments. With system journals growing unchecked, administrators often find themselves staring at full disks or corrupted trace files during critical outages. They break down how systemd-journald and rsyslog handle high-volume data streams, using a concrete example of a web server that lost its audit tra
Linux Server Memory Swappiness Tuning Guide
Most Linux servers default to a swappiness value of sixty, but for database and application workloads, that number often causes unnecessary disk thrashing. In this episode, we dig into the specific mechanics of how the Linux kernel decides what to swap out under memory pressure. We look at why setting swappiness to ten or even zero can stabilize response times for critical services like PostgreSQL
How Linux Servers Handle Memory Leaks Without Rebooting
Memory leaks are the silent killer of long-running Linux servers, often causing gradual performance degradation until a reboot is forced. In this episode, we explore how modern Linux administrators diagnose and mitigate memory pressure using tools like Valgrind, Valkey, and cgroups to isolate runaway processes without disrupting live services. We look at a specific case study where a custom Python
Why Linux Servers Stall Under Load
We examine the hidden cost of context switching in high-concurrency Linux servers. Using a real-world case from a major cloud provider, we break down how thousands of tiny threads fighting for CPU time create latency spikes that bypass traditional monitoring. Lucas and Luna explore cgroup limits, CPU affinity, and why your server feels fast until it doesn’t.
#LinuxServer #Sysadmin #BashScripting
Why Linux Servers Need Better Logging
We examine the hidden cost of noisy logs on Linux servers. Most sysadmins ignore disk I/O from excessive logging, but one specific configuration change can reduce write amplification by forty percent. We look at how rsyslog handles high-volume events and why your storage tier matters more than you think. This is a practical deep dive into server hygiene for technology professionals who manage infr
How Linux Servers Prevent Silent Data Corruption
Most sysadmins worry about crashes, but silent data corruption is the quiet killer of enterprise reliability. In this episode, Lucas and Luna break down how modern Linux servers use ZFS checksums and RAID-Z redundancy to detect bit-rot before it destroys databases. We look at a specific case where a financial services firm lost months of transaction logs due to undetected sector errors, and why to
How Linux Servers Handle Silent Disk Rot
Silent data corruption is the most insidious threat to modern Linux servers, often going undetected until it is too late. In this episode, we explore the mechanics of bit rot and how enterprise storage stacks defend against it using end-to-end checksums, scrubbing, and redundancy protocols like ZFS and Btrfs. We examine a real-world scenario where a silent sector failure compromised an unverified
How Linux Servers Survive Midnight Outages
We dissect the hidden mechanics behind why Linux servers often fail at midnight, focusing on the interplay between cron job scheduling and system resource exhaustion. This episode moves beyond simple disk quotas or network bonding to explore how silent background processes can accumulate memory leaks or lock files, causing cascading failures just as traffic patterns shift. We examine a specific ca
Linux Server Storage Caching with bcache
Lucas and Luna dive into bcache, the Linux kernel block layer caching system that marries high-speed SSDs with slower HDDs for enterprise-grade performance. They explore how write-back versus write-through modes affect data integrity and throughput, using a specific case of a legacy database migration to illustrate why proper cache invalidation matters more than raw speed. The conversation covers
How Linux Servers Handle Silent Disk Rot
Most sysadmins trust their RAID arrays to fix bad sectors automatically, but what happens when the redundancy fails silently? In this episode, Lucas and Luna explore the quiet crisis of bit rot on enterprise storage. We look at a specific case where a financial services firm lost critical transaction logs not because of a drive failure, but because of undetected data corruption over eighteen month
Linux Server Cgroups Resource Isolation Explained
Most sysadmins know how to restart a crashed service, but fewer understand how Linux actually prevents one runaway process from starving the rest of the machine. In this episode we dive into cgroups and namespace isolation. We look at how modern container runtimes like Docker rely on these kernel features to enforce memory limits and CPU shares. Lucas breaks down the difference between control gro
Why Linux Servers Stall Under Load
Most sysadmins blame CPU saturation when their Linux server stalls, but the real culprit is often lock contention in the kernel. We dive into how mutexes and spinlocks create invisible bottlenecks under high concurrency, using a specific case from a major fintech platform that saw latency spike despite low CPU usage. Lucas walks through the mechanics of lock escalation and how eBPF can pinpoint ex
How Linux Servers Handle High Concurrency Without Crashing
We dig into the specific engineering behind how modern Linux servers manage thousands of simultaneous connections without hitting a wall. Instead of relying on traditional process-per-connection models that drain memory, we explore the event-driven architecture powering high-throughput services today. Lucas and Luna break down the trade-offs between thread pools and non-blocking I/O, using concret
How Linux Servers Handle High Concurrency Without Crashing
We dissect the architecture behind high-concurrency Linux servers, focusing on how modern applications manage thousands of simultaneous connections without choking. Lucas and Luna explore the shift from thread-per-connection models to event-driven architectures using tools like Nginx and Node.js. We look at specific bottlenecks in memory allocation and context switching, examining why a simple mis
How Linux Servers Handle Failures Gracefully
We explore why Linux servers rarely crash on their own and how they manage inevitable hardware failures through careful design. Lucas and Luna discuss the concept of graceful degradation, focusing on how modern server architectures handle component failures without taking the whole system down. We look at specific examples from cloud infrastructure and traditional data centers, examining how redun
Why Linux Servers Fail at Midnight
Every sysadmin has seen the midnight crash: a server that runs flawlessly all day but dies when the backup job hits. In this episode, Lucas and Luna break down the specific mechanics of why Linux servers fail under pressure during off-peak hours. They examine disk I/O saturation, swap thrashing, and the hidden costs of cron jobs. Using real-world examples from shared hosting environments, they sho
Linux Server Network Time Synchronization
We look at why Linux servers drift off time, the dangers of relying on local hardware clocks, and how to properly configure chronyd or systemd-timesyncd for enterprise-grade accuracy. Lucas walks through the NTP protocol basics, stratum levels, and the critical difference between software synchronization and hardware timestamping. Luna challenges the assumption that one source is enough, exploring
Why Linux Servers Crash at Midnight
Midnight rollbacks are the silent killer of server stability. We examine why scheduled maintenance windows fail more often than you think, using a real-world case where a routine kernel update triggered a cascading failure across three data centers. Lucas and Luna break down the hidden dependencies in systemd timers, the importance of canary deployments, and how to audit your own cron jobs for lat
Linux Kernel Live Patching Without Downtime
We examine how Linux servers stay online during critical security updates using live kernel patching, a technique that injects code changes into running memory without rebooting. Lucas and Luna break down the mechanics of kpatch and Ksplice, exploring how enterprises like Red Hat and Oracle maintain uptime while fixing zero-day vulnerabilities. You will learn why traditional reboots are becoming u
How Linux Servers Handle High Concurrency Without Crashing
Most sysadmins think performance is about CPU speed or RAM capacity. It isn't. The real bottleneck in modern Linux server engineering is how the kernel schedules context switches and manages memory pages under load. We look at the specific trade-offs between traditional thread-per-connection models and event-driven architectures using Nginx and Redis as case studies. You will learn why a single co
Linux Server Security Beyond the Kernel with eBPF
Lucas and Luna discuss how modern Linux security has shifted from perimeter firewalls to kernel-level visibility using eBPF tools like Cilium and Falco. They explore a specific case study of a fintech startup that reduced false positives in intrusion detection by forty percent after replacing legacy host-based agents with eBPF-based observability. The hosts explain why this shift matters for sysad
Linux Kernel Live Patching Without Downtime
We explore how live kernel patching allows system administrators to apply critical security updates to Linux servers without a single second of downtime. Using Red Hat’s kpatch and Canonical’s livepatch as primary examples, we break down the technical mechanism of ftrace-based function replacement and why this capability is becoming standard in enterprise infrastructure. The conversation covers th
Linux Server Security Beyond the Firewall
We look at why traditional perimeter security fails in modern Linux environments and how mandatory access control systems like SELinux and AppArmor shift the defense from blocking external traffic to restricting internal process behavior. Lucas walks through a specific incident where a compromised web service was contained because of strict MAC policies, while Luna explores the operational frictio
Linux Server Memory Leak Detection
Lucas and Luna dissect the silent killer of Linux servers: memory leaks in long-running processes. They examine a real-world case where a custom Python web service consumed gigabytes of RAM over six months, masking the issue until it triggered OOM kills. The hosts walk through the specific diagnostic workflow using smem, /proc/pid/smaps, and heap profiling to pinpoint the exact allocation that nev
How to Use Linux Server Network Bonding for Redundancy
In this episode of Linux Server Admin with Fexingo, Lucas and Luna break down Linux network bonding—what it is, why it matters for server reliability, and how to configure it without losing your sanity. They walk through the main bonding modes (active-backup, balance-rr, 802.3ad), explain the traffic-balancing math behind balance-xor and balance-alb, and share hard-won lessons from real data-cente
Linux Server Disk Encryption with LUKS and TPM Unlocking
In this episode of Linux Server Admin with Fexingo, Lucas and Luna tackle the practical side of full-disk encryption on Linux servers. They focus on LUKS2 and how to set up automatic unlocking with a TPM 2.0 chip, a feature that balances security with the reality of unattended reboots. The conversation covers the essentials: what LUKS is, how TPM-based unlocking works, and the trade-offs involved.
Linux Server IPv6 Migration without Breaking Things
IPv6 is no longer optional, but migrating a Linux server without breaking existing services takes planning. Lucas and Luna walk through the practical steps: dual-stack configuration, firewall rules with nftables, and troubleshooting common pitfalls. They use a real-world example of moving a web server to dual-stack, covering address selection, DNS updates, and how to test connectivity with tools l
Linux Server Disk Quotas for Shared Hosting
In this episode, Lucas and Luna dive into the practical world of Linux server disk quotas, focusing on how to manage storage on shared hosting environments. They walk through the difference between user and group quotas, the XFS and ext4 filesystem support, and the exact commands to set and enforce limits using quota and setquota. They discuss real-world scenarios like runaway logs, user temp dire
How to Use Linux Server Systemd Journald Persistent Storage
In Episode 167 of Linux Server Admin with Fexingo, Lucas and Luna dive into systemd journald persistent storage. They explain why the default volatile journal can lose critical logs on reboot, how to enable persistent storage with a simple config change, and the practical implications for server troubleshooting and audit compliance. Using a real-world example of a crashed database server, they wal
Linux Server Systemd Services That Restart Themselves
In this episode of Linux Server Admin with Fexingo, Lucas and Luna dive into the art of building self-healing systemd services. They explain why a simple restart directive isn't enough, how to use RestartSec and StartLimitIntervalSec to avoid crash loops, and how to combine systemd with health checks using ExecStartPre and a custom watchdog script. They also cover the difference between Restart=on
How to Use Linux Server Systemd Timers for Scheduling
In this episode, Lucas and Luna dive into systemd timers as a modern replacement for cron jobs on Linux servers. They explain why timers offer better integration with systemd services, more precise scheduling options, and built-in logging and dependency handling. The hosts walk through real-world examples, from simple daily backups to complex calendar-based tasks, and discuss how to debug timers u
How to Use Linux Server LVM Cache for Faster Storage
In this episode of Linux Server Admin with Fexingo, Lucas and Luna dive into LVM cache — a feature that lets you accelerate slower spinning disks with fast NVMe or SSD storage without rebuilding your filesystem. They explain how LVM cache works, using a practical example of a mail server with a 10TB HDD array and a 512GB NVMe drive. Lucas walks through the key commands and concepts: cache pools, c
How to Use Linux Server LVM for Flexible Storage
In this episode of Linux Server Admin with Fexingo, Lucas and Luna dive into Logical Volume Management (LVM) — the Linux storage technology that lets you resize filesystems on the fly, take snapshots, and manage disk space without downtime. They explore a real-world scenario: a database server that runs out of disk space on a Friday afternoon. Instead of panicking, you can add a new physical disk,
How to Use Linux Server Landlock for Unprivileged Sandboxing
In this episode, Lucas and Luna explore Landlock, the Linux security module that lets unprivileged processes sandbox themselves without root. They walk through a concrete example: running an untrusted binary that can only access a specific directory, using a simple C program and a few syscalls. They explain how Landlock compares to namespaces, cgroups, and seccomp, and why it's a game-changer for
How to Use Linux Server Systemd Socket Activation
In this episode, Lucas and Luna dive into systemd socket activation on Linux servers, showing how to make services like SSH and web servers start on demand and save memory. They explain the difference between socket units and service units, walk through a real example with a Python HTTP server, and discuss when socket activation makes sense—and when it doesn't. Along the way, they cover the pitfal
How to Use Linux Server tmpfs for RAM Backed Storage
In this episode of Linux Server Admin, Lucas and Luna dive deep into tmpfs on Linux servers — a filesystem that lives entirely in RAM. They explain what tmpfs actually is under the hood, how it differs from ramfs and swap-backed storage, and walk through a practical setup for a web server's session cache. You'll learn the exact mount options to use, how to set size limits so you don't OOM your box
How to Use Linux Server cgroups v2 for Resource Control
In this episode of Linux Server Admin with Fexingo, Lucas and Luna dive into the practical side of cgroups v2 on Linux servers. They start with a real-world scenario: a runaway process eating CPU and memory, and show how cgroups v2 can tame it. Topics include the unified hierarchy, the difference between cgroups v1 and v2, and how to create and manage cgroups with systemd and the cgroupfs interfac
How to Use Linux Server BPF Tools for Network Diagnostics
In this episode of Linux Server Admin with Fexingo, Lucas and Luna dive into the practical side of BPF (Berkeley Packet Filter) tools for network diagnostics on Linux servers. They walk through real-world scenarios where tcpdump and bpftrace are your best friends — from tracing slow DNS queries to spotting packet drops before they become outages. You'll learn how to use bpftrace one-liners to coun
How to Use Podman for Containers on Linux Servers
Lucas and Luna dive into Podman, the daemonless container engine that's gaining ground as a Docker alternative. They explain how Podman's rootless architecture improves security by design, walk through the practical differences from Docker—like the pod concept and systemd integration—and share real commands for running containers without a central daemon. If you're a sysadmin curious about why som
Mastering Linux Server Boot Diagnostics with Systemd
In this episode of Linux Server Admin with Fexingo, Lucas and Luna dive into the world of systemd boot diagnostics. With systemd now the default init system on almost every major Linux distribution, understanding how to debug slow or failed boots is a vital skill for any sysadmin. Lucas shares a real-world story of a server that took over 10 minutes to boot, and how a combination of systemd-analyz
How to Tune Linux Server TCP Stack for High Throughput
In this episode, Lucas and Luna dive into tuning the Linux server TCP stack for high-throughput workloads. They explain the key socket buffers, congestion control algorithms like BBR, and kernel parameters such as tcp_rmem and tcp_wmem. Using a real-world example of a media server pushing large files, they walk through practical adjustments, how to test improvements, and common pitfalls. By the en
How to Use BPFtrace for Linux Server Troubleshooting
In this episode of Linux Server Admin with Fexingo, Lucas and Luna dive into BPFtrace, a dynamic tracing tool for Linux that lets you see exactly what's happening on a live server without rebooting or recompiling. They explain how BPFtrace builds on eBPF to give you safe, low-overhead visibility into kernel and user-space events, and walk through practical examples like tracing file opens, trackin
How to Harden Linux Servers with Systemd Sandboxing
In this episode of Linux Server Admin, Lucas and Luna dive into systemd's built-in sandboxing features—a powerful yet often overlooked way to harden Linux servers. They explore directives like ProtectSystem, ProtectHome, PrivateTmp, NoNewPrivileges, and more, showing how these can limit the damage a compromised service can do. Using a real-world example of a web server, they demonstrate how to app
How to Use Linux Server Control Groups for Resource Management
In this episode of Linux Server Admin, Lucas and Luna dive into control groups, or cgroups, the kernel feature that underpins container resource limits and systemd resource control. You'll learn how cgroups work under the hood, why they matter for modern server workloads, and how to use systemd's built-in resource control directives to cap CPU, memory, and I/O for services and user slices. With re
Linux Server Network Namespaces and VRF A Practical Guide
In episode 151 of Linux Server Admin, Lucas and Luna dive into network namespaces and Virtual Routing and Forwarding (VRF) on Linux servers. They explain how network namespaces give you isolated network stacks, why they're the backbone of container networking, and how VRFs let you run multiple routing tables on a single server. Using a concrete example—a server with two uplinks to different ISPs—t
Linux Server Journalctl Log Analysis That Actually Helps
Episode 150 of Linux Server Admin with Fexingo digs into journalctl, the systemd logging tool that can make or break your debugging sessions. Lucas and Luna walk through real-world scenarios: filtering by time windows with --since and --until, using _PID and _SYSTEMD_UNIT to isolate specific services, and taming the output with json-pretty for scripted automation. They explain why the default prio
Linux Server Firewall with nftables A Practical Guide
In this episode of Linux Server Admin with Fexingo, Lucas and Luna dive into the practical side of using nftables, the modern replacement for iptables. They walk through a real-world scenario of setting up a firewall for a small web server, covering the syntax, the key differences from iptables, and common pitfalls. Lucas shares a tip about using nftables' built-in sets to efficiently manage IP li
How to Set Up a Linux Server as a Router with nftables
In this episode, Lucas and Luna dive into turning a Linux server into a high-performance router using nftables. They explain the core concepts of packet filtering, network address translation, and routing, then walk through a practical setup with a simple dual-NIC configuration. You'll learn how to configure nftables to forward traffic, set up NAT for internet sharing, and secure the router with b
How to Build a Linux Server Backup Strategy That Actually Works
In this episode of Linux Server Admin, Lucas and Luna dig into the practical side of backup strategy for Linux servers. They break down the 3-2-1 rule, compare full, incremental, and differential backups, and walk through a real-world scenario using rsync and a LUKS-encrypted external drive. They also discuss testing restores, common pitfalls like silent corruption and backup drift, and share a qu
How to Set Up SSH Jump Hosts for Secure Server Access
Episode 146 of Linux Server Admin dives into SSH jump hosts, a practical way to secure multi-server environments. Lucas and Luna walk through the setup of a bastion host, showing how to use ProxyJump to route connections safely, along with key-based authentication and agent forwarding done right. They ground the discussion in a real-world scenario of managing a small fleet of servers, and they sha
How to Use Linux Auditd for Security Monitoring
In this episode of Linux Server Admin, Lucas and Luna explore the power of auditd, the Linux audit daemon, for tracking security-relevant events on your servers. They walk through a practical setup for monitoring file access and user commands, explaining how audit rules work, how to interpret audit logs, and how to use ausearch and aureport to make sense of the data. They also discuss performance
Tuning Linux Server I/O Schedulers for NVMe Workloads
In this episode of Linux Server Admin, Lucas and Luna dive into the often-overlooked world of I/O schedulers on modern NVMe drives. With the rise of NVMe storage, traditional schedulers like CFQ and even deadline are becoming less relevant, and the choice between none, mq-deadline, and bfq can have a real impact on latency and throughput. Lucas shares a production story from a busy PostgreSQL serv
Why Systemd Timer Units Beat Cron for Scheduled Jobs
In this episode of Linux Server Admin, Lucas and Luna dive into the practical differences between cron and systemd timer units for scheduling jobs on modern Linux servers. They explore why timers offer better logging, dependency handling, and reliability, using a real-world scenario of a backup job that failed silently under cron. The discussion covers how to configure a simple timer unit, trigger
How to Use Linux Server Namespaces for Process Isolation
In this episode, Lucas and Luna dive into the practical use of Linux namespaces for process isolation, going beyond the usual container talk. They focus on the mount namespace and how it can prevent a runaway process from clobbering your server's filesystem. You'll hear how a simple unshare command can give you a sandboxed view of the filesystem, and why pivot_root is the missing piece for truly i
Linux Server Disk Quotas Explained with Practical XFS Setup
In this episode of Linux Server Admin, Lucas and Luna dive into disk quotas on Linux servers, focusing on XFS quota management. They explain the difference between user and project quotas, how to set up quota accounting on XFS, and practical tools like xfs_quota and quotaon. They also discuss common pitfalls like inode limits, journaled quotas, and how to avoid performance hits. Perfect for sysadm
Chrony for Accurate Server Time Synchronization
In this episode of Linux Server Admin, Lucas and Luna dive into the often-overlooked but critical task of keeping server clocks accurate using Chrony. They walk through real-world failures caused by time drift — from authentication errors to broken log sequencing — and explain how Chrony addresses the shortcomings of older NTP implementations. You'll learn basic configuration with pool and iburst
Linux Server LVM Thin Provisioning for Efficient Storage
Episode 139 dives into LVM thin provisioning on Linux servers — a storage strategy that lets you over-commit disk capacity without wasting physical space. Lucas walks through creating a thin pool, provisioning logical volumes, enabling auto-extension, and leveraging snapshots for fast dev/test rollbacks. Luna challenges the trade-off: what happens when the pool fills up? They also cover monitoring
Linux Server User Namespaces for Container Security
User namespaces are a powerful Linux kernel feature that lets containers run as ‘root’ inside their namespace while actually running as an unprivileged user on the host. In this episode, Lucas and Luna walk through a real-world scenario: an attacker who compromises a containerized web app and tries to escape to the host. With user namespace mapping, the attacker’s root privileges inside the contai
Monitoring Linux Server Performance with Prometheus
In this episode, Lucas walks through setting up Prometheus version 2.53 and Node Exporter on a freshly provisioned Ubuntu 24.04 server. He demonstrates how to install the binaries from the official tarball, configure the prometheus.yml to scrape localhost:9100 every 15 seconds, and verify metric ingestion using the expression browser. Luna asks about the pull model versus push-based tools, and Luc
Debugging Slow Servers with Strace and Ltrace
When your Linux web server stalls for five seconds on every other request, where do you start? This episode walks through a real debugging session using strace and ltrace to uncover a hidden file-lock bottleneck. Lucas and Luna trace system calls and library calls in real time, showing how a single read operation on a shared config file turned a fast Nginx server into a crawl. You'll learn the pra
How to Set Up Disk Encryption with LUKS on Linux Servers
In this episode of Linux Server Admin, Lucas and Luna walk through the practical steps of encrypting a server's disk using LUKS (Linux Unified Key Setup). They cover partitioning an encrypted LVM volume, creating a LUKS container, unlocking it at boot via a keyfile stored on an initramfs, and managing passphrases. The discussion includes performance considerations, backup of LUKS headers, and inte
Recommended
Talk About Talk - Executive & Leadership Communication Skills
English with Olivia | Slow Conversations & Vocabulary
Stand In The Circle
SLOW ENGLISH PODCAST (A1-A2) With Subtitles | Daily Videos | English With Us Podcast
Learn English A2 with Daily News | Simple English Listening Practice
پلی لیست | PlayList
Conspiracy Files with Paige Carter
Bad Friends
Learn 50 English Phrases While You Sleep | Everyday English Phrases & Vocabulary
This Past Weekend w/ Theo Von
Dateline NBC
Back to the 80s Radio
