DevOps Daily with Fexingo: CI/CD, Kubernetes, and Modern Software Operations

DevOps Daily with Fexingo: CI/CD, Kubernetes, and Modern Software Operations

By FexingoBusiness
Download on the App Store

DevOps Daily with Fexingo: CI/CD, Kubernetes, and Modern Software Operations episodes

  • How Kubernetes Audit Logs Expose Silent Security Threats

    In this episode of DevOps Daily, Lucas and Luna dive deep into Kubernetes audit logs—a powerful but often overlooked tool for detecting silent security threats. They walk through a real-world scenario where a cluster was compromised via a misconfigured webhook, and the only clue was buried in the audit log. They explain how to enable audit logging, what to look for (like unexpected impersonation attempts or suspicious RBAC escalations), and why most teams don't parse these logs until it's too late. The hosts also discuss how audit logs can be integrated with SIEM tools for automated alerting, and share a practical tip: watch for repeated 403 errors—they might indicate an attacker probing your cluster. If you're running Kubernetes in production, this episode will change how you think about observability.

    #Kubernetes #AuditLogs #Security #CloudNative #K8s #DevOps #SIEM #RBAC #ThreatDetection #Webhook #Infrastructure #Observability #Technology #FexingoBusiness #BusinessPodcast #DevOpsDaily #Podcast #CyberSecurity

    Keep every episode free: buymeacoffee.com/fexingo

    12 min
  • How Kubernetes PodTopologySpread Constraint Silently Degrades Availability

    Lucas and Luna dive into a subtle Kubernetes anti-affinity trap that many teams don't notice until it's too late. The PodTopologySpread constraint — designed to spread pods evenly across failure domains — can actually concentrate pods onto fewer nodes when misconfigured with a low maxSkew value. Lucas explains a real incident at a mid-sized SaaS company where a three-zone cluster with maxSkew=1 caused a cascade: after one zone failed, the constraint blocked rescheduling because spreading the remaining pods would violate the skew limit. The result was a 50% capacity loss and a six-hour recovery. Luna questions whether the default maxSkew of 1 is too aggressive for most workloads. They walk through the math, the YAML, and the safer defaults — plus when to skip the constraint entirely. If you manage Kubernetes in production, this episode will save you a painful post-mortem.

    #Kubernetes #PodTopologySpread #HighAvailability #maxSkew #PodAntiAffinity #DevOps #SiteReliability #ProductionIncident #K8sScheduling #CloudNative #Infrastructure #AvailabilityZones #FailureDomain #ClusterResilience #Technology #DevOpsDaily #FexingoBusiness #BusinessPodcast

    Keep every episode free: buymeacoffee.com/fexingo

    9 min
  • Why Kubernetes PersistentVolume Claims Stall on WaitForFirstConsumer

    Lucas and Luna dig into a deceptively common Kubernetes failure: PersistentVolumeClaims stuck in Pending because the WaitForFirstConsumer binding mode delays volume provisioning until a pod actually consumes the claim. They trace how this interacts with StatefulSets, pod topology spread constraints, and cluster autoscaler to create cascading scheduling deadlocks. The episode walks through a real incident at a mid-size fintech where 150 PVCs stayed Pending for 14 hours, delaying an entire batch-processing pipeline. Lucas explains why immediate binding works for most workloads, when WaitForFirstConsumer makes sense, and how to detect these stalls before they hit production. Luna questions whether the Kubernetes docs bury this behavior too deep for teams that don't run storage admin day to day. They close with concrete monitoring and admission-control practices to avoid the trap.

    #Kubernetes #PersistentVolumeClaim #WaitForFirstConsumer #Storage #StatefulSet #PodTopologySpread #ClusterAutoscaler #SchedulingDeadlock #VolumeBindingMode #Fintech #BatchProcessing #AdmissionControl #Technology #DevOps #CloudNative #FexingoBusiness #BusinessPodcast #K8sTroubleshooting

    Keep every episode free: buymeacoffee.com/fexingo

    9 min
  • Why Kubernetes Node Problem Detector Misses Silent Failures

    Lucas and Luna dive into a specific blind spot in Kubernetes cluster observability: the Node Problem Detector (NPD) and how it fails to catch silent hardware and kernel-level issues. They walk through a real incident at a mid-sized fintech where NPD reported 'healthy' while memory corruption was quietly degrading performance across 12 nodes. They explain why default NPD configurations only monitor a handful of conditions, how kernel log parsing gaps create false negatives, and what you can do with custom problem detectors and event exporters. If you run Kubernetes in production, this episode will save you from a nightmare outage that doesn't show up in your usual dashboards.

    #Kubernetes #NodeProblemDetector #ClusterObservability #SilentFailures #KernelLogs #MemoryCorruption #Fintech #DevOps #SRE #K8sTroubleshooting #ProductionIncidents #NodeHealth #CustomDetectors #EventExporters #LinuxKernel #Technology #FexingoBusiness #BusinessPodcast

    Keep every episode free: buymeacoffee.com/fexingo

    14 min
  • How Kubernetes ConfigMap Rollouts Silently Fail Without Immutable Fields

    In this episode of DevOps Daily with Fexingo, Lucas and Luna dive into a hidden Kubernetes failure mode: when ConfigMap updates are rolled out to Deployments, but the Pods never pick up the new data because the rollout trigger is missing. They walk through a real incident from a mid-sized fintech where a database connection string changed at 2 AM, the ConfigMap was updated, but the Deployment never restarted—causing six hours of silent query failures. They explain why rolling updates depend on annotations or checksums, how immutable ConfigMaps can prevent accidental partial updates, and what to check in your staging pipeline tomorrow. Practical, specific, and rooted in a real outage.

    #Kubernetes #ConfigMap #DevOps #K8sRollout #ImmutableConfigMap #CloudNative #SiteReliabilityEngineering #ContinuousDeployment #InfrastructureAsCode #K8sFailureMode #PodRollout #Helm #Kustomize #Technology #DevOpsDaily #FexingoBusiness #BusinessPodcast #SoftwareOperations

    Keep every episode free: buymeacoffee.com/fexingo

    13 min
  • How Kubernetes Priority Class Starvation Locks Down Clusters

    In this episode of DevOps Daily, Lucas and Luna dive into a subtle but dangerous Kubernetes problem: priority class starvation. When lower-priority pods are preempted but never actually evicted due to PDB constraints, the scheduler gets stuck in a loop, and the cluster can grind to a halt. They walk through a real scenario where a team's production deployment failed because a single PriorityClass name was misspelled, leading to silent resource starvation over 48 hours. Using concrete numbers — 200 pending pods, three priority tiers, and a 30-second scheduler backoff — they explain why default PriorityClasses are a trap, why PDBs block preemption, and how to audit your cluster before it's too late. If you manage Kubernetes clusters, this episode will save you from a Monday morning outage.

    #Kubernetes #PriorityClass #PodDisruptionBudget #SchedulerPreemption #ClusterStarvation #DevOps #SiteReliabilityEngineering #CloudNative #K8sOperations #PodLifecycle #ResourceManagement #KubernetesTroubleshooting #PriorityPreemption #InfrastructureEngineering #ContainerOrchestration #Technology #FexingoBusiness #BusinessPodcast

    Keep every episode free: buymeacoffee.com/fexingo

    9 min
  • How Kubernetes Downward API Labels Break Pod Identity

    Lucas and Luna dig into a surprisingly brittle Kubernetes footgun: using the Downward API to inject pod labels as environment variables. They walk through a real incident where a label change triggered cascading failures because application code was hard-wired to read pod name from an env var that silently went stale. The conversation covers why this pattern is so common in Helm charts, how it differs from using the filesystem volume mount, and a concrete migration path to a more stable approach using the Downward API volume or operator-managed sidecars. If you've ever debugged a pod that couldn't figure out its own name, this episode will save you a late-night incident.

    #Kubernetes #DownwardAPI #PodIdentity #Helm #DevOps #CloudNative #Infrastructure #K8sTroubleshooting #PodLabels #EnvironmentVariables #OperatorPattern #Sidecar #IncidentResponse #SoftwareEngineering #DevOpsDaily #FexingoBusiness #BusinessPodcast #Technology

    Keep every episode free: buymeacoffee.com/fexingo

    10 min
  • Why Kubernetes Service Mesh Sidecar Injection Latency Matters

    In this episode of DevOps Daily, Lucas and Luna explore how service mesh sidecar injection in Kubernetes can introduce surprising latency during pod startup. They break down the mechanics of Istio's mutating webhook, explain why a 30-second delay in sidecar readiness can cascade into failed health checks and rolling update blips, and share practical mitigation strategies. Using a real deployment example from a mid-stage fintech startup, they show how teams can tune pre-stop hooks, adjust pod disruption budgets, and leverage native sidecar containers in Kubernetes 1.29+ to reduce injection overhead. No clickbait, just the hard-won ops lessons that keep pipelines green.

    #Kubernetes #ServiceMesh #SidecarInjection #Istio #PodStartup #Latency #SiteReliability #DevOps #CloudNative #CNCF #KubernetesSidecar #MutatingAdmissionWebhook #PodDisruptionBudget #RollingUpdate #Technology #FexingoBusiness #BusinessPodcast #DevOpsDaily

    Keep every episode free: buymeacoffee.com/fexingo

    9 min
  • How Kubernetes Network Policies Can Leak Pod Traffic

    Most teams assume Kubernetes Network Policies provide airtight segmentation. In this episode, Lucas and Luna break down a specific flaw: how a misconfigured egress policy combined with a default-deny-all ingress rule can actually leak DNS and API traffic to unintended namespaces. They walk through a real incident at a mid-sized fintech where a missing podSelector allowed a payments microservice to reach a database it should never have touched. They cover how the Kubernetes API processes policy rules, the gotcha with empty podSelectors, and two concrete audit commands you can run today to check for similar leaks. No theory — just a practical story of how policy-as-code can give false confidence.

    #Kubernetes #NetworkPolicy #PodTrafficLeak #ContainerNetworking #DevOps #CloudNative #Security #TechPodcast #FexingoBusiness #BusinessPodcast #Technology #SoftwareEngineering #Infrastructure #CNCF #PodSelector #EgressPolicy #IngressPolicy #PolicyAsCode

    Keep every episode free: buymeacoffee.com/fexingo

    8 min
  • How Kubernetes Mutating Admission Webhooks Cause Cascade Failures

    When a single misbehaving mutating admission webhook in Kubernetes can take down your entire cluster, it's not just a developer headache—it's a production emergency. In this episode, Lucas and Luna break down the real-world cascade failure at a major fintech that lost $2.3 million in trading revenue over 47 minutes. They walk through how webhooks work, why a simple config map change triggered a chain reaction across 1,200 pods, and what the team did to recover—and prevent it from happening again. You'll learn about webhook timeout defaults, failure policy nuances, and why monitoring webhook latency matters more than you think. If you run Kubernetes in production, this episode might save your weekend.

    #Kubernetes #MutatingAdmissionWebhook #CascadeFailure #K8sProduction #WebhookLatency #AdmissionController #CNCF #SiteReliabilityEngineering #IncidentResponse #CloudNative #K8sBestPractices #Fintech #PodSecurity #DevOps #Technology #FexingoBusiness #BusinessPodcast #Infrastructure

    Keep every episode free: buymeacoffee.com/fexingo

    7 min

About DevOps Daily with Fexingo: CI/CD, Kubernetes, and Modern Software Operations

From the publisher's feed

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 discuss monitoring strategies, incident response playbooks, infrastructure-as-code trade-offs, and the cultural friction between development velocity and operational stability—always with concrete examples, never with buzzwords. This is the show for engineers, SREs, and platform leads who want to hear two seasoned practitioners argue through the hard choices: when to rewrite vs. patch, how much observability is enough, and how to keep a multi-cloud deployment from becoming a management nightmare. By the end, you'll carry away a sharpened question about your own stack and a new way to think about reliability.