Fexingo
DevOps Daily with Fexingo: CI/CD, Kubernetes, and Modern Software Operations
Lucas and Luna dissect the daily realities of DevOps, from CI/CD pipeline design to Kubernetes cluster management and the human systems that keep software running. Each episode grounds abstract principles in real incidents—a failed deployment at a major retailer, a postmortem from a cloud outage, a configuration drift disaster—and traces the operational decisions that turned them around. Lucas brings the technical precision of a working engineer, while Luna pushes on the team dynamics, cost trade-offs, and organizational bottlenecks that separate resilient operations from fragile ones. They di...
Be sure to visit the podcast's website and support the creator: www.fexingo.com
Where to listen?
Podcasts in the app Replaio Radio Coming soonPodcasts are coming to the app soon. Install now and be the first to see a whole new take on podcasts
Episodes
How Kubelet Image Garbage Collection Deletes Running Containers 10.08.2026 12:29
In this episode of DevOps Daily, Lucas and Luna dig into a nasty failure mode that has bitten many production clusters: the kubelet's image garbage collector deleting images that running containers still need. They walk through a real scenario where a node with a small disk runs out of space, the kubelet's image GC kicks in and removes the image for a container that is actively running, and the co...
How Kubernetes Pod Disruption Budgets Cause Node Drain Stalls 09.08.2026 6:25
On this milestone 150th episode, Lucas and Luna dig into a Kubernetes failure mode that quietly grinds cluster upgrades to a halt: Pod Disruption Budgets. Using the story of a mid-sized fintech that got stuck mid-drain for six hours, they explain how PDBs interact with node drains, voluntary disruptions, and replica counts, and why your 'minAvailable: 2' can block a rolling upgrade even when nothi...
How Kubernetes Container Runtime Interface Timeouts Cause Node Drain Failures 08.08.2026 11:56
In this episode of DevOps Daily, Lucas and Luna dig into a surprisingly common but often overlooked failure mode in Kubernetes: container runtime interface timeouts. When the kubelet's connection to the container runtime — typically containerd or CRI-O — goes stale or hangs, node drains can stall, pods get stuck in Terminating, and your carefully planned maintenance window turns into a fire drill....
How Kubernetes Topology Spread Constraints Cause Pod Placement Chaos 07.08.2026 9:26
In this episode of DevOps Daily, hosts Lucas and Luna dive into the hidden dangers of Kubernetes Topology Spread Constraints. They explain how misconfigured spread constraints can prevent pods from scheduling, cause resource fragmentation, and trigger unexpected failovers. Using a real-world example of a three-node cluster with a rollout gone wrong, they walk through the mechanics of how these con...
How ArgoCD Sync Phases Turn a Simple Deploy Into a Cascade of Failures 06.08.2026 7:01
In this episode, Lucas and Luna dig into a nasty failure mode that shows up when ArgoCD's sync phases and hooks are misused: a single application rollout that triggers a cascade of errors, from failed health checks to stuck syncs. They walk through a real-world scenario from a mid-size fintech's production cluster, where a seemingly straightforward update to a payments service brought down depende...
Kubernetes Pod Security Admission Audit Mode Missed Risks 05.08.2026 9:00
In this episode of DevOps Daily with Fexingo, hosts Lucas and Luna uncover a quiet but dangerous gap in Kubernetes security: running Pod Security Admission in audit mode can let risky workloads slip into production without a single warning. They trace a real scenario where a team thought they were protected by PSA audit logs, but misconfigured exclusions and permissive policies meant no alert ever...
Kubernetes PersistentVolume Reclaim Policy Data Loss Risks 04.08.2026 9:16
In this episode of DevOps Daily, Lucas and Luna dig into a silent data-loss hazard in Kubernetes: the PersistentVolume reclaim policy. They walk through a real incident where a Recycle policy deleted a production database's data during a routine Helm upgrade, and explain the differences between Retain, Recycle, and Delete. They cover why the default Delete policy can be dangerous for stateful work...
How Kubernetes StatefulSet Ordinal Indexes Stuck on Old Images 03.08.2026 13:10
In this episode of DevOps Daily, Lucas and Luna dig into a surprisingly common Kubernetes failure: StatefulSets that keep rolling out old images because the controller's ordering logic interacts badly with image pull policies and rolling update strategies. Using a concrete example from a payment-processing service at a European fintech, they explain why 'Always' pull policy can mask a stale image,...
How Kubernetes Certificate Rotation Breaks Service Mesh mTLS 02.08.2026 9:42
In this episode, Lucas and Luna dig into a production incident where a service mesh's mutual TLS certificates expired overnight, silently killing traffic between microservices. They walk through the failure mode: certificates that were set to rotate every 24 hours but got stuck because of a clock skew issue on one of the worker nodes. They explain how Kubernetes CertificateSigningRequest objects w...
How Kubernetes Pod Priority Preemption Stalls Cluster Autoscaling 01.08.2026 8:44
In this episode, Lucas and Luna dig into a surprisingly common Kubernetes failure mode: when Pod PriorityClasses and preemption interact badly with cluster autoscaling, nodes get drained, workloads get killed, and the cluster autoscaler ends up fighting itself. They walk through a real-world scenario where a high-priority batch job preempts a low-priority web service, the node autoscaler scales do...
How Kubernetes ServiceAccount Token Expiration Breaks CI Workflows 30.07.2026 9:01
In this episode of DevOps Daily, Lucas and Luna explore a growing pain in Kubernetes clusters upgraded to version 1.24 and later: default ServiceAccount token expiration. They walk through the surprising moment a listener's CI pipeline stopped deploying, trace the root cause to a one-hour token time-to-live, and explain how to migrate to projected volume mounts with sidecar refresh. With practical...
How etcd Compaction Causes Kubernetes API Latency 30.07.2026 6:59
etcd compaction is a routine maintenance operation that removes historical key-value versions, but when it runs, it can consume significant IO and CPU, leading to increased latency for API server requests. This episode dives into the mechanics: compaction triggers defragmentation of boltdb pages, causing pauses that can spike request latency from milliseconds to seconds. We discuss a real-world in...
How Immutable ConfigMaps Break Helm Upgrades 29.07.2026 7:13
In this episode of DevOps Daily, Lucas and Luna investigate a production outage triggered by Helm upgrade failure after Kubernetes ConfigMaps were set to immutable. They trace the root cause to a Helm chart that marked ConfigMaps immutable, preventing updates without manual deletion. The hosts explain how this feature, intended for performance optimization, can silently break deployments, and shar...
How Node Problem Detector Hides Kernel Panics in Kubernetes 29.07.2026 9:34
When a Kubernetes cluster went down for 12 minutes last Tuesday, the Node Problem Detector didn't report a thing. Lucas and Luna dig into how this popular add-on can actually mask kernel panics instead of surfacing them. They walk through a real-world scenario: a race condition between the node-problem-detector's event reporting and the API server's watch timeout, causing a false all-clear. Then t...
How Kubernetes ImagePullSecrets Expiration Silently Breaks Deployments 28.07.2026 7:09
Lucas and Luna dissect a common but overlooked Kubernetes failure mode: ImagePullSecrets that silently expire and cause deployments to land in perpetual ImagePullBackOff. They walk through a real scenario—a team whose ECR token expired overnight, taking down three microservices before anyone noticed—and explain why standard dashboards miss it. They cover automation strategies using Reloader or Ext...
How ArgoCD Sync Waves Cause Deployment Ordering Fiascos 28.07.2026 8:22
ArgoCD's sync waves are a powerful mechanism for ordering Kubernetes resource deployments, but misconfigurations can lead to cascading failures. In this episode, we break down a real-world scenario where a team's database migration ran after the application pods started, causing a ten-minute outage. We explain how sync waves work, the difference between waves and phases, and common mistakes like m...
How Kubernetes ResourceQuota Exhaustion Silently Fails Deployments 27.07.2026 6:50
In this episode of DevOps Daily, Lucas and Luna dissect a real incident from a mid-sized e-commerce company: a routine deployment that silently failed because a Kubernetes ResourceQuota for CPU was exhausted. They walk through how ResourceQuotas interact with namespace limits, the cryptic error messages that confuse even experienced operators, and why default quotas often catch teams off guard. Lu...
How BuildKit Cache Mounts Cause Dependency Rot in CI 27.07.2026 9:42
Episode 134 of DevOps Daily with Fexingo reveals a hidden risk in containerized CI/CD pipelines: BuildKit cache mounts that silently preserve outdated dependencies. Lucas and Luna unpack a real-world case where a team's npm cache mount kept a vulnerable transitive dependency alive for weeks, bypassing lockfile updates. They explain how cache mount invalidation works, why developers overtrust it, a...
How Kubernetes NetworkPolicy Misconfigurations Create Silent Black Holes 26.07.2026 8:38
A single Kubernetes NetworkPolicy rule silently blocked traffic to a fraud detection engine for 48 hours, costing a team thousands in debug time. In this episode, we dissect how NetworkPolicy's default-deny behavior can create invisible connectivity gaps. We explore podSelector, namespaceSelector, and IPBlock gotchas, discuss why policies on one tier cascade to downstream services, and show how to...
How Topology Aware Hints Blackhole Kubernetes Traffic 26.07.2026 7:30
In this episode, Lucas and Luna explore a silent traffic-killing bug in Kubernetes Topology Aware Hints. They walk through how the feature, designed to reduce cross-zone network costs, can cause complete traffic blackholes when endpoint slices are missing or misconfigured. Using a real-world example from a three-zone deployment, they explain why kube-proxy drops traffic instead of falling back, an...
How Kubernetes LimitRange Defaults Stall Deployments 25.07.2026 5:35
In this episode of DevOps Daily, Lucas and Luna dive into a hidden Kubernetes pitfall: LimitRange objects that silently enforce default resource requests and limits. When your deployment omits resource specs, LimitRange kicks in with defaults that can exceed node capacity, leaving pods stuck in Pending. Lucas shares a real-world example from a fintech team whose Helm chart had no resource stanza,...
Why Kubernetes Horizontal Pod Autoscaler Scaling Decisions Lag 24.07.2026 9:39
In this episode of DevOps Daily, Lucas and Luna dig into one of the most misunderstood components in Kubernetes: the Horizontal Pod Autoscaler's default behavior. They explain why HPA scaling decisions can take two to three minutes to take effect, even when CPU or memory spikes suddenly. Using a case study from a mid-size e-commerce platform that saw checkout latency double during a flash sale, th...
Kubernetes Pod Disruption Budgets Cause Unplanned Outages During Voluntarily Evictions 23.07.2026 10:12
Episode 129 of DevOps Daily with Fexingo dives into a subtle but dangerous Kubernetes behavior: PodDisruptionBudget violations during voluntary evictions. Lucas and Luna walk through a real incident where a cluster running a critical payment service on 3 replicas with minAvailable=2 saw a complete outage during a node drain. The problem? The PDB only counts pods that are healthy according to readi...
How Kubernetes OOMKill Taints Actually Crash Your Cluster 23.07.2026 7:29
In this episode of DevOps Daily, Lucas and Luna dive into a lesser-known Kubernetes behavior: the OOMKill taint. When a node runs out of memory and the kernel kills a pod, Kubernetes applies a taint that can evict all remaining pods on that node, causing a cascade of failures. They walk through a real-world scenario where a single memory-hungry pod triggered node-level taints, leading to widesprea...
How Kubernetes Pod Security Standards Block Supply Chain Attacks 22.07.2026 10:07
In DevOps Daily Episode 127, Lucas and Luna explore how Kubernetes Pod Security Standards (PSS) can block common supply chain attack vectors. They dissect a real-world scenario where a compromised container image from a public registry tries to escalate privileges via hostPath mounts. Lucas explains the three PSS levels—Privileged, Baseline, and Restricted—and how migrating from the deprecated Pod...
Similar podcasts
Replaio is not a podcast publisher; show names, artwork and audio belong to their authors and are distributed through public RSS feeds.