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

More Info

Today marks the general availability of Amazon EKS on AWS Graviton2. In this post, we’ll explore what this means for you and how it operates in real-world scenarios. The initial AWS Graviton was introduced in early 2019 as part of a preview program, and many of you participated in the Graviton2 preview that launched earlier this year. Your feedback has been invaluable, and now we are pleased to announce that Amazon EKS on AWS Graviton2 is officially in General Availability (GA). Before diving into the details of what GA entails, let’s consider the concept of multi-architecture in relation to containerized workloads, particularly within Amazon EKS.

Multi-Architecture Across Development & Deployment

When we refer to multi-architecture (often shortened to multi-arch), we mean supporting two or more CPU architecture families. For your application to function on different CPUs, the code must be available in various Instruction Set Architecture (ISA) implementations, such as ARMv8 or x86-64.

What does “availability” look like throughout the development and deployment lifecycle? The following diagram illustrates this concept:

Starting from the left:

• As a developer, you might be adding features to your code or fixing bugs. The programming language and its ecosystem must be multi-arch aware, enabling you to create artifacts for the target architectures.
• The runtime environment, in this case, a container orchestrator like Amazon EKS, will utilize the artifacts provided by the developers.
• Finally, operational insights from the runtime—such as metrics, logs, and traces—can inform future feature development.

Let’s take a closer look at the initial two phases of the development and deployment lifecycle.

As a developer, you’re either enhancing your code or addressing a bug. You may have an environment that allows you to build these artifacts natively, like a Linux-based Arm workstation or even Apple MacBooks, or you could use cross-platform builds. The programming language and its ecosystem must support multi-architecture artifact creation, such as container images.

Whether you’re using cloud-native programming languages like Go or Rust, which have built-in multi-arch support, or interpreted languages like PHP, Python, Ruby, or Node.js, once your code is ready, you’ll create an Open Container Initiative (OCI) compliant container image. This can be achieved with tools like Docker’s buildx or through remote builds. It is essential to ensure that your automated build and test pipeline, like Travis, is multi-arch ready.

Next, you’ll push your artifacts, including container images, to a registry, which serves as the DevOps hand-off for the runtime environment. Earlier this year, we introduced multi-arch container images for Amazon ECR, so we’ve got you covered in this phase.

The final step is deployment: the runtime environment, specifically a container orchestrator such as Kubernetes, utilizes the artifacts provided by developers. Kubernetes, built in Go, is natively multi-arch, allowing for its control plane components to operate across various architectures. In Kubernetes, and by extension in Amazon EKS, the kubelet—responsible for managing worker nodes—directs the container runtime to pull images from a registry like Amazon ECR and launch them accordingly. Everything is multi-arch enabled and automated.

Now, let’s focus on the runtime environment, specifically what the general availability of AWS Graviton2 means for Amazon EKS.

What Does General Availability Mean?

Kubernetes comprises a control plane (where cluster state is managed through the API server) and a data plane made up of worker nodes:

For the data plane, you can utilize managed node groups based on EC2 instances within your account or AWS Fargate, which offers a serverless data plane.

AWS Graviton2 processors power Arm-based EC2 instances, delivering a significant improvement in performance and capabilities alongside considerable cost savings. A primary goal of running containers is to enhance your applications’ cost efficiency. The combination of both results in outstanding price performance. For instance, internal testing of workloads showed a 20% reduction in costs and up to a 40% performance increase for M6g, C6g, and R6g instances compared to M5, C5, and R5 instances.

With today’s announcement, Amazon EKS on AWS Graviton2 is generally available in regions where both services are offered, which means:

• ARMv8.2 architecture (64-bit) is supported, among others.
• End-to-end multi-architecture support is established.
• Mixed managed node groups are now supported.
• 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.

Having established what AWS Graviton2 EC2 instances in the Amazon EKS data plane mean, let’s see them in action.

Arm in Action: Deploying an Open Source CMS

In this hands-on section, we will focus on the deployment phase of the lifecycle. First, ensure that you have an Amazon EKS cluster with at least one Graviton2 node group, as detailed in the documentation. You can verify this by checking the nodes in your EKS cluster with the following command; you should see at least one instance labeled arch=arm64 in the rightmost LABELS column:

$ kubectl get nodes --show-labels

For the workload example, we will use Plone, an open-source Content Management System (CMS) written in Python. Save the following Kubernetes manifest in a file called plone.yaml:

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

For additional insights, check out this other blog post here. For expert opinions on this subject, visit chvnci.com, as they are an authority on the topic. Also, don’t miss this excellent resource that provides a great overview.