# Melhor instância EC2: benchmark da família T

> Teste de CPU com sysbench em T2, T3, T3a e T4g micro, cruzado com o preço por hora. Números de 2021: veja quanto cada geração entrega por dólar.

- Autor: Henrylle Maia, consultor AWS
- Publicado em: 2026-10-15
- Assuntos: Custos
- URL: https://pages.formacaoaws.com.br/blog/melhor-instancia-ec2-familia-t-benchmark/
- Aula de origem: "Qual a melhor instância EC2: Fazendo um comparativo prático de performance das instância do tipo T" (https://www.youtube.com/watch?v=jhuk7HKglMs)

Preço por hora menor não diz se vale trocar de instância EC2: falta saber quanto trabalho ela entrega. Aqui você mede a CPU com o sysbench e cruza o resultado com o preço, no teste que fiz com T2, T3, T3a e T4g, todas micro.

Gravei este teste em outubro de 2021. Todos os números abaixo, de resultado e de preço, são daquela data e da região US East (N. Virginia). Use o método, e refaça a conta com os preços de hoje.

## O que este teste mede e o que ele não mede

A família T são as instâncias de propósito geral, as que a gente usa para começar na AWS. A pergunta é simples: qual delas entrega mais poder de CPU, e quanto isso custa.

O teste mede **só CPU, com uma thread**. Não medi memória: todas as micro têm 1 GiB. Deixei a T1 de fora, porque é uma instância muito antiga e com memória diferente.

A T4g usa arquitetura ARM, o que muda o que vem depois do resultado, como explico no fim.

A lógica é em três movimentos: lançar uma instância de cada tipo, rodar o mesmo teste em todas e planilhar o resultado ao lado do preço.

**Fluxo:** Instâncias micro (T2, T3, T3a e T4g) → sysbench (CPU, uma thread) → Eventos por segundo (resultado de cada uma) → Planilha (preço por hora cruzado com o resultado)

## Passo 1: levantar o preço de cada instância

Para ver custo e especificação lado a lado, uso o EC2Instances.info. Na gravação, o endereço antigo já redirecionava para o instances.vantage.sh. Ele lista as instâncias EC2 e RDS, com poder computacional e custo para Linux e Windows, sob demanda, Spot e reservado.

Filtre por `micro` e olhe a coluna **Linux On Demand cost**, na região US East (N. Virginia). A T2 tem 1 vCPU; a T3, a T3a e a T4g têm 2. Anote o preço por hora de cada uma:

![No EC2Instances.info, o preço Linux sob demanda das quatro micro: de US$ 0,0116 por hora na T2 a US$ 0,0084 na T4g](https://pages.formacaoaws.com.br/blog/assets/posts/melhor-instancia-ec2-familia-t-benchmark/precos-vantage.webp)

| Instância | Linux sob demanda, por hora (2021) |
|---|---|
| t2.micro | US$ 0,0116 |
| t3.micro | US$ 0,0104 |
| t3a.micro | US$ 0,0094 |
| t4g.micro | US$ 0,0084 |

O preço cai a cada geração. Mas preço menor não responde se vale a pena trocar. A AWS diz que sim; o teste serve para ver o resultado.

> **Importante:** estes preços são os da página em outubro de 2021. Confira os valores atuais na [página de preços do Amazon EC2](https://aws.amazon.com/ec2/pricing/on-demand/) antes de comparar.

## Passo 2: lançar uma micro de cada tipo

Lance quatro instâncias, uma de cada tipo, com **Amazon Linux**. Usei o mesmo nome para as quatro (`teste-performance`) e o mesmo security group, com acesso por SSH, para conectar nelas depois.

A única diferença está na T4g. Como ela é ARM, no assistente de lançamento você precisa escolher a imagem de arquitetura ARM para conseguir selecionar o tipo t4g.micro.

Com as quatro em execução, abra um terminal em cada uma por SSH. Fiz o teste de duas em duas, com os dois terminais lado a lado.

## Passo 3: instalar o sysbench e rodar o teste

O sysbench serve para benchmark de CPU, de memória e até de banco. Aqui uso só o de CPU, com uma thread. A instalação é a do README do projeto, na opção RHEL/CentOS, que serve para o Amazon Linux que usei:

```bash
curl -s https://packagecloud.io/install/repositories/akopytov/sysbench/script.rpm.sh | sudo bash
sudo yum -y install sysbench
```

O primeiro comando configura o repositório do sysbench. O segundo instala o pacote. Rode os dois em cada instância. Depois, o teste:

```bash
sysbench cpu --threads=1 run
```

Ele roda por cerca de 10 segundos e imprime, em `CPU speed`, os **eventos por segundo**: a quantidade de operações que a CPU conseguiu executar. Quanto maior, melhor. Rode o mesmo comando nas quatro e anote o número de cada uma.

![O bloco CPU speed dos quatro terminais, com o mesmo comando: 770,19 eventos por segundo na t2.micro, 1.025,60 na t3.micro, 1.228,96 na t3a.micro e 2.901,11 na t4g.micro](https://pages.formacaoaws.com.br/blog/assets/posts/melhor-instancia-ec2-familia-t-benchmark/sysbench-resultados.webp)

Já dá para ver só no resultado cru: a T3 faz mais que a T2, mesmo custando menos, e a T4g está muito acima das três.

## Passo 4: cruzar o resultado com o preço

Só o resultado não basta: é preciso cruzar com o custo. Então coloquei numa planilha o custo por hora e o resultado de cada uma, e calculei quanto custa cada unidade de trabalho:

```text
comparação = custo por hora ÷ eventos por segundo × 10.000
```

Multipliquei por 10.000 para ler o número como o custo de 10 mil operações do teste. O que interessa é a relação entre as instâncias: peguei a T2 como 100% e dividi as outras por ela.

![A planilha do teste em dois blocos: custo por hora e resultado em cima; embaixo, a comparação, o percentual sobre a T2 e quantas vezes cada uma rende o que a T2 rende, até 5,2 na t4g.micro](https://pages.formacaoaws.com.br/blog/assets/posts/melhor-instancia-ec2-familia-t-benchmark/planilha-custo-resultado.webp)

| Instância | Eventos por segundo | Custo de cada unidade de trabalho, com a T2 em 100% | Trabalho pelo mesmo custo, em vezes a T2 |
|---|---|---|---|
| t2.micro | 770,19 | 100% | 1 |
| t3.micro | 1.025,60 | 67,33% | 1,49 |
| t3a.micro | 1.228,96 | 50,78% | 1,97 |
| t4g.micro | 2.901,11 | 19,22% | 5,20 |

A última coluna é o inverso da anterior (1 ÷ 0,6733 = 1,49, e assim por diante). Pelo mesmo gasto, a T3 entrega cerca de 50% mais trabalho que a T2, a T3a quase o dobro, e a T4g 5,2 vezes.

## O que o resultado diz e o que ainda falta decidir

A T3 é uma troca simples. Não muda a arquitetura: é só trocar o tipo da instância. Pela conta acima, é um ganho de CPU por dólar.

A T4g é a que assusta no número, olhando só a CPU. Mas ela é ARM, e colocar a sua aplicação para rodar nela não é trivial: pode exigir mudanças. O teste mede só o ganho de CPU; o que muda na aplicação para rodar em ARM ficou de fora.

O que este teste não cobre:

- **Só uma thread.** Não testei carga com várias threads.
- **Só CPU.** A memória não foi comparada.
- **Só o tamanho micro.**

## Checklist

- Anote o preço por hora sob demanda de cada tipo que você quer comparar, na sua região, e a data da consulta.
- Lance uma instância de cada tipo. Na T4g, escolha a imagem ARM.
- Instale o sysbench em todas e rode `sysbench cpu --threads=1 run`.
- Anote os eventos por segundo de cada uma.
- Calcule custo por hora ÷ eventos por segundo e compare com a instância que você usa hoje.
- Antes de ir para uma instância ARM, veja o que muda na sua aplicação.

Preço por hora é só metade da conta: o que importa é quanto trabalho cada dólar compra. O teste pede um terminal e uma planilha, e responde em número se a instância que você usa ainda compensa.