From Ideas to Impact: Cloud Native AI and TOC Highlights Post-KubeCon EU 2025

When we previewed the CNCF Cloud Native AI Working Group’s efforts ahead of KubeCon EU 2025, the tone was of curiosity and anticipation. Some still viewed AI as an outlier in the cloud-native world. But if KubeCon EU proved anything, AI has now fully arrived—and the community is building it in a cloud native way.

This year’s event didn’t just validate the momentum around AI; it showcased a CNCF community that’s actively rethinking its foundations—from how Technical Advisory Groups (TAGs) work to how the community serves end users to how projects grow and graduate. The CNCF Technical Oversight Committee (TOC) had a visible and influential role throughout the week, laying down a clear marker: the next wave of cloud native isn’t just about orchestration—it’s about intelligence, usability, and sustainable growth.

Over the past six months, the Cloud Native Computing Foundation’s (CNCF) Cloud Native AI (CNAI) Working Group has been at the forefront of integrating artificial intelligence (AI) and machine learning (ML) with cloud-native technologies. This is a moment to discuss the working group’s initiatives and opportunities for contributors and enthusiasts as we prepare for KubeCon Europe 2025 in London.

The group has been making strides in galvanizing the community around the needs of AI/ML workloads on top of cloud native environments. A significant deliverable was the publication of the “Cloud Native AI” whitepaper in March 2024.

Hello everyone! I’m excited to write this post about my experience at the Kubernetes Forum Seoul and Sydney 2019. My journey started in San Francisco on Friday evening, December 6th, 2019, on a flight to Seoul.

I arrived in Seoul on Sunday, December 8th, in the morning and had plenty of time during the day to rest in the hotel at the venue, The Seoul Dragon City. As speakers, we were invited along with the organizers and community leaders to an event dinner in the Goguryeo room. During that time, we had a great start networking with fellow industry leaders with an opportunity to connect. In my opinion, the number of people was just right to talk to most of the guests at dinner.

This page has been moved

The Kata community has been busy getting the first release out the door.

Virtual Machines have been around in the industry for over 20 years. One of the most attractive features of Kata is that it runs containers in VMs and VMs are very stable and provide very good isolation of your compute resources hardware. Furthermore, virtualization systems like KVM, Xen and VMware provide multiple ways to attach to dedicated storage. VMware takes this step even further by providing things like Storage VMotion.

It has been about 4 years since Docker exploded into the scene of Cloud Infrastructure. With that came a shift in cloud applications from monolithic to microservices. Containers made it easy for developers to deploy directly to production mostly caring about the scope of her/his microservice.

Enter container orchestration tools such as Kubernetes, Mesos, AWS ECS, GKE, Azure Container Service which allow cloud operations to manage containers at scale. Setup these tools with a redundant masters as quorum systems (k8s, mesos) and add hundreds of nodes or slaves and automatically scale your containers up and down depending on demand.

It has been about 4 months since I started working at Branch and wanted to reflect on what it’s been like.

I can truly say that I’m enjoying everything about it. The environment is fantastic, my co-workers are awesome, and we all come from various backgrounds.

I like the fact that the company takes their values seriously and the founding team is focused on making working at Branch the best experience you’ve ever had in your career. There’s also a very strong focus on diversity as the founding team puts it: The more diverse we are, the better we will be positioned in the long run. Being more diverse allow us to bring in different points of view and experiences that in the end help us progress more efficiently. I can’t say that there are many places like that.

Kubernetes has come a long way over the last 2 years and I was so excited to learn about during CloudNativeCon/Kubecon Berlin this year.

As of Today Kops the standard tool for installing Kubernetes on AWS doesn’t support GCP yet (it’s in the works). However you can still setup your cluster using good old kube-up.sh. There’s also a pretty good explanation on the k8s docs. Make sure you install the Google Cloud SDK with gcloud and all their utils.

DC/OS is the commercialized Mesos distribution + extras maintained by Mesosphere. I found it very straight forward to setup in GCP with the out of the box Ansible scripts provided by Mesosphere.

For starters I followed everything described in the README.

Then, I had to modify the group_vars/all file in the playbook

---
project: <my-gcp-project-id>
subnet: default
login_name: <my-gcp-login-id-with-no-email>
bootstrap_public_ip: 10.128.0.10 # This IP need to match the network in the zone
zone: us-central1-c

master_boot_disk_size: 200 # 200 is the recommended in GCP as of 05-2017
master_machine_type: n1-standard-1
master_boot_disk_type: pd-standard

agent_boot_disk_size: 200
agent_machine_type: n1-standard-1
agent_boot_disk_type: pd-standard
agent_instance_type: "MIGRATE"
agent_type: private
start_id: 0001
end_id: 0001

gcloudbin: gcloud
image: 'centos-7-v20161027'
image_project: 'centos-cloud'
bootstrap_public_port: 8080
cluster_name: cluster_name
scopes: "default=https://www.googleapis.com/auth/cloud-platform"
dcos_installer_filename: dcos_generate_config.sh
dcos_installer_download_path: "https://downloads.dcos.io/dcos/stable/{{ dcos_installer_filename }}"
home_directory: "/home/{{ login_name }}"
downloads_from_bootstrap: 2
dcos_bootstrap_container: dcosinstaller

Then to create the master I ran:

Parsing deeply nested json in Go is a bit challenging due to the fact that the language doesn’t provide many helpers to do so. If you do that in Ruby or Python it’s pretty straight forward running some like this in Python j = json.load(jsonstring) or in Ruby j = JSON.load(jsonstring).

In go generally you have to prefine your structs and run through an Unmarshal function which means that most of the times you need to know ahead of time what the nest level and structure of your target json is to parse it. For example: