Build in the Open on Aleskandro

Bridging Distributed Systems with Earth & Sea Science: A Field-Driven Reading List

Fri, 29 Aug 2025 00:00:00 +0000

I’m just back from a 10-days road-trip in Scotland. It was a perfect break from work and a wonderful experience with Courtney and Justin. It’s now official that I’m going to move out of my current team: my multi-arch compute Kubernetes chapter comes to an official end, and a new experience around LLM distributed serving will have me busy at Red Hat within a few weeks.

But it wasn’t just a break-from-work trip - it was a reminder of what’s at stake.

KubeCon EU 2025 Recap: Kubernetes Meets AI - a New Decade of Cloud Native development

Mon, 07 Apr 2025 00:00:00 +0000

KubeCon + CloudNativeCon Europe 2025 just concluded in London, bringing together thousands of cloud-native engineers, maintainers, and enthusiasts. As a local Distributed Systems Engineer involved in the Kubernetes community and ecosystem, attending in person was both energizing and insightful.

A central theme emerged across sessions: Kubernetes is rapidly evolving beyond microservices, adapting to support batch workloads, AI/ML training, HPC scenarios, and global-scale multi-cluster deployments. This shift isn’t just technical - it’s reshaping the cloud-native landscape and redefining how we think about workload orchestration, scheduling, and autoscaling.

A perspective on the current and future state of Kubernetes scheduling

Sat, 01 Mar 2025 00:19:02 +0200

Kubernetes scheduling is the brain of the cluster, deciding which node runs each Pod. In this post, I explore advanced scheduling mechanisms in Kubernetes. I start with how the default scheduler works under the hood, then dive into the scheduler-plugins project for extending its capabilities. I review custom schedulers and plugins in the ecosystem that focus on cost savings, SLA optimization, and performance tuning, noting which are community-supported or vendor-specific. Finally, I look at future trends in Kubernetes scheduling, from AI-driven algorithms to multi-cluster and energy-aware schedulers. This post brings together the key ideas from the full series I wrote on Kubernetes scheduling.

FOSDEM 2025 Recap

Sat, 08 Feb 2025 00:19:03 +0200

FOSDEM 2025, one of the largest open-source conferences globally, concluded last week, featuring an array of talks, workshops, and community events. Held annually in Brussels, Belgium, FOSDEM gathers developers, contributors, and enthusiasts from around the world to explore the latest trends, projects, and innovations in the open-source ecosystem.

Having missed the in-person event in 2024 due to my relocation to London, I was excited to attend FOSDEM 2025 in person and reconnect with the vibrant open-source community. This year, I boarded the Eurostar from London to Brussels, eager to engage with fellow contributors, maintainers, and developers.

Kubernetes Scheduling: Future Trends

Sat, 01 Feb 2025 00:00:00 +0000

The Kubernetes scheduler is the brain of the cluster, deciding which node runs each Pod. This is the final post in a series where I explore advanced scheduling mechanisms in Kubernetes. In this one, I look ahead at emerging trends and research directions that could shape the future of Kubernetes scheduling. I discuss how new heuristics and processing architectures, AI and machine learning could drive smarter placement decisions, how multi-cluster and federated schedulers might support global workloads, and how energy-aware scheduling could make Kubernetes more sustainable. I also explore upcoming ideas like dynamic scheduler profiles, carbon-aware policies, and new architectures for resilience and scalability. From smarter algorithms to environmental impact, Kubernetes scheduling is evolving into a platform for innovation - and the road ahead looks promising.

Kubernetes Scheduling: community schedulers in the ecosystem

Sun, 05 Jan 2025 00:00:00 +0000

The Kubernetes scheduler is the brain of the cluster, deciding which node runs each Pod. This is the fourth post in a series where I explore advanced scheduling mechanisms in Kubernetes. In this one, I give a broad overview of community-driven and vendor-supported custom schedulers built on top of Kubernetes. I focus on how these schedulers and plugins target specific goals like cost savings, SLA optimization, and performance tuning. I cover batch and ML-focused schedulers like Volcano, YuniKorn, and Koordinator, as well as research-driven systems like Poseidon/Firmament. I also look at cost-optimization strategies using bin-packing, spot instances, and descheduling, along with SLA-driven and topology-aware scheduling techniques. Finally, I reflect on the balance between community projects and vendor platforms, and how Kubernetes’s extensibility allows users to tailor scheduling to their workload and infrastructure needs.

Kubernetes Scheduling: the scheduler-plugins project

Sat, 21 Dec 2024 00:00:00 +0000

The Kubernetes scheduler is the brain of the cluster, deciding which node runs each Pod. This is the third post in a series where I explore advanced scheduling mechanisms in Kubernetes. In this one, I focus on the scheduler-plugins project by SIG Scheduling. I explain how this project extends the Kubernetes Scheduling Framework with a collection of out-of-tree plugins that enable advanced behaviors like gang scheduling, NUMA-aware placement, load-aware scoring, and more. I walk through key plugins such as Capacity Scheduling, Coscheduling, Trimaran, and Network-Aware Scheduling, and show how they solve real-world scheduling problems. I also cover how to integrate these plugins into your cluster using a custom scheduler or as a secondary scheduler, and discuss the tradeoffs of each approach.

Kubernetes Scheduling: the scheduling framework

Sat, 16 Nov 2024 00:00:00 +0000

The Kubernetes scheduler is the brain of the cluster, deciding which node runs each Pod. This is the second post in a series where I explore advanced scheduling mechanisms in Kubernetes. In this one, I give an overview of the current state of the Kubernetes scheduling framework. I explain how Kubernetes scheduling works as a batch-oriented process that handles one Pod at a time. I walk through the evolution from the older predicates and priorities model to the modern Scheduling Framework, where each step in the scheduling cycle is an extension point for plugins. I also cover extenders, PreEnqueue plugins, and SchedulingGates, which enable more flexible and complex scheduling workflows. Finally, I highlight projects like Kueue and the Multiarch Tuning Operator that build on these features to support AI, HPC, and multi-architecture workloads.

Kubernetes Scheduling: Under the Hood

Thu, 10 Oct 2024 00:00:00 +0000

The Kubernetes scheduler is the brain of the cluster, deciding which node runs each Pod. This post is part of a series where I explore advanced scheduling mechanisms in Kubernetes. In this part, I focus on the current state of the default scheduler.

I walk through how the default scheduler works under the hood, breaking it down into queueing, filtering, scoring, binding, and preemption. I explain how Pods move through different queues, how the scheduler picks viable nodes, and how it scores and selects the best one. I also touch on newer features like QueueingHint and PreEnqueue plugins, and discuss how the scheduler balances performance and fairness at scale. If you’re curious about how Kubernetes makes scheduling decisions, this post offers a detailed look at the mechanisms behind it.

A journey to an OSTree container native distributed desktop configuration system with Fedora Silverblue/Kinoite

Mon, 12 Dec 2022 00:19:02 +0200

flowchart TD
A("cron-like schedule")
B("manual triggers")
C("push")
D["Build BaseOS Image"]
E["Build OSContent Image"]
A --> D
B --> D
B --> E
C --> E
D --> E

The traditional desktop delivery model is based on a large number of distributed PCs executing the operating system and the desktop applications. Managing traditional desktop environments is incredibly challenging and expensive. Tasks like installations, configuration changes, and security measures require time-consuming procedures and dedicated deskside support. Users in the Free and Open Source Software (FOSS) community have always been keen to implement strategies for the delivery of the configuration of their systems so that they (1) can share it with the community, and (2) distribute it across multiple workstations or servers. Dotfiles and Ansible repositories are usual buzzwords for those users to respectively version specific user configurations, deliver initial system-level setup to freshly installed OSes and update existing ones. Alternatively, and especially in desktop enterprise environments leveraging multi-user desktop configuration, the delivery of the user-specific configuration can be managed through technologies like Kerberos, LDAP and Active Directory. However, the latter still needs a specific centralized model that is either not always doable and optimal or even over-killing for small configurations like single-user workstations.