# Calculadora de preços do AWS Fargate

Grátis, no seu navegador · preços conferidos em 17 de novembro de 2026, us-east-1

## Calculadora de preços do Fargate

### Mostrar a fórmula

```
Per task-hour = vCPU × price per vCPU-hour + GB × price per GB-hour
              (+ vCPU × Windows licence fee) (+ storage GB above 20 × storage price)
Monthly cost  = task-hours × per task-hour
```

Preços conferidos em 17 de novembro de 2026, us-east-1, sob demanda, em dólares americanos. Outras regiões têm preços diferentes. Sempre ligadas significa 730 horas por mês, como na AWS Pricing Calculator. Tudo é calculado no seu navegador.

Screenshot: Cost by resource: total mensal estimado e recursos ordenados por custo

No app CloudConsole

## Faça isso na sua própria conta

Para serviços que já estão rodando, o cartão Monthly cost do app em um serviço do ECS no Fargate multiplica o tamanho da tarefa pelas tarefas em execução agora, pelo preço da sua região, e o Cost by resource o ordena com as suas instâncias, bancos de dados e gateways NAT.

[Como funciona o Cost by resource → (EN)](https://cloudconsole.dev/app-tools/aws-cost-per-resource)

[Baixar na App Store](https://apps.apple.com/app/cloudconsole-for-aws/id6835419710) · [Disponível no Google Play](https://play.google.com/store/apps/details?id=com.cloudconsole.app)

**Resposta curta**

O Fargate cobra as vCPUs e a memória que uma tarefa solicita, por segundo, com mínimo de 1 minuto: $0.04048 por vCPU-hora e $0.004445 por GB-hora para Linux/x86 na us-east-1, cerca de 20% menos em Arm. Uma tarefa com 1 vCPU e 2 GB custa $0.04937 por hora, ou cerca de $36.04 por mês se ficar sempre ligada. O Windows acrescenta uma taxa de licença e tem mínimo de 5 minutos; armazenamento temporário acima de 20 GB é cobrado à parte.

## Como funcionam os preços do AWS Fargate

O Fargate cobra o que cada tarefa do ECS (ou pod do EKS) *solicita*, não o que ela usa: as vCPUs e a memória da tarefa, o sistema operacional e a arquitetura de CPU, e qualquer armazenamento temporário acima dos 20 GB que cada tarefa recebe. A cobrança vai do momento em que a tarefa começa a baixar a imagem do contêiner até ela parar, arredondada para cima ao segundo.

```
cost per task-hour = vCPU × price per vCPU-hour
                   + memory (GB) × price per GB-hour
                   + vCPU × Windows licence fee        (Windows only)
                   + (ephemeral storage GB − 20) × $0.000111
monthly cost       = cost per task-hour × task-hours a month
```

Uma tarefa que roda menos que o mínimo é cobrada pelo mínimo: **1 minuto no Linux, 5 minutos no Windows**. Isso importa em jobs agendados curtos. Um job Linux que roda 20 segundos a cada minuto é cobrado como se rodasse o tempo todo, e um job Windows de 2 minutos custa o mesmo que um de 5.

Como a conta acompanha o tamanho da tarefa, a configuração mais barata é o menor tamanho em que seus contêineres cabem. As métricas CPUUtilization e MemoryUtilization do CloudWatch mostram quanto de cada tarefa é usado; um serviço parado em 10% de CPU com 4 vCPUs paga por mais de 3 vCPUs que não usa.

## Preços do Fargate na us-east-1

Preços conferidos em 17 de novembro de 2026 para o Leste dos EUA (Norte da Virgínia), sob demanda, na AWS Price List e na página de preços do Fargate. A AWS conta um GB como 1024³ bytes.

| Cobrança | Linux/x86 | Linux/Arm | Windows/x86 |
|---|---|---|---|
| Por vCPU-hora | $0.04048 | $0.03238 | $0.046552 |
| Por GB-hora de memória | $0.004445 | $0.00356 | $0.00511175 |
| Licença do Windows, por vCPU-hora | — | — | $0.046 |
| Armazenamento temporário acima de 20 GB, por GB-hora | $0.000111 | $0.000111 | $0.000111 |
| Cobrança mínima por tarefa | 1 minuto | 1 minuto | 5 minutos |

### Custo mensal de tamanhos de tarefa comuns

Uma tarefa rodando o mês inteiro (730 horas), com os 20 GB de armazenamento incluídos:

| Tamanho da tarefa | Linux/x86 | Linux/Arm | Windows/x86 |
|---|---|---|---|
| 0.25 vCPU, 0.5 GB | $9.01 | $7.21 | — |
| 0.25 vCPU, 1 GB | $10.63 | $8.51 | — |
| 0.5 vCPU, 1 GB | $18.02 | $14.42 | — |
| 1 vCPU, 2 GB | $36.04 | $28.84 | $75.03 |
| 1 vCPU, 4 GB | $42.53 | $34.03 | $82.49 |
| 2 vCPU, 4 GB | $72.08 | $57.67 | $150.05 |
| 2 vCPU, 8 GB | $85.06 | $68.07 | $164.98 |
| 4 vCPU, 8 GB | $144.16 | $115.34 | $300.10 |
| 4 vCPU, 16 GB | $170.12 | $136.13 | $329.96 |
| 8 vCPU, 16 GB | $288.32 | $230.68 | — |
| 16 vCPU, 32 GB | $576.64 | $461.36 | — |

## Combinações válidas de CPU e memória no Fargate

O Fargate só roda os tamanhos de tarefa abaixo. A calculadora se ajusta a eles: escolha um valor de vCPU e a lista de memória mostra o que esse tamanho permite. Nas definições de tarefa, a CPU também é escrita em unidades de CPU (1 vCPU = 1024).

| vCPU (unidades de CPU) | Memória | Sistemas operacionais |
|---|---|---|
| 0.25 vCPU (256) | 0.5, 1 ou 2 GB | Linux |
| 0.5 vCPU (512) | 1, 2, 3 ou 4 GB | Linux |
| 1 vCPU (1024) | 2–8 GB em passos de 1 GB | Linux, Windows |
| 2 vCPU (2048) | 4–16 GB em passos de 1 GB | Linux, Windows |
| 4 vCPU (4096) | 8–30 GB em passos de 1 GB | Linux, Windows |
| 8 vCPU (8192) | 16–60 GB em passos de 4 GB | Linux |
| 16 vCPU (16384) | 32–120 GB em passos de 8 GB | Linux |
| 32 vCPU (32768) | 60, 120 ou 244 GB | Linux |

8, 16 e 32 vCPUs exigem a versão de plataforma Linux 1.4.0 ou posterior. Tarefas Windows exigem pelo menos 1 vCPU e só rodam em x86. O armazenamento temporário pode ir dos 20 GB padrão até 200 GB por tarefa.

## ECS ou EKS, Arm, Spot e Savings Plans

- **EKS no Fargate.** A página de preços do Fargate da AWS aplica aos pods do EKS os mesmos preços de vCPU e memória das tarefas do ECS. Cada pod é arredondado para o próximo tamanho da tabela acima depois de somar 256 MB para os componentes do Kubernetes, então um pod que solicita 1 vCPU e 8 GB roda, e é cobrado, como 2 vCPUs e 9 GB. Windows e Arm só estão disponíveis no ECS.
- **Arm (Graviton).** Cerca de 20% mais barato que x86, tanto em vCPU quanto em memória. As imagens precisam de um build arm64 (ou multiarquitetura).
- **Fargate Spot.** Capacidade interrompível para tarefas do ECS no Linux com até 70% de desconto. O preço varia com a oferta e a demanda e não está no arquivo da AWS Price List, por isso a calculadora não o inclui.
- **Compute Savings Plans.** Até 50% de desconto no Fargate em troca de um compromisso de gasto de um ou três anos. Não modelado aqui.

## O que mais uma carga de trabalho do Fargate custa

A calculadora cobre as cobranças do próprio Fargate. A conta real de um serviço de contêineres costuma ter mais linhas:

- **Load balancers.** Um Application Load Balancer na frente de um serviço é cobrado por hora e por LCU.
- **Gateways NAT e transferência de dados.** Tarefas em sub-redes privadas baixam imagens e chamam a internet por um gateway NAT, cobrado por hora e por GB, a menos que se usem endpoints da VPC. O tráfego de saída para a internet é cobrado à parte.
- **Endereços IPv4 públicos.** Tarefas com endereço IP público pagam a cobrança de IPv4 público da VPC.
- **CloudWatch Logs.** Tudo o que os contêineres escrevem no driver awslogs é ingerido e armazenado.
- **Amazon ECR.** Armazenamento de imagens e transferência de dados para pulls de fora da região.

Para ver quanto você gasta de verdade, agrupe o Cost Explorer por serviço e depois por tipo de uso; o [guia de detalhamento dos custos da AWS (EN)](https://cloudconsole.dev/how-to/see-aws-cost-breakdown) mostra como, e os [guias da AWS (EN)](https://cloudconsole.dev/guides/) cobrem o resto da conta.

**Fargate ou Lambda?** Não há um número equivalente aqui: o Lambda cobra por solicitação e por GB-segundo de cada invocação, com a CPU atrelada à memória, então o custo do mesmo trabalho depende do tráfego, não de um tamanho de tarefa. Use a [calculadora de custos do Lambda](https://cloudconsole.dev/pt-br/tools/lambda-cost-calculator) com a sua taxa de solicitações e a sua duração para comparar.

## Perguntas frequentes

### Como o AWS Fargate é cobrado?

O Fargate cobra as vCPUs e a memória que uma tarefa solicita, por segundo, do momento em que ela começa a baixar a imagem do contêiner até a tarefa parar, com mínimo de 1 minuto no Linux. Na us-east-1, Linux/x86 custa $0.04048 por vCPU-hora e $0.004445 por GB-hora. O Windows acrescenta uma taxa de licença do sistema operacional por vCPU-hora e tem mínimo de 5 minutos.

### Quanto custa uma tarefa do Fargate por mês?

Uma tarefa com 1 vCPU e 2 GB rodando o mês inteiro (730 horas) custa cerca de $36.04 em Linux/x86, $28.84 em Linux/Arm e $75.03 em Windows na us-east-1. A menor tarefa, 0.25 vCPU e 0.5 GB, custa cerca de $9.01 por mês em Linux/x86.

### O Fargate é mais barato em Arm (Graviton)?

Sim, cerca de 20%: Linux/Arm custa $0.03238 por vCPU-hora e $0.00356 por GB-hora na us-east-1, contra $0.04048 e $0.004445 em Linux/x86. Suas imagens de contêiner precisam de um build arm64, e tarefas Windows só podem usar x86.

### O EKS no Fargate custa o mesmo que o ECS no Fargate?

A página de preços do Fargate da AWS usa os mesmos preços de vCPU e memória para pods do EKS e tarefas do ECS, e o exemplo de EKS dela usa as tarifas de Linux/x86. No EKS, cada pod é arredondado para o próximo tamanho do Fargate, com 256 MB somados para os componentes do Kubernetes, e Windows e Arm só estão disponíveis no ECS.

### E o Fargate Spot?

O Fargate Spot roda tarefas interrompíveis do ECS no Linux com até 70% de desconto, mas o preço muda com o tempo e não está no arquivo da AWS Price List que esta calculadora usa, então ele não é modelado. Confira o preço atual do Spot na página de preços do AWS Fargate.

### O que a calculadora de preços do Fargate deixa de fora?

Transferência de dados, load balancers, gateways NAT, endereços IPv4 públicos, CloudWatch Logs, armazenamento de imagens no Amazon ECR, Fargate Spot e Compute Savings Plans. Ela calcula só as cobranças do próprio Fargate: vCPU, memória, licença do Windows e armazenamento temporário.

**Veja quanto seus contêineres custam**

O CloudConsole mostra seus gastos por serviço, com tipos de uso e regiões, ao lado dos seus clusters, serviços e tarefas do ECS, então um serviço que de repente custa mais se destaca. No iPhone e no Android.

[Sobre o app →](https://cloudconsole.dev/pt-br/aws-console-app)

## Fontes

- [AWS Fargate pricing](https://aws.amazon.com/fargate/pricing/)
- [AWS Price List: Amazon ECS (Fargate), us-east-1](https://pricing.us-east-1.amazonaws.com/offers/v1.0/aws/AmazonECS/current/us-east-1/index.json)
- [Amazon ECS task definition differences for Fargate (task CPU and memory)](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/fargate-tasks-services.html)
- [Fargate task ephemeral storage for Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/fargate-task-storage.html)
- [Understand Fargate Pod configuration details (EKS)](https://docs.aws.amazon.com/eks/latest/userguide/fargate-pod-configuration.html)
- [Amazon ECS clusters for Fargate (Fargate Spot)](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/fargate-capacity-providers.html)

## Veja também

- [Calculadora de custos do AWS Lambda](https://cloudconsole.dev/pt-br/tools/lambda-cost-calculator) – Ferramentas grátis
- [Como escalar um serviço do ECS (EN)](https://cloudconsole.dev/how-to/scale-ecs-service) – Guias práticos
- [OutOfMemoryError: Container killed due to memory usage (EN)](https://cloudconsole.dev/errors/ecs-outofmemoryerror) – Como corrigir erros da AWS
- [Alarme do CloudWatch para CPUUtilization de um serviço do Amazon ECS (EN)](https://cloudconsole.dev/alarms/ecs-cpuutilization) – Alarmes do CloudWatch
- [Por que a minha conta da AWS está tão alta? (EN)](https://cloudconsole.dev/how-to/why-is-my-aws-bill-so-high) – Guias práticos
- [Como ver o detalhamento dos custos da AWS (EN)](https://cloudconsole.dev/how-to/see-aws-cost-breakdown) – Guias práticos

---

Source: https://cloudconsole.dev/pt-br/tools/fargate-pricing-calculator

CloudConsole is an independent iPhone and Android app for Amazon Web Services by Cloudconcur Ltd. It is not affiliated with Amazon Web Services.
