• Kubernetes Cloud Native CI/CD: A New Era with Tekton

    For those looking to manage CI/CD processes on K8s seamlessly, Tekton offers a powerful and flexible solution. Tekton leverages pods and container architecture, ensuring each step is isolated and scalable. With its reusable and modular structure, you can define workflows using Task and Pipeline concepts, enabling integration across different workflows. Additionally, Tekton Triggers allow the creation of event-driven pipelines using webhooks, enabling seamless integration with any programming language or toolset. Thanks to its lightweight and K8s-native architecture, Tekton offers a more flexible, GitOps-compatible, and scalable alternative to conventional solutions such as Jenkins. We will explore Tekton’s architecture, core components, and practical use cases, demonstrating how it meets the demands of modern CI/CD workflows. This session is a must-attend for those seeking a lightweight, fast, and easily manageable CI/CD infrastructure within K8s-based development environments.

    Main Stage
    Fri 09:45 - 10:15
    • English

  • The Cluster API Migration Retrospective: Live migrating hundreds of clusters to Cluster API

    Cluster API has become the industry standard for managing Kubernetes clusters, taking care of the heavy lifting of cluster operations.
    However, migrating to Cluster API can still be challenging, especially for organisations heavily invested in existing cluster management tools.
    This talk presents Giant Swarm's journey from a custom operator-based Kubernetes cluster management system to Cluster API, including the live migration of hundreds of production clusters of major enterprises such as adidas and Vodafone.
    The driving force for the migration will be covered, followed by challenges encountered during the migration, concluding with a discussion of the observed benefits and differences seen post-migration.
    Attendees will come away with an understanding of potential risks and challenges to be considered when migrating to Cluster API, a better insight into the expectations and efforts required, and the benefits of using this upstream project.

    Main Stage
    Fri 10:30 - 11:00
    • English

  • Building Kubernetes Operators in Rust: A New Operator SDK Plugin

    Rust is gaining traction in cloud-native development due to its speed, memory safety, and concurrency. With `kube-rs`, Rust provides a powerful interface for building Kubernetes controllers, but integrating it into the Operator SDK has been a gap—until now.

    In this talk, I’ll introduce `rust-operator-plugins`, an extension enabling Rust developers to leverage the Operator SDK for building Rust-based Kubernetes Operators. We’ll explore the plugin’s capabilities, demonstrate developing an operator with it, and discuss Rust’s advantages in cloud-native ecosystems.

    Whether you're a Rust enthusiast or an operator developer, this session will showcase how `rust-operator-plugins` can elevate Kubernetes operator development.

    Main Stage
    Fri 11:30 - 12:00
    • Turkish

  • The Hacker's Guide to Pod Escape

    As Kubernetes leads the way in container orchestration, securing clusters has never been more crucial. A major threat is pod escape, where attackers breach container isolation to access the host system or other containers, potentially compromising the entire cluster.

    This talk demystifies the concept of pod escape in Kubernetes. We'll break down how misconfigurations, insecure defaults, and overlooked vulnerabilities can open doors for attackers. Through live interactive demos, you'll learn about common security pitfalls such as misconfigured security contexts, privileged containers, and sharing host namespaces.

    Not only will you learn about common mistakes and vulnerabilities, but you'll also discover best practices for container security, including setting up proper security contexts, enforcing the principle of least privilege, and effectively utilizing Kubernetes security features.

    Main Stage
    Fri 12:30 - 13:00
    • English

  • Bridging the Gaps: Communication Strategies for Kubernetes Releases

    In this talk, I’ll explore how the Kubernetes Communications Team serves as the vital link between the technical contributors driving Kubernetes innovation and the global community relying on it.

    You’ll learn how we:
    - Coordinate across SIGs (Special Interest Groups) to capture and clarify key updates, to review changes and ensure the quality of the information provided is the highest possible.
    - Translate technical release notes and KEPs into actionable insights for end users in the form of release blogs.
    - Leverage tools and strategies to keep communication seamless, even in one of the most fast-paced open source projects in the world.

    Whether you’re planning to contribute to Kubernetes, navigating its releases or maintaining any open source project, this session will provide insights into how open source communication practices can amplify collaboration, transparency, and serve your users.

    Join me to understand how communication drives the Kubernetes evolution!

    Main Stage
    Fri 14:00 - 14:30
    • English

  • Delivering Kubernetes as a Platform with Multi-Tenancy

    At TomTom, we found ourselves managing hundreds of Kubernetes clusters, with each team handling their own cluster from beginning to end using a blueprint we provided. This approach started causing problems—some clusters weren't fully utilized, and we ran into compliance issues with security and keeping up with supported versions.

    To address this, we decided to let teams share Kubernetes clusters while making sure they stay isolated and don't interfere with each other. We used Kubernetes multi-tenancy with Capsule and set up Backstage so teams can create their own tenants through self-service.

    In this session, I'll talk about how we shifted to this multi-tenant setup, the challenges we faced, and the benefits we've seen since making the change.

    Main Stage
    Fri 15:00 - 15:30
    • English

  • Building Air-Gapped Control Planes for a Global Pharma Leader Using Crossplane and ArgoCD

    Operating in air-gapped environments imposes strict limitations on connectivity, security and compliance. This session tells the story of designing and implementing a secure, air-gapped control plane setup for Novo Nordisk, one of the world’s largest pharmaceutical companies, leveraging Crossplane for declarative infrastructure management and ArgoCD for GitOps workflows.
    We’ll share how Novo Nordisk adopted and scaled the setup within their highly regulated environment:
    -Architectural decisions tailored to the demands of the pharmaceutical industry
    -Overcoming challenges related to security, scalability, and operational efficiency
    -Strategies to replicate GitOps workflows in disconnected systems while maintaining the integrity of continuous delivery pipelines
    The talk will dive deep into the technical challenges and solutions, focusing on how open-source tools like Crossplane and ArgoCD can be adapted for highly controlled environments without compromising functionality or flexibility.

    Main Stage
    Fri 16:15 - 16:45
    • English

  • End-to-End Pull Request Testing on Kubernetes: A Walkthrough

    As applications increasingly rely on Kubernetes for deployment, ensuring seamless integration and end-to-end testing during pull requests is crucial. This talk dives into the practical steps of building a robust CI/CD pipeline that mirrors production environments, enabling reliable and efficient testing within your Kubernetes ecosystem.

    We’ll explore how to:

    * Set up foundational unit and integration tests using modern tools like Testcontainers and GitHub Workflows.
    * Integrate Google Kubernetes Engine (GKE) to emulate a production-grade cluster for testing.
    * Leverage vCluster to isolate test environments, ensuring parallel runs and minimizing interference.
    * Attendees will gain actionable insights to create scalable and maintainable testing pipelines via an existing working example.

    Depending on the audience, I can focus more on a aspect or another.

    Main Stage
    Fri 16:45 - 17:15
    • English

  • From Code to Leadership: Navigating the Tech Landscape as a Woman

    Navigating the tech landscape as a woman comes with unique challenges and opportunities. "From Code to Leadership: Navigating the Tech Landscape as a Woman" offers a comprehensive guide to career growth, leadership development, and the impact of diversity in technology. This presentation provides practical advice for women aspiring to transition from technical roles to leadership positions, emphasizing the importance of continuous learning, mentorship, and building a personal brand.

    Main Stage
    Fri 17:15 - 17:45
    • English

  • Double the Efficiency: Kubernetes Autoscaling with Karpenter and KEDA

    Autoscaling in Kubernetes can be significantly simpler when you have the right tools to help you. Who doesn’t want a highly efficient Kubernetes cluster? You, me, and even our planet. The novel approach of Karpenter for node autoscaling helps many organisations reduce their spending by up to 70% on their cloud infrastructure. KEDA as an established standard for pod scaling plays an equally important role in the autoscaling ecosystem. How can these two technologies work together for even greater efficiency? This session offers practical insights from KEDA and Karpenter contributors into the current state of autoscaling, and it will give you a set of useful recommendations you can apply after leaving the conference.

    Main Stage
    Sat 09:45 - 10:15
    • English

  • Introduction to Distributed ML Workloads with Ray on Kubernetes

    The rapidly evolving landscape of Machine Learning and Large Language Models demands efficient scalable ways to run distributed workloads to train, fine-tune and serve models. Ray is an Open Source framework that simplifies distributed machine learning, and Kubernetes streamlines deployment. In this introductory talk, we'll uncover how to combine Ray and Kubernetes for your ML projects. You will learn about:
    - Basic Ray concepts (actors, tasks) and their relevance to ML
    - Setting up a simple Ray cluster within Kubernetes
    - Running your first distributed ML training job

    Main Stage
    Sat 10:30 - 11:00
    • English

  • WASM On, WASM Off for Telemetry with Fluent Bit

    Much like the Karate Kid, this will be a journey of learning how to use a powerful new technique (namely WASM) to solve your problems without "sweeping the leg".

    As a dubious engineer looking at the perennial "it'll be useful next year" WASM, I will cover my journey starting from a new starter in the world of WASM up to deployment along with all the trials and tribulations along the way.

    I will go over my successes and failures when attempting to use WASM to solve some of the problems I come up against in the observability space - in this case with the Fluent Bit project but they can be generalised hopefully to a lot of other scenarios.

    I will try to weave this narrative together with some Karate Kid references and hopefully keep it entertaining.

    Main Stage
    Sat 11:30 - 12:00
    • English

  • Optimizing CI/CD with KEDA: Autoscaling for Efficiency

    It focuses on leveraging KEDA (Kubernetes Event-driven Autoscaler) to automate the scaling of CI/CD pipeline agents.

    Main Stage
    Sat 12:30 - 13:00
    • Turkish
    • English

  • The Perfect Trio: Managing Thousands of Applications on Kubernetes with Helm, ArgoCD, and GitOps

    Having implemented this solution in the real-world infrastructure of one of the largest banks in Turkey, I’ve seen firsthand how managing thousands of applications across dozens of Kubernetes clusters can transform from a daunting task into a streamlined, automated process. Hundreds of developers and SREs rely on this cloud-native implementation daily to efficiently manage deployments at scale. In this session, we’ll dive into the power of the GitOps methodology, leveraging Helm for templating and packaging, and ArgoCD for continuous delivery. Learn how these technologies work together to ensure scalability, consistency, and efficiency in your Kubernetes ecosystem. Whether you're operating at a small scale or managing clusters globally, this talk will equip you with actionable insights to optimize your Kubernetes deployments. Join us to discover how you can achieve seamless scalability with Helm, GitOps, and ArgoCD!

    Main Stage
    Sat 14:00 - 14:30
    • Turkish

  • Two Sides of the Platform Coin with Operator’s and Customer’s Voices

    In the evolving landscape of platform engineering, building a robust, production-ready platform isn’t just about choosing the right tools—it’s about fostering a partnership between operators and customers to unlock actual organizational value. In this talk, we’ll share a dual-perspective journey: from an operator crafting the foundation with open-source tools like Kubernetes to a customer leveraging the platform to accelerate innovation and deliver results. We’ll explore how collaborative platform engineering aligns technology and builds a strong ecosystem for providing exceptional products.
    Learn practical lessons on productionizing platforms, ensuring adoption, and driving measurable impact. Whether designing platforms or using them to build products, this session will leave you with actionable insights on creating a shared path to success. Join us to understand the "why" behind platform engineering and discover its transformative potential for organizations and the tech community.

    Main Stage
    Sat 15:00 - 15:30
    • English

  • Cloud-Native Task Scheduling for AI & Analytics: Kubernetes at Scale

    In the AI landscape, there are many HPC platforms for running analytics and AI tasks. However, most of these platforms are designed for institutions that rely on bare-metal servers. While this works for corporations and universities, many companies prefer a cloud-native approach that allows them to use any type of cloud, including their own.

    This presentation will share the journey of a Platform Engineer searching for the best cloud-native HPC/task scheduler/executor on Kubernetes or VMs, balancing performance and cost. When existing solutions fell short, they built a platform using native Kubernetes tools like Jobs and Persistent Volumes.

    By the end, you'll learn how to create a low-cost, high-performance task scheduler/executor that will satisfy both your product teams and your CTO.

    Main Stage
    Sat 16:15 - 16:45
    • Turkish

  • The Infinite Hotel: Scaling Multi-Tenant Platforms through a Unified API

    As platform teams evolve, platforms extend beyond infrastructure to application services, cloud resource management, and middleware orchestration. Managing these distributed components across clusters and teams demands a unified, scalable approach. This session shows how to manage infrastructure, tenants, and application services entirely through Kubernetes by building a modular, multi-tenant, multi-control-plane platform. Attendees will learn to extend the Kubernetes API with Control Planes for distributed, tenant-aware infrastructure management. We’ll explore CNCF projects to create abstractions and automation, enabling platform teams to offer consistent services and self-service capabilities. Topics include multi-tenancy with in- and out-of-cluster isolation, unified APIs for control-plane orchestration, and avoiding common pitfalls in multi-control-plane management. By the end, attendees will have a roadmap for scalable platforms supporting centralized and tenant-managed services.

    Main Stage
    Sat 16:45 - 17:15
    • English

  • Git Shit Done, the GitOps Way

    Are you an avid cloud user, and are now contemplating Kubernetes for your project? Did you already start to play with clusters, controllers, pods and anything K8s? In both cases, stop what you are doing right now, and let me help you in your container orchestration journey by introducing you to GitOps. I know, I know… you barely jumped the DevOps wagon, and there is already this new kid in town. Worry not my friend, because this talk will set you on the path to success for implementing Continuous Deployment (CD) for cloud native applications. You’ll learn what the hell is GitOps, and how it will help you better collaborate with your team, deploy & iterate faster within a more secure environment, while saving some costs on the road. In the end, you’ll leave with concrete steps to implement best practices to get shit done, the GitOps way!

    Main Stage
    Sat 17:15 - 17:45
    • English
Session and Speaker Management powered by Sessionize.com