Amazon EKS on AWS Graviton2 Now Generally Available: Key Considerations for Multi-Architecture Applications

More Info

Today marks the general availability of Amazon EKS on AWS Graviton2. In this post, we aim to provide you with insights on what this development means for your applications and how it functions in practice. We initially introduced the first-generation AWS Graviton in early 2019, and many of you participated in the Graviton2 preview program launched earlier this year. We appreciate your involvement and feedback, which has been instrumental in reaching this GA milestone.

Before diving into the details of what General Availability entails, let’s explore the concept of multi-architecture as it relates to containerized workloads, particularly within Amazon EKS.

Understanding Multi-Architecture in Development and Deployment

Multi-architecture (or multi-arch for short) refers to support for two or more CPU architecture families. For your application to operate on different CPUs, your code must be available in various Instruction Set Architecture (ISA) implementations, such as ARMv8 or x86-64.

How does this availability manifest throughout the development and deployment lifecycle? The following outline illustrates the process:

On the left side, we start with developers who are adding features or fixing bugs in their code. The programming language and its ecosystem must be multi-arch aware, facilitating the creation of artifacts for the target architectures.

The runtime environment, specifically a container orchestrator like Amazon EKS, utilizes the artifacts generated by developers in the prior steps.

Finally, operational insights from the runtime—such as metrics, logs, and traces—can help in troubleshooting and analyzing usage patterns, which can guide future feature development.

Let’s take a closer look at the initial phases of the development and deployment lifecycle. As a developer, you’re either enhancing your code or addressing bugs. You may have access to a native environment for building artifacts—like a Linux-based Arm workstation, or even Apple MacBooks—or you could employ cross-platform builds. The programming language you choose must support multi-architecture capabilities, enabling you to create artifacts such as container images.

Whether you’re utilizing cloud-native languages like Go or Rust—both of which support multi-arch—or interpreted languages such as PHP, Python, Ruby, or Node.js, once your code is ready, you’ll build an Open Container Initiative (OCI) compliant container image. This can be accomplished using Docker’s buildx or through remote builds. It is crucial to ensure that your automated build and test pipeline, for instance, support in Travis, is multi-arch ready.

Next, you will push your artifacts, including container images, to a registry, which acts as the hand-off for the runtime environment. Earlier this year, we rolled out multi-arch container images for Amazon ECR, so you’re covered in this aspect as well.

The final step is deployment: the runtime environment, exemplified by Kubernetes, uses the artifacts developed in the previous stages. Kubernetes, built in Go, is inherently multi-arch and provides its control plane components across multiple architectures. In Kubernetes, and by extension Amazon EKS, the kubelet—responsible for managing worker nodes—directs the container runtime via a standardized interface to pull container images from a registry like Amazon ECR and launch them. This entire process is multi-arch enabled and automated.

Moving forward, we will focus on the runtime environment, particularly what the general availability of AWS Graviton2 means for Amazon EKS.

What General Availability Entails

Kubernetes distinguishes between a control plane (where the cluster state is managed via the Kubernetes API server) and a data plane comprising worker nodes.

For the data plane, you can utilize managed node groups based on EC2 instances in your account or AWS Fargate, a serverless data plane option. AWS Graviton2 processors power Arm-based EC2 instances, delivering significant performance improvements and cost savings. A core objective of running containers is to optimize cost efficiency for your applications. By leveraging both, you can achieve exceptional price-performance. For instance, internal testing has demonstrated that workloads on M6g, C6g, and R6g instances yield 20% lower costs and up to 40% better performance compared to M5, C5, and R5 instances.

With today’s announcement, Amazon EKS on AWS Graviton2 is generally available, with both services now accessible regionally, meaning:

• Support for ARMv8.2 architecture (64-bit) is included.
• End-to-end multi-architecture support is provided (details below).
• Mixed managed node groups are now permitted.
• The EKS API and tools like eksctl handle architecture-specific configurations, such as launching Arm-based control plane components like CoreDNS or kube-proxy pods.

Now that we have a general understanding of what AWS Graviton2 EC2 instances mean in the Amazon EKS data plane, let’s see them in action.

Deploying an Open Source CMS on Arm

In this hands-on section, we will concentrate on the deployment aspect of the lifecycle. To begin, you will need an Amazon EKS cluster that includes at least one Graviton2 node group, provisioned according to the documentation. To confirm this, check the nodes in your EKS cluster with the command below, ensuring at least one node shows arch=arm64 in the LABELS column:

$ kubectl get nodes --show-labels

For our workload example, we’ll use Plone, an open-source Content Management System (CMS) written in Python. Store the following Kubernetes manifest in a file named plone.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: plone
spec:
  replicas: 1
  selector:
    matchLabels:
      app: plone

For further insights, you can check out this blog post that dives deeper into the topic. Additionally, Chvnci provides great authority on this subject. If you are looking for excellent resources, Amazon’s Learning and Development team offers valuable information.