# 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:       | 31 Jul 2026       |

| Author:             |
|---------------------|
| Jason Andrews, Arm  |
| [GitHub](https://github.com/jasonrandrews) |
| [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](https://learn.arm.com/tag/aws)                 |
| [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?
Upon completion of this Learning Path, you will be able to:
- 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 will need the following:
- 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
<details>
<summary>What happens when I run the `copilot init` command shown in the steps?</summary>
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.
</details>

<details>
<summary>When should I change Copilot to use the Arm architecture for Graviton?</summary>
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.
</details>

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

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

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