Discover a collection of articles and talks by Graziano Casto

Talks and Articles by Graziano Casto

Modern runtimes like Java, Go, and Node.js face a critical 'resource gap'. They require a massive CPU burst for JIT compilation or dependency loading, only to settle into a much leaner steady state seconds later. Historically, we had to over-provision Pods for this peak, wasting thousands of cores across clusters. With In-Place Pod Resize in Kubernetes v1.35, we can finally implement a startup boost strategy. This session moves beyond the theory to show the technical 'how-to' where we will demonstrate how to build a reactive workflow that provisions high initial resources and then 'shrinks' the footprint silently via the resize sub-resource. Beyond the 'how-to', we must address the 'shrinkage trap' and explain how to time the resource reclamation to avoid aggressive CPU throttling immediately after boot. We will compare different implementation patterns including sidecar-driven patches, a dedicated boost-operator, and the native Vertical Pod Autoscaler, ensuring your applications don't just start fast but stay stable. Stop paying for peak startup power during hours of steady-state operation.

Stop Overprovisioning for Application Startup

Mettere in piedi un’infrastruttura solida è solo l’inizio. La vera sfida è scalarla senza che i costi o la complessità gestionale vadano fuori controllo. In questo talk vedremo perché il Platform Engineering e l’Autonomous Optimization sono le due facce della stessa medaglia. Scopriremo come una moderna Internal Developer Platform (IDP) permetta di costruire i 'binari' (un’infrastruttura standardizzata e sicura) e come l'integrazione di sistemi di ottimizzazione autonoma agisca da 'pilota automatico', usando l'IA per decidere i parametri migliori in tempo reale. Smetti di combattere con i file YAML: impara a progettare un sistema che non solo funziona, ma impara a dare il massimo spendendo il minimo.

Da Zero a Cento: Costruire un’Infrastruttura che si Auto-Ottimizza

Observability gets tricky when you take Kubernetes to the Edge. Sending full traces and metrics upstream doesn’t scale when every byte and millisecond count. This talk introduces an ultra-optimized OpenTelemetry Micro-Collector strategy built for Edge environments. It demonstrates how to minimize overhead without losing visibility by applying smart data reduction techniques like Tail-Based Sampling and Lossless Batching directly on the device, ensuring that only high-value telemetry such as errors and slow requests leave the Edge. The session covers how to deploy a lightweight DaemonSet tuned for K3s or MicroK8s using the OpenTelemetry Collector Contrib, integrate Fluent Bit for unified log ingestion, and maintain data integrity during disconnections. It shows what it takes to make observability truly sustainable in constrained Edge environments.

Making Observability Work at the Edge

As CNCF efforts evolve beyond infrastructure, improving the developer experience has become a central focus. The rebooted CNCF Technical Advisory Groups introduced TAG Developer Experience (TAG DevEx) to drive concrete, impactful outcomes across projects and their communities. This panel will showcase how TAG DevEx reduces friction in developer workflows, advances best practices, and delivers resources that benefit contributors and end users alike. We’ll highlight key initiatives and how TAG DevEx helps maintainers adopt a developer-first mindset. We’ll also discuss our ongoing efforts, including research around success stories and pain points from adopting secure coding practices, the emerging role of agentic AI in development, and a working group defining a specification for declaring application integration dependencies. Join us to learn how TAG DevEx is shaping the next generation of cloud native developer experience—and how you can get involved.

The Next Chapter of Developer Experience: TAG DevEx in Action

We have spent the last five years building 'Golden Paths' to help developers deploy faster. But the moment the application hits production, the path ends. We leave developers alone with a dashboard of squiggly lines and ask them to 'fix the performance'. This is not Platform Engineering; this is just fancy provisioning. The next evolution of the Internal Developer Platform (IDP) isn't about deploying code, it's about optimizing it. In this talk, we will explore how to build a Continuous Optimization Layer directly into your platform. We will see how to pipe Prometheus telemetry back into the deployment manifest, creating a closed loop where the platform automatically suggests runtime tuning, from Kubernetes limits to application runtime flags, without the developer ever touching a YAML file.

The Self-Improving Platform: Closing the Loop Between Telemetry and Tuning

We love ArgoCD, but it creates a classic 'map vs. territory' problem. We treat Git as our 'map', our single source of truth. But the cluster is the 'territory', and it's often more complex than the map shows. This becomes a crisis with the 3 AM hotfix: an SRE fixes production, changing the territory. ArgoCD, loyal to the map, sees this as drift and helpfully overwrites the fix, re-breaking the cluster. The problem is that Git isn't our Truth, it's our Intention. This talk introduces a pragmatic solution: Cluster-Scoped Snapshotting. We’ll show a simple pattern that dumps the entire live cluster state (the 'territory') into its own 'reality' Git repo. To automate this, we wrote a small open-source tool called Kalco, but the pattern is the real takeaway. This 'reality' repo gives us a powerful 'pre-flight diff' in our CI pipeline, comparing our 'intention' (the app repo) against the 'truth' (the snapshot repo). This simple check lets us bootstrap existing clusters, create a complete audit log, and stop our pipeline before it merges a change that conflicts with a critical live fix.

Your Cluster is Lying to ArgoCD (And How to Catch It)

Similar to previous Kubernetes releases, v1.35 introduces new stable, beta, and alpha features, consisting of 60 enhancements. Of those, 17 have graduated to Stable, 19 have graduated to Beta, and 22 are entering Alpha. Tune in to see the latest and greatest from the Kubernetes v1.35 Release Team!

Cloud Native Live: Kubernetes v1.35 Release

Join industry leaders in a panel discussion about the evolution of developer portals, exploring trends in developer experience, platform engineering, and the tools that will shape the future of software development workflows.

PANEL | The Future of Developer Portals

Learn advanced techniques for optimizing Kubernetes clusters for energy efficiency, including intelligent scheduling, resource management, and sustainable cloud-native practices that reduce environmental impact while maintaining performance.

The Kubernetes Compass: Navigating Space and Time for Energy Efficiency

Explore how to efficiently serve Large Language Models on Kubernetes clusters, covering resource optimization, scaling strategies, and best practices for platform engineers managing AI workloads in production environments.

Serving LLMs on Kubernetes: A Golden Path for Platform Engineers

Generative AI is rapidly changing how we build software. With powerful language models (LLMs) and the growing availability of smaller, more accessible models (SLMs), we are entering a new phase of development where intelligent agents play a central role. Just like we once moved from procedural programming to object-oriented programming, we are now moving toward a model where software is built around interactions between AI agents. In this new approach, APIs are essential. They are how agents connect to the outside world, talk to each other, and work with existing systems. In this talk, we’ll look at how to design software based on agent interactions, with a special focus on how APIs make this possible. We’ll explore how generative models can power agents that use APIs, expose APIs, and coordinate tasks through APIs. You’ll also learn practical patterns for building systems where multiple agents collaborate effectively using clear and well-defined interfaces.

SLMs and the Agents Revolution: Rethinking How Software Is Built

Get ready for a provocative and engaging session that challenges the very notion of who, or what, can deliver a compelling presentation! In this talk, an AI agent will be built right before your eyes. Using the Google ADK framework and Gemini, this agent will scour the internet, prepare a presentation, and then deliver it. But here's where it gets really interesting: by the end of the session, you, the audience, will choose the topic the AI agent has to talk about. This raises some fascinating questions: Can the information it presents be trusted? What does this mean for the future of knowledge and communication when an AI can 'speak' with authority? Join us to find out if an AI can truly become the speaker in the room!

Can an AI Agent Give a Talk? Let's Find the Speaker in the Room!

Perché mantenere acceso il tuo cluster quando non lo stai usando? Fai in modo che si spenga ogni notte! Con Crossplane e kube-green, puoi creare ephemeral environments che si attivano quando lavori e si spengono quando ti riposi. Immagina una configurazione che faccia il provisioning dinamico di un’infrastruttura complessa per i test, per poi spegnersi automaticamente durante le ore non lavorative come durante la notte o nei fine settimana. In questo talk, ti mostreremo come un IDP (Internal Developer Platform) può aiutare ad orchestrare in modo intelligente e on-demand la tua infrastruttura, in modo che gli sviluppatori possano concentrarsi sul creare applicazioni e non sul fare da babysitter ai cluster. Vedrai come funziona l’integrazione, esplorerai l’impatto su costi, efficienza e sostenibilità e scoprirai come passare da un infrastruttura statica a una dinamica ed eco-friendly. Risparmia denaro, riduci le emissioni e lascia riposare i tuoi cluster. Perché we will rock you, ma non per tutta la notte.

Another Cluster Bites the Dust… E Va Bene Così!

APIs are more than just tools; they are the foundation for building scalable and sustainable digital products. This talk explores how circular design principles can improve the way APIs are developed and used, enhancing the developer experience and delivering long-term value. Through real-world examples, we’ll explore how to leverage platforms designed to enable a circular API economy that emphasizes reusability, modularity, and interoperability to drive innovation, reduce technical waste, and foster collaboration. If you’re looking to build products that not only scale but also evolve gracefully and efficiently, this talk is for you. In API we trust!

In API We Trust: Circular Design for Scalable Platforms

Why keep your cluster alive when you’re not using it? Let it bite the dust, every night, and that’s just fine. With Crossplane and kube-green, you can unlock ephemeral environments that spin up when you code and shut down when you rest. Imagine a development setup that dynamically provisions complex infrastructure for testing, then automatically scales down during off-hours – like nights and weekends. In this talk, we’ll show you how Platform Engineering can orchestrate this smart, on-demand model, so developers can focus on building applications, not babysitting clusters. You’ll see the integration in action, explore the impact on cost, efficiency, and sustainability, and discover how to shift from static uptime to dynamic, eco-friendly infrastructure. Save money, reduce emissions, and let your clusters rest – because we will rock you, but not all night long.

Another Cluster Bites the Dust... and That's Just Fine!

Monitoring the behavior of a system is essential to ensuring its long-term effectiveness. However, managing an end-to-end observability stack can feel like stepping into quicksand. In this talk, we’ll explore how combining two worlds, developer platforms and observability, can help tackle the feeling of being off the beaten cloud native path. We’ll discuss how to build paved paths, ensuring that adopting new developer tooling feels as seamless as possible.

ROUNDTABLE | When Platform Engineers Meet SREs: The Birth of Observability-as-a-Service Superpowers

In this session, we’ll explore how platform engineering enables the seamless delivery of an AI-powered agentic architecture—from deploying open-source models to building and releasing a simple agent that interacts with real-world applications. Through a joint demo by Mia-Platform and ConfidentialMind, we’ll demonstrate how a GPU-powered cluster hosts both the ConfidentialMind Control Plane and the AI models, while the Mia-Platform Console serves as the unified entry point for developers. We’ll walk through the creation of a multi-tool agent built from templates available on the Mia-Platform Marketplace and powered by models deployed using the ConfidentialMind Control Plane. This agent interacts with our data to act as a shopping assistant for customers, providing product recommendations, stock availability, and suggestions for the nearest store based on the user’s location. Attendees will gain a clear understanding of how platform engineering practices simplify the complexities of AI model deployment, application development, and runtime management in a production-grade, scalable environment.

How Platform Engineering Streamlines the End-to-End Delivery of a Self-Hosted Agentic Architecture

As the world shifts toward renewable energy, the need to align computing workloads with the availability of green resources has never been more critical. In this talk, we’ll explore how Kubernetes can serve as a “compass”, guiding workloads across space and time to optimize energy efficiency. By leveraging temporal shifting to align workloads with periods of peak renewable energy generation and spatial shifting to dynamically move workloads to regions with surplus green energy, we’ll demonstrate strategies that not only reduce carbon footprints but also enhance cost-efficiency. Through real-world examples and practical insights, this session will showcase how temporal and spatial scheduling innovations can transform Kubernetes into a powerful tool for sustainable cloud operations. Join us to discover how to navigate the intersection of technology and sustainability, paving the way for a greener, smarter future.

As the technology landscape evolves and the need for adaptability to solve modern problems grows, Function-as-a-Service (FaaS) has emerged as a pivotal strategy to meet the elasticity demands of today’s systems. However, a pressing question remains: how can we make our functions truly portable, with minimal overhead, while achieving the high level of dynamism promised by FaaS? The answer already exists, and you don’t need the Infinity Gems to make it happen. All you need is wasmCloud, a CNCF incubating project, and a few tips to take the right path in building your own FaaS platform using WebAssembly (WASM). In this talk, we will dive into the world of Functions-as-a-Service, sharing insights on building a FaaS platform from the ground up with WASM and wasmCloud. We’ll provide practical examples and demonstrate how to create paved paths that empower developers to build high-performance functions—effortlessly, as if snapping their fingers.

Platform Engineers Assemble! Create Your FaaS Platform Using WASM

Monitoring the behavior of a system is essential to ensuring its long-term effectiveness. However, managing an end-to-end observability stack can feel like stepping into quicksand, without a clear plan you’re risking sinking deeper into system complexities. In this talk, we’ll explore how combining two worlds—developer platforms and observability—can help tackle the feeling of being off the beaten cloud native path. We’ll discuss how to build paved paths, ensuring that  adopting new developer tooling feels as seamless as possible. Further, we’ll show how to avoid getting lost in the sea of telemetry data generated by our systems. Implementing the right strategies and centralizing data on a platform ensures both developers and SREs stay on top of things. Practical examples are used to map out creating your very own Internal Developer Platform (IDP) with observability integrated from day 1.

Observability-as-a-Service: When Platform Engineers and SREs Join Forces

As a crucial part of a platform adoption journey, it’s essential to choose the right metrics to gain a clear, comprehensive view and drive success. While DORA metrics are valuable for platform teams, assessing platform adoption solely based on deployment frequency doesn’t make sense. Reflecting on our expertise, we’ve learned that measuring platform success involves two types of KPIs: progress metrics and outcome metrics. In this talk, we’ll explore how measuring both allows us to identify patterns and correlations between technical improvements and business success. By combining these two sets of KPIs, we gain a comprehensive view of the platform’s value. This approach helps stakeholders quantify the platform’s technical contributions while also understanding its influence on key business objectives. Ultimately, it enables us to set meaningful milestones for future improvements and effectively communicate the platform’s value across the organization.

From DORA to the SPACE and Beyond: Metrics to Drive Platform Engineering Initiatives

When Platform Engineers Meet SREs: The Birth of Observability-as-a-Service Superpowers

In today’s technological landscape, the synergy between Cloud Native technologies and Artificial Intelligence (AI) opens the stage to a myriad of unexplored challenges and opportunities. Dynamic, always-on and highly scalable infrastructures, typical of the Cloud Native paradigm, seamlessly integrate with AI’s need to rapidly prototype solutions and access vast computational resources. The convergence of these two worlds has exposed some gaps in the Cloud Native ecosystem that need to be addressed. At the same time, AI opens numerous opportunities for innovation that are yet to be explored. This talk will delve into the Cloud Native Artificial Intelligence (CNAI) paradigm as a holistic approach to unlocking the full potential of the cloud in managing AI workloads and aim to anticipate the growth opportunities that lie ahead for the Cloud Native world.

Challenges and Takeaways of Managing AI Workloads on Cloud

The increasing complexity of software development presents significant risks and inefficiencies, especially for large enterprises. That’s why companies require a structured approach to streamline software delivery, with a focus on platform engineering and internal developer platforms. While existing literature often discusses platform engineering in terms of DevOps tool integration and infrastructure provisioning, its scope extends far beyond these aspects. To truly enhance service scalability and quality, platforms must prioritize data encapsulation and composability. This means addressing not just the IT infrastructure, but the entire organizational framework. Infrastructure management represents only the tip of the iceberg; to drive a successful platform engineering initiative, factors like data management and composability are equally crucial. Let’s delve into the unspoken truths of platform engineering by examining the fundamental principles necessary for a successful platform initiative.

Platform Engineering Untold Truths: Is It Just an Infrastructure Matter?

In a context where the ICT sector alone produces around the 1.4% of global CO2 emissions, adopting mindful resource usage is of paramount importance. One of the most challenging aspects about green software is understanding where to start. Before delving into more complex things, a good starting point is to raise awareness of the hidden ‘zombies’ within our infrastructure and then proceed to eliminate them. In this session, we’ll explore what green software is, its environmental and economic implications and how kube-green (an open source project listed in the CNCF landscape) immediately help us make our cloud infrastructures more sustainable.

An Open-Source First Step to Greenify Your Cloud Environments

The cloud-native landscape brings incredible advantages, but it also introduces new security challenges, making safeguarding a top priority. In the traditional policy enforcement model, manual management leaves organizations vulnerable to inevitable breaches due to human error – a matter of ‘when,’ not ‘if.’ Enter Policy-as-Code (PaC), a game-changing approach that leverages code to define and manage policies, transforming rules and conditions into actionable directives. By keeping policy definitions in source code control, whenever a change is made, it can be tested, validated, and then executed. The goal of PaC is not to detect policy violations but to prevent them. In this session we delve into the practical implementation of a Policy-as-Code strategy for your organization using Rönd and Open Policy Agent, two powerful open-source projects that could help you to redefine your security paradigm implementing an RBAC authorization mechanism over your APIs.

A Policy-as-Code Approach to RBAC Authorization

In rapidly expanding cloud-native ecosystem, managing distributed architectures feels like navigating stormy seas with waves of telemetry data. Yet this data can offer vital insights to sail smoothly. This session will explore strategies to avoid drowning, improving DevEx, and more. The cloud-native ecosystem has grown exponentially in the last few years, as has the complexity of the distributed architectures being built. In a context where keeping up with technology requires a substantial amount of computational power and data, monitoring our cloud-native applications has become a constant struggle against the storm. The ever-increasing volume of traces, metrics, events, and logs generated by our systems is a double-edged sword: on one hand, if not managed correctly, becoming a distraction from needed insights. On the other hand, if approached with care and thought, providing organizations the chance to sail calm cloud-native seas. In this session, we will discover how to avoid drowning in the sea of monitoring data, instead understanding how to provide insights while using only what is needed. We will explore the emerging scenarios on the horizon, abandoning the oars and testing the waters of artificial intelligence as it applies to our observability use cases. We will discuss how to leverage monitoring data, conversational DevEx, and anomaly prediction, among other topics, in this talk.

Finding Observability and DevEx Tranquility Sailing the Monitoring Data Seas

Platform engineering, digital platforms, platform maturity, platform-as-product… When we hear these terms, we often focus on the ‘what’: understanding what platform engineering is, what we mean by digital platforms, and what it means to apply a product mindset to platforms. However, mere knowledge of the ‘what’ is often not enough; the most curious among us have often asked about the ‘how’: how do I begin my journey into the world of digital platforms? Well, if you have ever found yourself hitting a wall when trying to understand how to start your journey in adopting a digital platform, you have found the workshop that suits you! In this interactive workshop, using a Platform Journey Map, we will play the role of a Solution Architect who has to guide real companies through their platform adoption journey. Yes, you heard that right, we will be playing, because the journey is presented as a board game where the players, our fantastic Solution Architects, must conquer spaces to mature their platform. In this workshop, we won’t just talk about digital platforms as mere orchestrators of infrastructure, but there will also be room to discuss software lifecycle, architecture modernization, business composability, and market use cases.

WORKSHOP | The Game of Platforms: A Guided Journey into the World of Digital Platforms

The cloud-native landscape brings incredible advantages, but it also introduces new security challenges, making safeguarding a top priority. In the traditional policy enforcement model, manual management leaves organizations vulnerable to inevitable breaches due to human error – a matter of 'when,' not 'if.' Enter Policy-as-Code (PaC), a game-changing approach that leverages code to define and manage policies, transforming rules and conditions into actionable directives. By keeping policy definitions in source code control, whenever a change is made, it can be tested, validated, and then executed. The goal of PaC is not to detect policy violations but to prevent them. In this session we delve into the practical implementation of a Policy-as-Code strategy for your organization using Rönd and Open Policy Agent, two powerful open-source projects that could help you to redefine your security paradigm.