Open Source Summit + Embedded Linux Conference North America 2026

Public health systems increasingly rely on open source cloud infrastructure to deliver critical services, yet many are built and operated under tight budget, connectivity, and skills constraints.

This talk shares real-world lessons from designing, deploying, and operating Linux-based, open source cloud infrastructure supporting malaria control and public health programs in Ghana. It covers practical decisions around hybrid cloud architecture, containerization, data reliability, security tradeoffs, and operational resilience in environments with intermittent connectivity and limited resources.

Rather than theory, this session focuses on what actually worked, what failed, and how open source tools enabled sustainable systems for nonprofits and public sector teams. Attendees will gain actionable insights into building resilient, scalable cloud platforms using open source technologies—especially when operating outside ideal conditions.

This session is intended for practitioners building or maintaining cloud infrastructure who want honest, field-tested guidance from real deployments.

Traditional infrastructure GitOps workflows, commonly built on tools like Terraform or OpenTofu, often struggle with state management, limited reconciliation, and delayed drift detection. Because these systems operate outside the Kubernetes control plane, infrastructure changes follow different lifecycle and failure semantics than applications, making it difficult to reason about system-wide correctness and safety.

We’ll present a unified approach for managing both applications and infrastructure through the Kubernetes control plane. This approach brings together GitOps controllers and Crossplane to extend the Kubernetes API to infrastructure via an ecosystem of community-supported providers spanning major clouds, alternative clouds, and on-prem. The result is a vendor-neutral foundation where applications and infrastructure follow the same review, lifecycle, and reconciliation model.

What do a raccoon, a goat, and a goose have in common? They all take part in a tracing adventure where we’ll use OpenTelemetry and the Grafana observability stack to easily showcase a cloud-native observability scenario.

In this session, you’ll learn what distributed tracing is, why it’s incredibly helpful for understanding how requests flow through multi-service systems, and how it can reveal issues like latency and unexpected errors — alongside metrics, logs, traces, and profiles for a complete observability picture.

We’ll walk through a multi-service application that uses AI to generate animal facts and images, tracing each request from API call to fact and image generation to database storage. Along the way, you’ll learn how to use OpenTelemetry to instrument Python and Java applications and visualize the full request journey using easy to understand, open-source dashboards for metrics, logs, traces, and profiles.

If a goat can survive cloud-native observability, so can you.

Microservices promised speed and independence, but for many SREs and developers, they delivered network complexity. Suddenly, we're all part-time network engineers. We have to code retry logic, timeouts, and circuit breakers into every service. We struggle to get uniform "golden signal" metrics. And how do we enforce that all 50 of our polyglot services are communicating securely over mTLS?

This is the "microservice tax," and it's holding us back.

Enter the service mesh. You've heard the buzzwords, Istio, Linkerd, but what is a mesh, and what problems does it actually solve? Is it just hype, or is it the key to taming a complex distributed system?

We'll cover the three pillars of a mesh:

Reliability: Automatic retries, timeouts, and circuit breakers.

Observability: Uniform metrics, logging, and tracing for every call.

Security: Automatic mTLS (encryption) and fine-grained authorization policies.

Containers are the de facto deployment model for our applications today, but is your Container Runtime appropriate for multi-tenant workloads?

If you don't know which Container Runtime you're using today, then it's likely that you're using a shared kernel, so your multi-tenant workloads aren't as isolated as you might think they are.

In this talk, we'll demonstrate how MicroVMs can provide a Hardened Container Runtime. We'll build an understanding of why namespaces and cgroups are limited in the isolation they provide, how the MicroVM architecture can provide an isolated kernel, and the open-source tools available today to implement this.

To demonstrate this, we'll use a Multi-Tenant Kubernetes Cluster to show an attack that can break container isolation, and how MicroVMs can mitigate it.