Planning your transition

This section will help you prepare your transition project and highlights things to consider. In most cases, your application or service consists of multiple components and their dependencies. Being aware of what these dependencies are will help you identify constraints and opportunities for quick wins. If you are primarily interested in the technical activities associated with transitioning to AWS Graviton2, see Transitioning Your Service or Application.

The following figure illustrates the typical components of an application stack. Your application may differ or you may not have full control over some components depending on your software distribution model. For example, you may have full control over all components of the stack if you are distribution software as a SaaS-based product. However, you may have less control over some aspects such as operating systems and software agents if you distribute your software directly to customers (and customers are responsible for deploying and configuring your software).

Typical components of your application stack

The following sections provide additional details around each application component and the specific issues you may encounter when transitioning to AWS Graviton2.

Operating system (OS)

Most popular Linux distributions offer out-of-the-box support for AWS Graviton2 include Amazon Linux 2, Red Hat Enterprise Linux, Ubuntu, and SUSE Linux Enterprise Server. Use the latest version of these operating systems to benefit from performance enhancements. Consider which operating systems and versions you or your customers are running in their production environment. Verify that the operating system offers 64-bit ARM support using the AWS console and CLI. Filter by owner, region, platform and architecture to check whether a combination is supported today. At the time of publication, Windows is not available for AWS Graviton2. For an up-to-date-list of supported operating systems, see the AWS Graviton Getting Started Guide.

Language and runtimes

Verify which languages and runtimes make up your codebase and whether your code dependencies include native language extensions (such as Java JNI's) or artifacts (such as x86 shared objects where equivalent ARM versions should be created). Interpreted and bytecode-compiled languages such as Python, Java, Node.js, and .NET Core on Linux mostly run without modifications. This means you should be able to run these applications on AWS Graviton2 by simply installing the corresponding runtime.

For example, the Java Virtual Machine (JVM) runtime added 64-bit ARM support in version 8 and above. (Java has been available in multiple forms for ARM for a long time. OpenJDK and Oracle JDK added support for 64-bit ARM in JDK8 and above. Servers and cloud workloads typically adopt LTS versions of Java which include JDK8, 11, and 15 which all have 64-bit ARM support and later versions provide more 64-bit ARM specific optimizations for best performance.) Check the Getting Started Guide to identify exceptions (such as platform-specific artifacts) that apply to your language and how to work around them. Applications written in compiled languages such as C/C++ and Go will need to be recompiled these languages provide mature and optimized support for both 64-bit ARM and x86. For example, this includes the GCC and LLVM for C/C++ and the golang/go compiler for Go. (Some languages provide a built-in cross compiler (like Go), some do support multiple architecture in the sense that you can compile a compiler for a target but not a compiler for multiple targets at the same time.)

Container services

If your application is deployed using container services, check for multi-architecture support for containers and infrastructure dependencies. Containers are architecture specific and you will need to build new container images to support 64-bit ARM. Multi-architecture support helps simplify the consumption of container images across x86 and ARM. For example, Docker supports multi-architecture images transparently via the Buildx tool and the majority of Docker official images are now multi-architecture enabled.

You can deploy multi-architecture container images in Amazon Elastic Container Service (Amazon ECS) and Amazon Elastic Kubernetes Service (Amazon EKS). This enables you to optimize your clusters by offering support for both x86 and Graviton2 hosts. Other considerations include specific infrastructure dependencies such as proxies or service mesh components. For more information about the status of open-source projects and their 64-bit ARM and Graviton2 support, see the Getting Started Guide.

Software agents

If you distribute your application as SaaS, work with your operations team to identify your dependencies on software agents. Most security, monitoring, and logging use cases require operations teams to install software agents on virtual machines and container hosts. Lack of support for 64-bit ARM can be a blocker if your security and application performance monitoring processes rely on these agents. Most first-party software agents on the AWS platform provide 64-bit ARM support. This includes the Amazon CloudWatch, Amazon Inspector, and AWS Systems Manager agents. A growing ecosystem of third-party vendors offer a 64-bit ARM version of their software agents. Examples include security solutions (CrowdStrike, Qualys, Rapid7, Snyk, and Tenable) and observability and monitoring solutions (Splunk, New Relic, Datadog, and Honeycomb).

Build systems

Consider the state of multi-architecture support for continuous integration/continuous delivery (CI/CD) pipelines and build systems. Maintaining multiple versions of compilers, libraries, and support binaries for different architectures has traditionally been a cumbersome, time-consuming, and an error-prone process. Modern CI/CD tools offer facilities to build and test code submitted to code repositories with minimal manual intervention.

First party CI/CD tools on the AWS platform such as AWS CodeCommit, AWS CodeBuild, AWS CodePipeline, and AWS CodeDeploy provide out-of-the box support for 64-bit ARM. There is a growing ecosystem of third-party CI/CD vendors that are adding 64-bit ARM support to their software offerings. These include Jenkins, GitLab, CircleCI, and TravisCI. For example, GitLab now offers first class support for AWS Graviton and the ARM architecture in its CI/CD tooling.

Edge cases

You may encounter edge cases in older, monolithic applications. While these are rare, they may impact on your ability to transition to AWS Graviton2. Examples for edge cases include proprietary legacy applications, hand-tuned code written for x86 in low-level languages, or workloads that depend on specific features of the x86 architecture. If this is the case, consider whether AMD-backed instance types such as the M5a, C5a, and R5a are a better choice for your application. While AMD-backed instance types do not provide the same price performance advantages compared to AWS Graviton2, they offer a seamless transition and potential cost savings.