# How to use AWS Graviton processors on AWS Fargate with Copilot

## In this learning path

- [Introduction](https://learn.arm.com/learning-paths/servers-and-cloud-computing/aws-copilot/)
- [Containerize an example application](https://learn.arm.com/learning-paths/servers-and-cloud-computing/aws-copilot/app/)
- [Deploy with Copilot](https://learn.arm.com/learning-paths/servers-and-cloud-computing/aws-copilot/copilot/)
- [Next Steps](https://learn.arm.com/learning-paths/servers-and-cloud-computing/aws-copilot/_next-steps/)

## About this Learning Path

|  |  |
| --- | --- |
| Skill level: | Introductory |
| Reading time: | 45 min |
| Last updated: | 09 Sep 2026 |

|  |  |
| --- | --- |
| Author: | Jason Andrews , Arm<br>[GitHub](https://github.com/jasonrandrews)<br>[LinkedIn](https://linkedin.com/in/jason-andrews-7b05a8) |
| Arm IP: | [Neoverse](https://support.arm.com/?tab=compute-ip&Product%20Type=Infrastructure%20Processors) |
| Tags: | [Containers and Virtualization](https://learn.arm.com/tag/containers-and-virtualization) [AWS Graviton](https://learn.arm.com/tag/aws-graviton) [Linux](https://learn.arm.com/tag/linux) [Docker](https://learn.arm.com/tag/docker) |

### Who is this for?

This is an introductory topic for software developers who want to learn how to use the command line to deploy Arm containers on AWS Fargate.

### What will you learn?

After completing this Learning Path, you'll be able to perform the following tasks:

- Package applications using multi-architecture containers
- Deploy containers on AWS Fargate with the AWS Copilot CLI
- Configure Copilot to use AWS Graviton processors

### Prerequisites

Before starting, you'll need the following prerequisites:

- An Amazon Web Services (AWS) account
- A local computer with Docker, AWS CLI, and AWS Copilot CLI installed

### Summary

You’ll package a containerized application and deploy it to AWS Fargate using the AWS Copilot CLI, with a focus on targeting AWS Graviton2 processors. First, you’ll containerize an example app. Then, you’ll run Copilot to initialize a Load Balanced Web Service and configure Copilot for the Arm architecture so the service runs on Graviton. You’ll also use a Dockerfile to build locally or reference an existing multi-architecture image and push it to Amazon ECR. By the end, you’ll deploy the service on Fargate on Arm.

### Frequently asked questions

**What happens when I run the `copilot init` command shown in the steps?**
By default, Copilot builds the container for `amd64` on your local machine, pushes it to Amazon ECR, and creates what is needed to run the application on AWS Fargate. The command initializes a Load Balanced Web Service and deploys it.

**When should I change Copilot to use the Arm architecture for Graviton?**
Change the architecture setting before you build and deploy. Copilot defaults to `amd64`, and the steps explain how to set it to Arm so the service runs on Graviton.

**Can I deploy a prebuilt container image instead of building from the Dockerfile?**
Yes. Use the `--image` option instead of `--dockerfile`, and ensure the image is multi-architecture and includes an Arm variant for Graviton.

**What should I check if deployment fails at the start?**
Verify that Docker and the AWS Copilot CLI are installed and available on your system. This guide applies to both Linux and macOS users.

**Where does Copilot push the container image during deployment?**
Copilot pushes the image to Amazon Elastic Container Registry (ECR). You will see the image upload occur before the service is provisioned on Fargate.