Content Hub
Explore all sessions from all editions of our event. Search our archive by title, topic, or speaker.
Agentic AI in Platforms: Verticalizing Intelligence for Regulated Domains
William Rizzo
Agentic AI is moving from experimental copilots to production-grade systems that reason, plan, and act across complex enterprise platforms. Recent open-source architectures from OpenAI, Google, Microsoft, and FINOS show a convergence toward multi-agent systems orchestrated over shared, governed context rather than isolated sub-agents. This talk explores how these patterns can be productized as cloud-native platform capabilities: agent runtimes, context layers, tool gateways, policy and evaluation pipelines, and orchestration planes. We will show how platform teams can verticalize these primitives into domain-specific "agent platforms" for fintech, healthcare, telco, mobility, and contracting, embedding compliance, observability, and safety by design. Attendees will learn how agentic systems map to modern platform engineering concepts, how context engineering becomes a first-class platform concern, and how to build reusable, governed foundations for the next generation of autonomous digital services.
API-First IDPs on Kubernetes: Unifying APIs, Workloads & Developer Experience
Erandi Ganepola
Internal Developer Platforms often begin as SRE-focused clusters and CI/CD pipelines, but their real value emerges when they become API-first. In this talk, we explore how API-first Internal Developer Platforms (IDPs) can unify API design, service and workload deployment, gateway policies, security, observability, and developer workflows into a single, cohesive experience built on Kubernetes. We'll walk through a practical API-first reference architecture that shows how teams can design and publish APIs, deploy workloads via GitOps, apply security guardrails automatically, and access architecture and topology insights from one platform. Along the way, we highlight key business outcomes such as faster time-to-market, improved onboarding, lower operational overhead, built-in security and compliance, reusability, and better visibility for engineering and product stakeholders. Using an open-source IDP (OpenChoreo - https://github.com/openchoreo/openchoreo) as a reference implementation, this session demonstrates how API-first platform engineering accelerates delivery, reduces cognitive load, and creates golden paths that developers genuinely want to follow.
Applying CI/CD Patterns to Bootc Containers
Alessandro Rossi
Bootc Containers fundamentally changed how the traditional Linux Operating System is built, packaged, and distributed. By leveraging many of the same technologies and approaches prevalent in Cloud Native infrastructures, over a decade's worth of innovation can be applied to simplify the delivery of CentOS, Fedora and RHEL. In this session, attendees will learn how to apply Continuous Integration and Continuous Delivery (CI/CD) practices to Bootc Containers, including the steps involved, as well as integration with several popular CI/CD tools: Tekton, GitHub Actions, GitLab CI, Jenkins, AWX, and more. By incorporating CI/CD practices to Bootc Containers and introducing a series of tool-specific examples available within the Open Source community, attendees will be empowered with the skills necessary to reliably build and deploy RHEL at scale and to contribute to a growing library of Open Source example implementations.
Beyond Tool Sprawl: Accelerating Operations in the Multi-Cloud World
Eleni Grosdouli
Feeling overwhelmed by the complexity of the cloud-native landscape and Kubernetes application deployments? Modern teams find themselves juggling multiple tools creating operational chaos and overload. When teams roll out production workloads, their goal goes beyond keeping things running. They also need simple, reliable ways to manage them daily without the constant context-switching between platforms. What if we had a tool that would simplify ongoing management, reduce tool sprawl, and enable on-demand deployment of applications? In this lightning talk, we'll explore how Kubernetes and Sveltos help teams of all skill levels consolidate their tooling and speed up business operations. We'll unravel how a label-based, event-driven approach can cut through tool sprawl while speeding up the deployment of services, such as databases, network policies, reducing manual overhead, operational complexity, and the burden of managing too many tools.
Booting into Kubernetes with an Immutable OS
Santiago Merlos
Kubernetes platforms often struggle with configuration drift and inconsistent environments across clusters. Reproducing the exact same setup across nodes and environments can become complex when operating systems and system components evolve over time. What if the operating system itself was immutable and fully controlled through declarative configuration? In this session, maintainers of the SIGHUP Distribution will share how we designed an immutable Kubernetes platform built on top of Flatcar Container Linux, optimized for on-premises environments. By removing traditional package managers and mutable system components, the platform eliminates configuration drift while reducing the attack surface. The operating system is preconfigured and tuned specifically for Kubernetes, with managed kernel parameters and system-level settings aligned with the architecture of the SIGHUP Distribution. Custom system extensions are used to deliver tightly integrated components, improving cohesion between the operating system and the Kubernetes stack while preserving immutability, security, and operational consistency across all cluster nodes. The session will include a live demo showing how we bootstrap a cluster from a PXE boot to a fully operational immutable Kubernetes cluster with a single command. Along the way, we will explore how immutable infrastructure enables reproducible environments, declarative system management, and consistent platform operations for Kubernetes clusters.
Building Infrastructure Tools with Kubernetes Operators and Go
Rabieh Fashwall
In this hands-on workshop, participants will learn how to build powerful infrastructure management tools using Kubernetes (K8s) Operators written in Go. Kubernetes Operators extend the functionality of Kubernetes by automating complex, domain-specific tasks, and managing custom resources at scale. Through this workshop, attendees will gain a deep understanding of the Operator pattern, best practices in Operator development, and how Go can be used to create robust, production-grade Operators. Key topics covered will include: - Introduction to Kubernetes Operators: What they are, why they're needed, and how they fit into the Kubernetes ecosystem. - Deep dive into the Operator Framework: Building, testing, and deploying Operators with Go. - Custom Resource Definitions (CRDs) and how to manage lifecycle events of custom resources. - Best practices for error handling, reconciliation loops, and scalability in Operator development. - Hands-on labs: Writing a simple Operator in Go to manage real-world infrastructure resources. - Advanced Operator patterns, including status management, handling upgrades, and building for high availability. By the end of the workshop, participants will have practical experience building a functional Kubernetes Operator using Go, along with the foundational knowledge needed to develop custom tools for automating and managing infrastructure at scale.
Building Platforms with Crossplane: A Hands-On Introduction
Riccardo Capraro
In this hands-on workshop, we'll take you from zero to building your first internal developer platform with Crossplane. Whether you've heard about Crossplane but never touched it, or built a small PoC but got stuck going further, this workshop is for you. ### Who should attend ### DevOps engineers, platform engineers, cloud engineers, and technical leads who want a practical, guided introduction to Crossplane. Beginner-friendly - no prior Crossplane experience required. ### What you'll learn ### By the end of this workshop, you will: - Understand what Crossplane is, how it works, and when it makes sense to use it (vs. alternatives like a Terraform module in a pipeline) - Know the core building blocks: Providers, Managed Resources, Composite Resource Definitions (XRDs), Compositions, and Functions - Be able to create managed resources and write a basic Composition for a real-world use case - Understand how Crossplane fits into the bigger picture: GitOps, platforms, and team self-service ### How it works ### The workshop is split into thee parts: 1. Short intro on key Crossplane concepts A focused introduction covering Crossplane's architecture and resources, how it extends Kubernetes with CRDs and controllers, and where it fits in the IaC and platform engineering landscape. 2. Hands-On Lab Working in small teams (or solo), you'll build a working platform from a curated set of guided exercises. 3. Wrap-up and your questions A dedicate slot for your questions and to talk about real-world experience: what works, what doesn't, and how to go from workshop to production. We'll cover how to organize your code and repos, and what the path looks like to roll out Crossplane in an organization. ### How to prepare ### You bring the laptop, we give you the environment. Nothing else needed (except a Github account). ### What we expect from you ### - Basic Kubernetes knowledge: you can use kubectl, you know what a Deployment and a Service are, and you've heard of CRDs and controllers - An idea of what IaC and GitOps mean - not intricate setups, just the general principles ### Bonus #### What we can optionally dive into during the Q/A se: - Using different languages for Compositions (Python, KCL, Go) - Writing a custom provider or function - Packaging configurations into OCI images with dependency management - Setting up Crossplane with ArgoCD / GitOps - Integration with policy engines (OPA, Kyverno) - Testing strategies: rendering, assertions, and E2E
Building, sharing, running and governing AI Agents
Stephane Montri
AI Agents are already in your SDLC. Coding agents, MCP tools, LLM-powered workflows - 84% for new code is AI-generated, 79% of companies are running agents across roles. If you want the benefits of agents (move faster, ship more software, automate workflows), you need governance. In this lightning talk, we will cover what is needed and how AI governance looks like and how Docker is helping to govern the full agent lifecycle in one backbone from local to cloud.
Change Drives Cloud Native: Radical Experiments in Kubernetes
Ralph Squillace
Understanding where Kubernetes came from and what worldwide usage has taught us about containers -- let alone orchestrators and Linux -- is critical to having a clear road to making things better. This session proposes to discuss the past of containers and Kubernetes and why strange things keep appearing -- and how some of them are the future. Several demos and yes, **some** AI, will help clarify what the community is really driving at and help you think about your place in it.