CNCF Triggers a Platform Parity Breakthrough for Arm64 and x86

Snapshot

Challenge

Developing open source software for deployment on Arm64 architecture requires a robust CI/ CD environment. Yet, there has historically been a disparity between the levels of support for Arm64 and traditional x86 processor architectures, with Arm64 usually at a disadvantage. Developers of infrastructure components for multiple architectures have certain expectations of their work environments:

• Consistency: of the tools and methods they use across platforms, so that they don’t have to adopt different development procedures just to adopt a less prevalent platform
• Performance: from their platforms and support mechanisms, so their deployment schemes don’t suffer from speed deficiency when they choose to support multiple platforms
• Testing coverage: so the very same tests for efficiency, compliance, and security apply to all platforms simultaneously and without substantial differentiation
• Maintainability: enabling developers to automate their integration and redevelopment processes so they apply to all platforms without alteration

Product managers for these same components have these same requirements, plus at least two more:

• Platform coverage: capability, so that technical account managers (TAM) may have the skills and readiness they need to respond to customer needs
• Support tiering: capability, enabling TAM and other IT personnel to classify their levels of software support according to their capability to respond to urgent or emerging customer issues

Solution

Working in collaboration with both Ampere and infrastructure provider Equinix, open source developer Alex Ellis made available his Actuated CI/CD platform to some of the most critical open source projects in the cloud-native software ecosystem.

Actuated takes GitHub self-hosted automation processes demonstrated by security engineers to be inherently vulnerable to malicious attack, and runs them in microVMs abstracted from the public Internet.

Implementation

Several key open source Cloud Native Computing Foundation projects took advantage of an Actuated environment to run all of their GitHub Actions for Arm64. This environment is based on Ampere® Altra® processors made available with the help of infrastructure provider Equinix.

The success of this initiative was instrumental in prompting GitHub to implement full support of Arm64 architecture with GitHub Actions. Now, developers who had been running Arm64 build processes in QEMU emulation environments on x86 architectures can relocate those processes to Arm64 on bare metal.

Self-hosted runners for GitHub Actions on ARM64

GitHub dominates the hosting of software projects these days. The most popular way that GitHub-hosted projects generate builds and releases for Continuous Integration is with the platform’s built-in CI toolset, GitHub Actions. The most important role played by the GitHub Actions CI/CD platform is the automation of software development pipelines.

The party responsible for triggering any GitHub Action is a runner. It’s an agent running on a server, waiting for something to do and eager to do it once it’s given the assignment. It’s given a job from the workflow and tasked with getting it done.

GitHub is a complete software deployment platform. As such, it hosts its own runners, each of which is adapted to its specified target environment and architecture. Until recently, GitHub did not offer hosted runner environments for Arm64. Projects that wanted to generate Arm64-native builds did have an option – the self-hosted runner.

GitHub users could install an agent on a physical or virtual machine hosted elsewhere, and have GitHub Actions dispatch jobs to that host, managed by the project users. This required project administrators to not only manage the project itself, but also to take care of the maintenance and security of the build environment that the projects would use.

In CNCF’s case, developers took advantage of credits to Equinix Metal, enabling them to provision bare metal instances use them as self-hosted runners for projects. But for a code lab whose projects must be made available 24/7/365 to other developers worldwide, the security of self-hosted runners poses a challenge: Anyone could clone the project repository, modify the Actions jobs, and get access to the runner node to run arbitrary jobs, according to GitHub documentation.

Another problem was ensuring consistency between CI runs. With self-hosted runners, if there were side-effects of the CI jobs, such as configuration changes or files left behind afterwards, they would still be there for ensuing jobs.

This posed a problem – when running a CI job to build or test software, you should have a controlled environment, so that the only thing that changes between runs is the software. In the case of self-hosted runners, the environment can drift over time. In the absence of a cleanup process, it was possible for runs of the same build job on the same host to generate different results over time.

One way developers bypassed the need for Arm64 native runners was by running virtual Arm64 environments on x86 servers, using QEMU open source emulation. Emulated environments add a huge performance overhead for software compilations, which run at a fraction of the pace of compilations on native, non-emulated hardware.

Emulation worked well enough for developing small to medium projects. But if developers had to build something big and important for ARM64, the strain would become so great on their virtual environments that builds would completely fail.

“In the past, people were doing builds using QEMU. Say you were building a compiler, where the intermediate steps require large amounts of memory and very deep integration with the processor. That just would not work in an emulated environment.”

Ed Vielmetti
Developer Partner Manager, Equinix

The Disparity Phenomenon

Unlike the typical enterprise, the Cloud Native Computing Foundation has a special obligation to build its cloud-native components for all the world’s major processor architectures.

Projects such as the containerd portable container runtime, the etcd key/value data store, the fluentd log data collector, the Falco real-time threat detection tool, and the OpenTelemetry observability and instrumentation toolkit, among dozens of others, are critical dependencies for the cloud native ecosystem, and as such, must be built for both x86 and Arm64.

To build low-level infrastructure components with support for Arm64, CNCF developers need access to native Arm64 infrastructure. This means, ironically, they need the very class of tools they’re trying to create.

At first, Ampere and Equinix collaborated with CNCF to overcome these gaps, by donating Ampere Altra-based servers or setting up Altra-based bare metal nodes at Equinix facilities. The granularity of the Arm64-based server resources that Equinix could share were bare metal nodes – 160 core dual-socket Ampere Altra system.

Ideally, a server like this would be shared among several projects, but this was, at the time, beyond the capabilities of the CNCF. This is the problem that Ampere and Actuated proposed to solve for CNCF, by allowing multiple projects to run on a smaller number of hosts, thus providing easy access to build services for more projects, while consuming less hardware.

“OpenTelemetry is a full-on, full-time-on, CI/CD system. We were able to leverage [our Ampere server] infrastructure for ourselves, but we weren’t able to share it with open source at large. We cannot give GitHub runners away. Once we were happy with certifying the downstream distributions to our customers, we opened issues with the OpenTelemetry project saying we would like to see ARM64 support being delivered at the highest level — meaning, it should run for every commit, it should run for main, it should run all the time. And the feedback was, well, great, but there are no ARM64 runners in GitHub. So we’re going to need you to work with what we can do here.”

Antoine Toulmé
Senior Engineering Manager for Blockchain and DLT, Splunk
Maintainer, OpenTelemetry project

As a result of the lack of availability of easily available Arm64 platforms for these projects, developers were unaware if changes they were committing were causing issues on Arm64, because test suites were not being run as frequently as for x86.

Since container orchestration platforms are among the platforms being developed to support Arm64, this phenomenon became a vicious cycle: Releases were gated on passing integration test suites for x86, but releases were not gated on the same test suites passing for Arm64.

The solution CNCF’s developers would discover falls far short of qualifying as radical or revolutionary — in fact, it’s more of a bug fix in practice. It’s so simple to implement that it completely compensates for this disparity not just for CNCF but for any developer of any platform-level component for any architecture.

Breakthrough: Actuated, plus editing one line of code

To take the first step towards platform parity between x86 and Arm64, Ampere enlisted the help of Alex Ellis, the creator of a service called Actuated. It’s a product that runs GitHub Actions jobs in secure, isolated microVMs, instrumented to receive build jobs from GitHub Actions, and offering developers visibility into the performance of their build jobs, and the load on the shared build systems.

Actuated could run all the CNCF’s existing GitHub Actions runners after altering a single line of their configuration files, plus in some cases the pasting of a few code snippets — changes which took less than five minutes to implement. These changes enabled GitHub-hosted projects to point to Actuated’s microVM-driven environment on Ampere Altra processors for their build jobs.

“Falco really needed Arm64 GitHub runners to elevate its support for the architecture and enlarge its user base. [Actuated] was the perfect solution for us because it was easy to leverage and relieved any burden for the maintainers. This way, we as maintainers can focus on what really matters for the project, instead of fighting with maintaining and deploying self-hosted infrastructure. Now we are building, testing, and releasing artifacts for ARM64, leveraging Actuated for many of our projects, and it works flawlessly.”

Federico Di Pierro
Senior Open Source Engineer, Sysdig
Maintainer, Falco project

Having seen the increase in demand for Arm native build environments in recent years, GitHub announced last June the availability in public beta of Arm64-based hosted runners for GitHub Actions, powered by Ampere compute instances on Microsoft Azure, followed in January 2025 by the release into public preview of free hosted runners for public repositories.

For OpenTelemetry, this means the end of network loads as high as 10 times their assigned bandwidth caps, on account of OpenTelemetry builds constantly downloading dependencies from Docker Hub repositories.

“Yeah, we were definitely breaking things. We got lucky, because the Arm runners for GitHub shipped. We have moved to ARM runners, we are happy as can be, and nothing is breaking anymore.”

Antoine Toulmé
Senior Engineering Manager for Blockchain and DLT, Splunk
Maintainer, OpenTelemetry project

Now for the first time, project maintainers can pay as close attention to the safety and security of Arm64 builds as they have for x86 builds, knowing that they’re no longer likely to encounter performance degradations or penalties.

“[Actuated] gave us great confidence in the CI builds on ARM64. If the Arm CI breaks now, there’s no way we will merge that [pull request] until we figure out why… We have full confidence now that [build failures] are not an issue with flaky hardware [as they sometimes were before].”

Phil Estes
Principal Software Engineer, AWS
Maintainer, containerd project

For its part, Oracle is continuing its policy of donating $3 million per year in OCI credits for Arm64 instances powered by Ampere to CNCF projects. This generosity, coupled with the new-found stability of Arm64 platforms catalyzed by Ampere and Equinix, and brought about by Actuated, is enabling prominent cloud infrastructure vendors including Red Hat, SUSE, Canonical, and Mirantis to provide full support for their enterprise customers who choose ARM64 infrastructure.

Parity makes it possible for enterprises to make sensible choices about their computing infrastructure and platforms without incurring penalties just for choosing an alternative architecture.

Large cloud customers are proving that Arm64 can provide organizations with the performance they need, and reduced expenses for workloads–all with industry-leading energy efficiency. But organizations can’t experience those benefits until they can deploy their workloads on all infrastructure options on a level playing field with one another, and measure the results for themselves.

Leveling the Playing Field

In early 2023, few options existed for GitHub-hosted projects who wanted to fully integrate Arm64 into their Continuous Integration processes. Through this initiative, leveraging an innovative software solution from Actuated with Ampere CPUs hosted by Equinix, lowered the bar for CNCF projects to make a start towards partity of support for ARM64 and x86.

Key cloud native projects including etcd, containerd, Open Telemetry, Falco, and others were able to advance their support of ARM64, accelerate their CI runs on native Arm64 infrastructure, and support increasing numbers of their users taking advantage of Arm64 compute in the cloud.

By the end of this pilot project, the number of options for developers has grown considerably. The CNCF now offers its projects the ability to run GitHub Actions jobs on managed Kubernetes clusters on OCI, using Ampere-powered instances and the GitHub project Actions Runner Controller, and with the addition of hosted Arm64 runners to GitHub, it has never been easier for projects to easily support this fast-growing and exciting architecture for cloud native applications.