SRS’ Post

Andrei Kvapil, CEO of AENIX, is redefining Kubernetes platform management by drawing inspiration from the Linux ecosystem. He points out a clever realization: every platform variant is essentially just a YAML file living in a repository. Here is how his team leverages this for better architecture: * Treats Kubernetes like a Linux distro. * Uses an APT-style packaging system with FluxCD. * Simplifies custom installs for tools like Cilium or Kilo. This approach transforms complex configurations into manageable, user-specific packages that are incredibly easy to deploy. It is a brilliant example of applying proven legacy wisdom to modern cloud-native challenges. How are you currently managing configuration complexity in your own Kubernetes clusters? #Kubernetes #DevOps #CloudNative #FluxCD #SoftwareEngineering #TechInnovation

Docker Tutorial: Introduction, Benefits & Installation Guide 2026 Docker is a platform that lets you package an application together with everything it needs to run — code, runtime, system libraries, and settings — into a single unit called a container....... https://lnkd.in/eubkauQ2

Homelab upgrade: we now have better thermal control. 🥶 (Jokes aside — this cluster has come a long way in a few months.) -+ Swapped every drive for matched NVMe/SSD pairs -+ Bumped RAM to 32/32/48GB (shoutout to whoever oversold RAM on eBay — you made my week) -+ Migrated from Nomad on Debian → Kubernetes on Talos -+ GitOps via ArgoCD + GitHub -+ Now running local ARC runners for CI Small footprint, real patterns. More to come. #kubernetes #talos #homelab #github

Built a lightweight, Kubernetes-inspired container orchestration platform in Go — from scratch, to actually understand how orchestration systems work internally. 🔗 https://lnkd.in/gG9MQVDq 𝗪𝗵𝗮𝘁 𝗶𝘁 𝗱𝗼𝗲𝘀: • REST API server backed by an embedded key-value store – Optimistic concurrency control to safely handle simultaneous writes – A watch mechanism so components react to state changes instead of polling • A scheduler that decides pod placement using: – Predicate filtering — does a node even qualify to run this pod? – Priority scoring — which qualifying node is the best fit? • Controllers that run continuous reconciliation loops, comparing desired state against actual state and correcting drift automatically • Lease-based leader election + a Controller Manager, enabling high availability with only one active controller at a time • A node agent that does real isolation work: – Linux namespaces for process isolation – cgroups for resource limits – Actual containers — not a simulated abstraction • A custom CLI (mkctl) to interact with the cluster • Automatic recovery and pod rescheduling — a dead node's workloads get detected and rescheduled without manual intervention 𝗪𝗵𝗮𝘁 𝗜 𝗹𝗲𝗮𝗿𝗻𝗲𝗱: Self-healing isn't magic—it's a reconciliation loop that never stops asking, "Does reality match what I want?" and correcting when it doesn't. Watching a pod get automatically rescheduled after a node failure was the moment this really clicked. The hardest part wasn't the happy path—it was making recovery work correctly when a node dies mid-operation, not cleanly. Would genuinely appreciate feedback from anyone who's worked on Kubernetes internals or distributed schedulers. #GoLang #Kubernetes #DistributedSystems #Linux #CloudComputing #SystemDesign #ContainerOrchestration #SoftwareEngineering

Hi everyone, I have been working on bringing ksyms infra support to rust aya; an ebpf framework with a custom loader and a linker to allow you to write native bpf programs in rust. Normally, you are only allowed to call bpf helper functions when writing bpf programs, which are predefined set of functions exposed by the vm verifier. This limits ones ability to do things in their programs. Then, people came up with a mechanism to call into any function internally exposed by the linux kernel itself. So this work brings this support to aya loader. If you are using rust aya, make sure to check this out. I will hopefully detail out things in a series of blog post covering ksyms infra and its internals. Special thanks to Alessandro D., Michal Rostecki for their help along the way. They are the official aya creators and maintainers. #aya #ebpf #kfunc #ksyms #rust https://lnkd.in/dPAvzeif

Andrei Kvapil, CEO of AENIX, recently shared a brilliant perspective on treating Kubernetes like a Linux distro. He highlights that we often overcomplicate platform architecture when historical solutions might actually hold the key. Instead of reinventing the wheel, his team at Cozystack looked back at how Linux handled package management decades ago. By leveraging FluxCD and OCI artifacts, they built an APT-like system that simplifies dependency resolution and installation significantly. Here are the key takeaways from his approach: * **Adopt proven patterns:** Use familiar concepts like `dpkg` and `sources.list` for K8s package management. * **Leverage SourceWatcher:** This new Flux controller allows users to compose and decompose artifacts from multiple sources effortlessly. * **Prioritize modularity:** Empower users to install only what they need, fostering a stronger community-driven ecosystem. It is fascinating to see how looking at older, stable technologies can solve the modern headaches of Kubernetes architecture. How are you currently managing complex dependencies in your Kubernetes clusters? #Kubernetes #FluxCD #CloudNative #DevOps #TechArchitecture #Innovation

🏥 My self-managed Kubernetes cluster crash-looped for hours today. The fix? One missing line in one config file. Here's what happened: My control plane went down. kubectl get nodes → connection refused. I dug in: 🔴 etcd → CrashLoopBackOff 🔴 kube-apiserver → CrashLoopBackOff 🔴 controller-manager, scheduler, even Calico → all crash-looping Every component started fine... then died ~1 second later with a SIGTERM. Over 240 restarts. I checked the usual suspects: ✅ IP hadn't changed ✅ Memory was fine (no OOM) ✅ Disk space was fine ✅ Certs were valid Then I found it. containerd's config file — /etc/containerd/config.toml — was gone. Likely wiped by a package update. Without that file, containerd falls back to its default cgroup driver: cgroupfs. But kubeadm configures kubelet to use systemd. Two components managing the same Linux cgroups with two different drivers = kubelet doesn't recognize the containers containerd creates, so it kills them. On repeat. Forever. The fix: sudo containerd config default | sudo tee /etc/containerd/config.toml sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml sudo systemctl restart containerd kubelet One line: SystemdCgroup = true. Lesson learned: on Ubuntu, kubelet and containerd MUST use the same cgroup driver — systemd. When your control plane crash-loops with no obvious cause, check the cgroup driver before you rebuild. Don't rebuild what you can debug. 🛠️ What's the sneakiest root cause that ever cost you hours? 👇 #Kubernetes #DevOps #CloudEngineering #LearningInPublic #k8s

Almost every fleet operation in Kestra comes down to one construct: ForEach. You give it the hosts or groups to walk, either a static array or a list rendered from a previous task. Its concurrency setting decides whether they run one at a time or in capped parallel. Inside the loop, the current item is what you drop into an Ansible limit or use to render the inventory. Sequential waves, parallel batches, or just enough concurrency to spare the worker, all from the same building block. https://lnkd.in/e6HGNTNs

Crossview is a React and Go dashboard for managing Crossplane resources across Kubernetes clusters, with real-time watching, resource visualization, OIDC/SAML support, Helm install, and Docker deployment. More: https://ku.bz/BCXVD6j8F