ARM64 processor architecture has seen a tremendous rise in popularity. Until a few years ago, they were restricted to devices that had strict power requirements. Now the pursuit of performance and the upshift in the capabilities of ARM processors have made them ubiquitous. From edge devices, IoT, small computing devices, personal computing, and now cloud computing infrastructure.
What is the reason behind this rise in popularity?
Cloud computing workloads are expected to be large and complex. Running them in the most cost-efficient manner is paramount. The primary motivation behind adopting ARM is the price-to-performance value that it can provide when running workloads in the cloud. In addition to this, ARM processors are utilized in a large variety of device types. This can allow for applications to be reused across numerous devices and device types. There is a diametrically opposite reason too ― that is, the customization options available for ARM processors also help in creating processors designed for specialized tasks. When combined with well tuned applications, the performance gains can be tremendous.
What implications does this have on application developers?
At the present time, this trend has meant that developers build software independently for each architecture. For containerized workloads this has meant having to support images that can be deployed to different architectures. This may not mean that specialized code changes are required for each of the architecture types. A single container image is capable of containing variants for the different processor architectures. Also images have to be tagged with a tag appended with the architecture they are built for, that can identify them specifically.
What does this mean for the Paketo project?
In order for Paketo Buildpacks to build ARM compliant workloads, a massive shift is required. The buildpacks binaries, along with the internal lifecycle that does the actual build process and exports a container has to be (re)built specifically for ARM. This will allow buildpacks to run inside ARM containers, which will be capable of installing these ARM binaries, leading to support for ARM apps.
The Cloud Native Buildpacks docs has a guide which allows those who need an app image for arm64 devices. Based on this, the Paketo community released support for arm64 and Java workloads at the start of this year. This is an exploratory effort and is directed at early adopters to showcase the possibilities when using Paketo. A shout out here to Dashaun Carter, who has been creating and maintaining ARM64 images for the community which can be used by those interested.
For stable and publicly available support for ARM64 use cases, the Paketo community needs to undertake some work across several parts of its toolchain. The bulk of this work is to manage dependencies. For example, in the Java Buildpacks, many components are not architecture dependent, but several supported JVM vendors have different builds for ARM. This is not consistent and therefore requires investigation and constant tracking until all upstream builds are producing ARM64 compatible builds constantly.
The next significant effort is putting a pipeline in for testing and continuous integration. Existing pipelines will have to be rebuilt on ARM64 based infrastructure. The codebase will have to be constantly tested and validated for the ARM64 platform. While this isn’t necessarily a complex technical challenge, there are unknowns about ownership and costs which are typically onerous for open source projects.
Who Is This For?
The user base anticipating support for ARM64 architecture belongs to one of three distinct groups. The first are those working on ARM-powered devices such as Raspberry Pi and the like. They need their workloads containerized and deployed to to work on IoT devices, on edge compute, and the like. The second bucket is those looking to take advantage of new compute instances such as Graviton on EC2, Dps/Dpds v5 on Azure, and Tau T2A on GCP. Finally, there is a growing user base for the Mac M1/M2 range of processors, who will need support for ARM64 architecture to be able to work with their inner development loop.
How Can You Help?
The Paketo project (and the Cloud Native Buildpacks project) is fully open source. Contributors are welcome to participate in any area they see fit, particularly in building tooling and support for ARM64 architecture. You can start by checking all the open issues and discussions on GitHub. Several RFCs about upcoming work are linked from the community repos, and reading these, along with the roadmaps, will give you a good idea of what work is upcoming in the project. You can also join ongoing conversations on the Paketo Slack.