Linux Server Admin with Fexingo: Sysadmin, Bash, and Server Engineering

Linux Server Admin with Fexingo: Sysadmin, Bash, and Server Engineering podcast cover
Fexingo Technology

Linux Server Admin with Fexingo: Sysadmin, Bash, and Server Engineering

Lucas and Luna sit down at a pair of thin laptops, terminal windows flickering with abstract patterns, to talk Linux server administration as it's actually practiced—bash scripting, systemd quirks, Nginx tuning, SSH hardening, and the daily grind of keeping production services online. Each episode picks a single sysadmin problem: how to diagnose a slow database query without panic, why that cron job keeps failing at 3 AM, or the right way to automate backups with rsync and rclone. Lucas brings the journalistic rigor—he'll cite real-world incidents like the 2021 AWS Kinesis outage that broke monitoring for half the internet, or the time a misplaced chmod command took down a major e-commerce site for an hour. Luna pushes back with hands-on experience: she's the one who asks whether you really need Docker for a three-service stack, or why your fail2ban config is banning your own IP. Together they cut through vendor hype—no Kubernetes if you have five servers, no Ansible if a shell loop will do—and focus on the tools and habits that keep systems boringly stable. The listener is someone who manages servers—maybe a solo IT generalist at a mid-size company, a DevOps engineer tired of conference talk, or a hobbyist running a home lab who wants professional-grade discipline. No whiteboarding abstract architectures; just concrete decisions, error messages, and the trade-offs between uptime and complexity. Can you afford to ignore SELinux? When is it smarter to reboot than to debug a memory leak? And how do you explain a 99.9% uptime SLA to a manager who thinks 'the cloud' fixes everything?

#LinuxServerAdmin#Sysadmin#Bash#ServerEngineering#SSH#Nginx#Systemd#DevOps#Infrastructure#Automation#Backup#Security#Technology#FexingoBusiness#BusinessPodcast#DailyPodcast#ServerRoom#Terminal

Support Fexingo

Episodes

Latest 50 of 183 episodes

How Linux Servers Handle High Concurrency Without Crashing

Sep 12, 2026 · 15:15

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 concrete examples from web infrastructure to show why concurrency is no longer just about raw CPU speed…

0:000:00

How Linux Servers Handle High Concurrency Without Crashing

Sep 11, 2026 · 11:18

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 misconfiguration can turn a responsive server into a zombie process. This episode breaks down the…

0:000:00

How Linux Servers Handle Failures Gracefully

Sep 11, 2026 · 8:38

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 redundancy, load balancing, and smart monitoring prevent single points of failure. This episode breaks…

0:000:00

Why Linux Servers Fail at Midnight

Sep 9, 2026 · 8:19

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 show how to diagnose these issues using systemd timers and resource limits before your production…

0:000:00

Linux Server Network Time Synchronization

Sep 8, 2026 · 8:46

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 fallback strategies and firewall considerations. We also cover how to diagnose sync issues using…

0:000:00

Why Linux Servers Crash at Midnight

Sep 8, 2026 · 11:24

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 latent risks. This isn't just about timing; it's about dependency mapping and rollback strategies that…

0:000:00

Linux Kernel Live Patching Without Downtime

Sep 7, 2026 · 11:05

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 unacceptable for high-availability systems and what operational risks come with modifying the kernel…

0:000:00

How Linux Servers Handle High Concurrency Without Crashing

Sep 5, 2026 · 12:12

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 core can handle more requests when it stops sleeping, and how tuning the TCP stack parameters like…

0:000:00

Linux Server Security Beyond the Kernel with eBPF

Sep 4, 2026 · 10:22

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 sysadmins managing containerized workloads in September twenty twenty six, focusing on performance…

0:000:00

Linux Kernel Live Patching Without Downtime

Sep 3, 2026 · 10:03

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 the risks of memory corruption during patch application, the importance of verifying patch…

0:000:00

Linux Server Security Beyond the Firewall

Sep 2, 2026 · 12:51

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 friction this creates for sysadmins who are used to root-level freedom. We cover the difference between…

0:000:00

Linux Server Memory Leak Detection

Sep 1, 2026 · 12:44

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 never freed. If today's tech conversation gave you something usable, consider supporting us at buy me…

0:000:00

How to Use Linux Server Network Bonding for Redundancy

Aug 31, 2026 · 16:47

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-center setups. You'll learn why the switch you're plugged into decides which mode you can use, how to…

0:000:00

Linux Server Disk Encryption with LUKS and TPM Unlocking

Aug 30, 2026 · 9:35

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. They walk through a real-world example of configuring LUKS with a TPM, including measuring the…

0:000:00

Linux Server IPv6 Migration without Breaking Things

Aug 29, 2026 · 8:59

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 like ping6 and curl. By the end, you'll know how to enable IPv6 on your server while keeping IPv4…

0:000:00

Linux Server Disk Quotas for Shared Hosting

Aug 28, 2026 · 8:42

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 directories, and backup storage, and explain how to avoid common pitfalls like inode exhaustion. The…

0:000:00

How to Use Linux Server Systemd Journald Persistent Storage

Aug 27, 2026 · 9:35

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 walk through the steps to set up /var/log/journal, manage disk usage with SystemMaxUse and…

0:000:00

Linux Server Systemd Services That Restart Themselves

Aug 26, 2026 · 7:28

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-failure and Restart=always, and when to use RestartPreventExitStatus to keep a service down on…

0:000:00

How to Use Linux Server Systemd Timers for Scheduling

Aug 25, 2026 · 11:13

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 using journalctl. They also cover common pitfalls like timezone confusion and the importance of…

0:000:00

How to Use Linux Server LVM Cache for Faster Storage

Aug 24, 2026 · 8:06

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, cache modes (writeback and writethrough), and how to monitor performance with lvs and lvdisplay.…

0:000:00

How to Use Linux Server LVM for Flexible Storage

Aug 23, 2026 · 9:01

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, extend the volume group, and grow the logical volume while the system stays up. Lucas breaks down…

0:000:00

How to Use Linux Server Landlock for Unprivileged Sandboxing

Aug 22, 2026 · 12:19

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 server hardening. If you're a sysadmin or developer looking for a lightweight way to contain risky…

0:000:00

How to Use Linux Server Systemd Socket Activation

Aug 21, 2026 · 12:20

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 pitfalls of using it with stateful services and how to debug socket units with systemctl and journalctl.…

0:000:00

How to Use Linux Server tmpfs for RAM Backed Storage

Aug 20, 2026 · 11:24

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, and when tmpfs is the right tool versus when you should reach for something like Redis or a…

0:000:00

How to Use Linux Server cgroups v2 for Resource Control

Aug 19, 2026 · 12:17

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 interface. They also cover how to read key files like cpu.max and memory.max, and how to monitor usage with…

0:000:00

How to Use Linux Server BPF Tools for Network Diagnostics

Aug 18, 2026 · 8:50

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 count TCP retransmissions, trace connect() calls, and even measure latency across your stack. The hosts…

0:000:00

How to Use Podman for Containers on Linux Servers

Aug 17, 2026 · 10:25

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 some teams are swapping Docker for Podman, this episode gives you the concrete reasons and gotchas.…

0:000:00

Mastering Linux Server Boot Diagnostics with Systemd

Aug 16, 2026 · 7:55

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-analyze critical-chain, bootchart, and journalctl -b -1 helped pinpoint the culprit: a network-mounted…

0:000:00

How to Tune Linux Server TCP Stack for High Throughput

Aug 16, 2026 · 8:54

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 end, you'll know how to identify bottlenecks and apply targeted tweaks without breaking your network.…

0:000:00

How to Use BPFtrace for Linux Server Troubleshooting

Aug 15, 2026 · 12:23

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, tracking system call latency, and catching short-lived processes. They compare BPFtrace to strace and…

0:000:00

How to Harden Linux Servers with Systemd Sandboxing

Aug 13, 2026 · 8:48

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 apply these options step by step, discuss common pitfalls, and explain when sandboxing isn't enough.…

0:000:00

How to Use Linux Server Control Groups for Resource Management

Aug 12, 2026 · 11:12

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 real-world examples like limiting a runaway PHP-FPM pool or prioritizing a database over batch jobs…

0:000:00

Linux Server Network Namespaces and VRF A Practical Guide

Aug 11, 2026 · 10:02

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—they walk through a policy-based routing setup that sends traffic through distinct paths. They also…

0:000:00

Linux Server Journalctl Log Analysis That Actually Helps

Aug 10, 2026 · 8:34

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 priority filter hides important messages, how to combine multiple matches with +, and when to use…

0:000:00

Linux Server Firewall with nftables A Practical Guide

Aug 9, 2026 · 12:20

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 lists, and Luna asks how to test the rules without locking yourself out. They also touch on the…

0:000:00

How to Set Up a Linux Server as a Router with nftables

Aug 8, 2026 · 7:50

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 basic firewall rules. They also discuss performance tuning tips, such as enabling IP forwarding and…

0:000:00

How to Build a Linux Server Backup Strategy That Actually Works

Aug 7, 2026 · 12:19

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 quick tip on automating backups with systemd timer units. If you've ever wondered whether your…

0:000:00

How to Set Up SSH Jump Hosts for Secure Server Access

Aug 6, 2026 · 10:38

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 share the exact ssh config entries that make it work. Along the way they touch on common pitfalls like…

0:000:00

How to Use Linux Auditd for Security Monitoring

Aug 6, 2026 · 8:42

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 considerations and common pitfalls, such as log rotation and rule ordering. By the end, you'll know…

0:000:00

Tuning Linux Server I/O Schedulers for NVMe Workloads

Aug 4, 2026 · 8:03

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 server where switching from the default none scheduler to mq-deadline reduced write latency by 15…

0:000:00

Why Systemd Timer Units Beat Cron for Scheduled Jobs

Aug 3, 2026 · 9:45

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 jobs based on service activity, and leverage the built-in integration with journald and systemd's…

0:000:00

How to Use Linux Server Namespaces for Process Isolation

Aug 2, 2026 · 11:44

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 isolated environments. They also touch on how systemd uses namespaces under the hood for service…

0:000:00

Linux Server Disk Quotas Explained with Practical XFS Setup

Aug 1, 2026 · 11:15

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 sysadmins managing multi-user servers or shared hosting environments. The conversation includes…

0:000:00

Chrony for Accurate Server Time Synchronization

Jul 30, 2026 · 7:47

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 directives, how to verify synchronization with chronyc sources, and how to set up authentication…

0:000:00

Linux Server LVM Thin Provisioning for Efficient Storage

Jul 30, 2026 · 6:59

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 with lvs and dmeventd, and a real-world case of a CI pipeline that reclaimed 60% of its allocated…

0:000:00

Linux Server User Namespaces for Container Security

Jul 29, 2026 · 9:29

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 container are worthless outside it. They explain how UID 0 inside maps to UID 100000 outside, why this…

0:000:00

Monitoring Linux Server Performance with Prometheus

Jul 29, 2026 · 7:43

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 Lucas highlights the value of historical data for troubleshooting night-time anomalies. They also…

0:000:00

Debugging Slow Servers with Strace and Ltrace

Jul 28, 2026 · 10:01

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 practical difference between strace's -p and -c flags, how to read call output without drowning in…

0:000:00

How to Set Up Disk Encryption with LUKS on Linux Servers

Jul 28, 2026 · 6:43

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 integrating with systemd for automatic unlocking. Perfect for sysadmins securing sensitive data without…

0:000:00

How to Confine Applications with SELinux on Linux Servers

Jul 27, 2026 · 7:33

Episode 134 digs into SELinux — the mandatory access control layer most sysadmins avoid. Lucas and Luna break down how SELinux works, why it matters for application confinement, and walk through a real example: locking down an Apache web server with targeted policies. They cover booleans, contexts, and audit logs, plus common pitfalls like confined vs unconfined domains. If you've never touched SELinux because it's 'too complex', this episode gives you the practical starting point to secure…

0:000:00

Showing the latest 50 episodes. The full archive of 183 is on Apple Podcasts, Spotify and every major podcast app — or via the RSS feed above.