Preços das AWS Lambda MicroVMs, Explicados
Por Fabio Douek
Conduzido por humano, com apoio de IA. Pesquisa e implementação feitas com ferramentas de IA, conduzidas, testadas e editadas por mim. Como os posts são classificados
Ir para seção
- Visão Geral
- A tabela de tarifas
- Exemplo 1: Um sandbox de programação, um passo de cada vez
- Passo 1: Uma MicroVM, uma hora
- Passo 2: Burst acima do baseline
- Passo 3: Suspender e retomar
- Passo 4: O dia de um desenvolvedor
- Passo 5: 100 desenvolvedores, 20 dias
- Exemplo 2: Jobs de CI, um de cada vez
- Passo 1: Um job de dez minutos
- Passo 2: 10.000 jobs
- O que os exemplos deixam de fora
- Conferindo com a minha fatura
- Como se compara
- Veredito
Explica (TLDR) como se eu fosse...
Imagine alugar um robô de brinquedo que custa uma moedinha a cada segundo em que ele está ligado, e quatro moedinhas por segundo quando ele corre bem rápido. Quando você vai fazer um lanche, pode colocá-lo para dormir numa caixa, e guardar a caixa quase não custa nada.
Colocar o robô para dormir e acordá-lo custa mais ou menos o mesmo que cinco minutos de brincadeira, então só vale a pena se o seu lanche demorar mais do que isso. A maior parte do dinheiro vai para o tempo em que o robô está acordado e trabalhando, não para a caixa.
A AWS publica cinco tarifas para as Lambda MicroVMs e dois exemplos calculados, mas os exemplos se apoiam em premissas que um comprador deve testar: o tamanho de cada snapshot, quanto tempo roda acima do baseline e a exclusão da transferência de dados. Nenhum dos exemplos é uma cotação.
A exposição material é a computação, nove décimos ou mais das duas contas. As cobranças de snapshot são medidas pelo tamanho usado, e a única fatura pública encontrada mostra cerca de quatro vezes o snapshot de memória por inicialização. Não há free tier e, até onde mostram os arquivos de tarifas publicados, nenhum desconto de Savings Plans, então faça o orçamento pelo preço de tabela e confira no Cost Explorer.
A queixa principal é uma fatura opaca: cinco tarifas, dois exemplos calculados e nenhuma forma de ver qual premissa determina qual linha. Reconstruir os dois a partir de uma única MicroVM deixa o diagnóstico claro. A computação é nove décimos ou mais do custo, e os segundos de burst são uma parte grande dela.
Suspender é o tratamento principal, eficaz para pausas mais longas que cerca de cinco minutos e contraproducente abaixo disso. Efeitos colaterais a monitorar: o tempo ocioso antes da suspensão automática é cobrado, os tamanhos de snapshot são presumidos e a transferência de dados fica de fora. As evidências de faturas reais ainda são escassas.
Páginas de preços podem parecer um muro de decimais minúsculos, e é fácil desconfiar que você deixou passar algum truque. Ir de uma MicroVM para um dia e depois para um time inteiro tira a ansiedade: cada número tem um motivo, e a maior parte da conta vem de um lugar só.
A tensão está nos hábitos que o modelo recompensa. Times que deixam os sandboxes dormirem quando as pessoas se afastam pagam metade; times que mantêm tudo acordado por cautela pagam o dobro. É uma conversa sobre confiar no botão de suspender tanto quanto sobre dinheiro.
Pense na conta de uma MicroVM como um metrônomo: um clique por segundo enquanto o sandbox roda, quatro vezes mais alto quando ele faz burst. As pausas saem quase de graça, mas cada parada e recomeço custa um tempo, cerca de cinco minutos de execução.
Então o arranjo importa mais do que o andamento. Um sandbox de programação com pausas longas e passagens curtas e fortes sai por cerca de doze dólares por desenvolvedor por mês. Um job de CI que toca direto do início ao fim, com um minuto forte, sai por cerca de onze centavos por execução.
A história que a AWS conta com os próprios números é US$ 12,41 por desenvolvedor por mês para um sandbox de programação e 11 centavos por job de CI. Reconstruídos a partir de uma MicroVM, os dois números se sustentam, e o argumento de venda é claro: sessões quentes que dormem barato e só fazem burst quando precisam.
O posicionamento tem limites. Para CI, uma task do Fargate ou uma instância EC2 dimensionada para o job custa mais ou menos o mesmo, ou menos. Para sandboxes, as opções mais baratas da AWS que alcançam o pico perdem a memória quando ficam ociosas. Lidere com sessões isoladas e com estado, não com o preço por vCPU.
Visão Geral
A página de preços do AWS Lambda dá às Lambda MicroVMs cinco tarifas e dois exemplos calculados: sandboxes para um assistente de programação a US$ 1.241,22 por mês para 100 desenvolvedores, e jobs de CI a US$ 1.124,03 para 10.000 execuções. Os exemplos vão direto das tarifas para os totais mensais, então é difícil ver qual premissa determina qual linha. Na minha série hands-on, o que mais me importava era se as MicroVMs funcionavam. Este post é sobre quanto elas custam.
Eu reconstruo os dois exemplos a partir de uma única MicroVM, um passo de cada vez: uma hora no baseline, um burst, uma suspensão e retomada, o dia de um desenvolvedor e depois o time inteiro. Uma pequena calculadora reproduz cada linha dos dois exemplos até o centavo. Depois, cubro o que os exemplos deixam de fora, confiro o modelo com a minha própria fatura da série e comparo as duas cargas de trabalho com outros serviços da AWS: EC2, Fargate, CodeBuild e funções Lambda.
A versão curta: a computação é quase a conta inteira, suspender se paga depois de cerca de cinco minutos de ociosidade, e as cobranças de snapshot dependem de quão grandes os seus snapshots realmente são, algo que os exemplos presumem em vez de medir.
Todos os preços deste post são preços de tabela da AWS em 9 de novembro de 2026, na us-east-1, salvo indicação em contrário.
A tabela de tarifas
As MicroVMs cobram cinco tipos de uso. Estes são os nomes na minha fatura do Cost Explorer, com as tarifas Graviton da us-east-1 em 9 de novembro de 2026:
| Tipo de uso | Página de preços | Lista de preços (o que a fatura cobra) | Cobrado |
|---|---|---|---|
Lambda-MicroVM-vCPU-Second-ARM | US$ 0,0000276944 por vCPU-segundo | igual | a cada segundo em que a MicroVM roda |
Lambda-MicroVM-Memory-GB-Second-ARM | US$ 0,0000036667 por GB-segundo | igual | a cada segundo em que a MicroVM roda |
Lambda-MicroVM-Snapshot-Write-GB | US$ 0,0038 por GB | US$ 0,0037977138 | a cada suspensão |
Lambda-MicroVM-Snapshot-Read-GB | US$ 0,00155 por GB | US$ 0,0015467699 | a cada inicialização e retomada |
Lambda-MicroVM-Snapshot-Storage-GB-Hour | US$ 0,08 por GB-mês | US$ 0,0001111111 por GB-hora | imagens e MicroVMs suspensas |
Algumas regras moldam tudo o que vem a seguir:
- O tamanho é definido pela memória. Você escolhe um tamanho de memória de baseline e recebe uma vCPU a cada 2 GB. O padrão é 2 GB com 1 vCPU, e o maior baseline é 8 GB com 4 vCPU (imagens e dimensionamento).
- Uma MicroVM pode fazer burst até 4x o seu baseline sem nenhuma ação sua. Você paga o baseline enquanto ela roda e, nas palavras da página, “apenas pela duração ativa da memória e da vCPU adicionais consumidas, não pela capacidade de pico”.
- A computação é cobrada por segundo. Não encontrei nenhuma duração mínima documentada.
- Os snapshots são cobrados pelo que usam. A lista de preços mede leituras e escritas de snapshot “em GB de memória e disco usados pelo snapshot” e o armazenamento “ponderado pela memória e disco usados pelo snapshot”, enquanto o Lambda SnapStart, no mesmo arquivo, diz “atribuídos à função”. Os 2 GB dos exemplos são uma premissa sobre a carga de trabalho, não a memória configurada.
- O armazenamento de imagens tem mínimo de uma semana, e a transferência de dados é cobrada à parte, pelas tarifas padrão da AWS.
- Sem free tier e sem Savings Plans. O free tier da página de preços cobre apenas as Event Functions. O arquivo de tarifas do Compute Savings Plans para a us-east-1 não lista nenhum tipo de uso de MicroVM, então, até onde consigo ver, não existe hoje desconto por compromisso.
Os exemplos da página usam tarifas de snapshot arredondadas para cinco casas decimais; a fatura usa as da lista de preços. A diferença é pequena: o Exemplo 1 dá US$ 1.241,07 com as tarifas exatas em vez de US$ 1.241,22. Abaixo, uso as tarifas da página para que todos os números batam com os da AWS.
As tarifas variam por região. us-east-2 e us-west-2 são iguais à us-east-1; os dois exemplos custam cerca de 5% a mais na eu-west-1, 17% a mais na ap-northeast-1 e 27% a mais na eu-central-1. A lista de preços também traz tarifas x86, 17,9% acima do Graviton na us-east-1, e o Developer Guide agora diz que x86_64 é suportado a partir da versão 3 da imagem base, mas a página de preços mostra apenas Graviton.
Exemplo 1: Um sandbox de programação, um passo de cada vez
O cenário da AWS: cada desenvolvedor recebe um sandbox isolado para programação assistida por IA, com baseline de 2 GB / 1 vCPU que faz burst até 8 GB / 4 vCPU para compilar e rodar testes. A jornada de trabalho é de 8 horas. O sandbox fica ativo em 2,5 delas, 25% disso no pico, e suspenso nas outras 5,5, com seis ciclos de suspensão/retomada. São 100 desenvolvedores, 20 dias úteis por mês e cinco imagens de linguagem de 2 GB.
Passo 1: Uma MicroVM, uma hora
Comece com uma MicroVM no tamanho padrão, sem fazer nada de especial:
per second 1 vCPU x $0.0000276944 + 2 GB x $0.0000036667 = $0.0000350278
per hour $0.0997 vCPU + $0.0264 memory = $0.1261
Esse é o piso: cerca de 12,6 centavos por hora, 79% disso em vCPU, cobrado a cada segundo em que a MicroVM está rodando, esteja ela compilando ou esperando uma tecla. Deixada rodando por toda a sua vida útil de 8 horas, ela custa US$ 1,01. Rodando 24 horas por dia, seriam US$ 3,03 por dia, o número citado nas threads do lançamento, embora nenhuma MicroVM possa rodar mais de 8 horas.
Passo 2: Burst acima do baseline
Quando o agente compila ou roda testes, a MicroVM escala sozinha para 4 vCPU e 8 GB. Na verdade, o guest sempre enxerga o pico: na parte 1, uma MicroVM padrão de 2 GB reportou nproc 4 e 8 GB de MemTotal, sem limites de cgroup. Ferramentas de build que dimensionam seus pools de workers pela contagem de CPUs vão fazer burst por padrão. No tamanho máximo, um segundo custa exatamente quatro vezes mais, US$ 0,0001401112, ou US$ 0,5044 por hora.
No exemplo, o sandbox fica ativo 2,5 horas por dia (9.000 segundos) e no pico durante um quarto disso (2.250 segundos). Há duas formas de calcular o preço, e elas dão o mesmo total:
| Leitura | Cálculo | Custo |
|---|---|---|
| As linhas da AWS: segundos de pico no tamanho de pico, segundos de baseline no baseline | 2.250 s × US$ 0,0001401112 + 6.750 s × US$ 0,0000350278 | US$ 0,3153 + US$ 0,2364 = US$ 0,5517 |
| A regra de cobrança: o piso por todo o tempo ativo, mais as 3 vCPU / 6 GB extras enquanto são usadas | 9.000 s × US$ 0,0000350278 + 2.250 s × US$ 0,0001050834 | US$ 0,3153 + US$ 0,2364 = US$ 0,5517 |
As duas leituras produzem os mesmos dois números com os rótulos trocados. É uma coincidência do exemplo: 25% do tempo a 4x é igual a 100% a 1x. Não tire conclusões demais de qual linha se chama “pico”.
Uma premissa a notar: o exemplo coloca a MicroVM nos 4x completos em todo segundo de pico. A regra de cobrança cobra pela vCPU e pela memória realmente consumidas acima do baseline, então um burst que só chega a 2 vCPU e 4 GB custa menos que o do exemplo.
Passo 3: Suspender e retomar
Nas outras 5,5 horas, o desenvolvedor está lendo, em reuniões ou no almoço. Pagar o piso nesse tempo é desperdício, então o sandbox suspende:
suspend write 2 GB x $0.0038 = $0.0076 compute stops
suspended 2 GB x $0.08 / 720 h = $0.00022 per hour
resume read 2 GB x $0.00155 = $0.0031
one cycle = $0.0107
Uma hora suspensa custa cerca de 1/570 de uma hora rodando. O custo de suspender é o próprio ciclo: US$ 0,0107 é o que o baseline de 2 GB custa em cerca de 305 segundos rodando. Então a regra prática é que suspender compensa quando a pausa passa de uns cinco minutos. Para pausas mais curtas, mantenha rodando. Pelo mesmo motivo, no Exemplo 1 as leituras e escritas de snapshot custam 55 vezes mais que o armazenamento suspenso: o número de ciclos importa muito mais do que as horas em suspensão.
Passo 4: O dia de um desenvolvedor
Juntando tudo para um desenvolvedor:
| Linha | Cálculo | Custo |
|---|---|---|
| Inicialização | ler a imagem de 2 GB: 2 GB × US$ 0,00155 | US$ 0,0031 |
| Computação | Passo 2 | US$ 0,5517 |
| Suspensão/retomada | 6 ciclos × US$ 0,0107 | US$ 0,0642 |
| Armazenamento suspenso | 2 GB × 5,5 h × US$ 0,08 / 720 h | US$ 0,0012 |
| Um dia de desenvolvedor | US$ 0,6202 |
O mesmo dia sem suspender, ocioso no baseline durante as 5,5 horas, custa US$ 1,25. Suspender corta a conta pela metade.
O exemplo também tem um limite rígido que não explicita. Uma MicroVM vive no máximo 8 horas, e o tempo suspenso conta para esse limite (eu medi isso na parte 1, Teste 6). 2,5 horas ativas mais 5,5 suspensas dão exatamente 8, então a MicroVM atinge o limite no fim do dia. É por isso que há uma inicialização por desenvolvedor por dia, e por isso o exemplo não cobra nada nas outras 16 horas. Se um desenvolvedor precisa que o sandbox de amanhã se lembre de hoje, esse estado tem que ficar em outro lugar.
Passo 5: 100 desenvolvedores, 20 dias
Agora multiplique: 100 desenvolvedores × 20 dias úteis dão 2.000 dias de sandbox.
2,000 x $0.62021 = $1,240.42
5 images x 2 GB x $0.08 = $0.80
monthly total = $1,241.22 ($12.41 per developer)
Isso bate com a AWS. Aqui está o detalhamento da própria página, que a calculadora reproduz linha por linha:
Exemplo 1, linha por linha (python microvm_cost.py scenarios/coding-sandboxes.json)
Compute
Peak 4.50M s at 4 vCPU / 8 GB $630.50
vCPU 4.50M s x 4 vCPU $498.50
memory 4.50M s x 8 GB $132.00
Baseline 13.50M s at 1 vCPU / 2 GB $472.88
vCPU 13.50M s x 1 vCPU $373.87
memory 13.50M s x 2 GB $99.00
Compute total $1,103.38
Snapshot read/write
Write on suspend 12,000 cycles x 2 GB $91.20
Read on resume 12,000 cycles x 2 GB $37.20
Read on launch 2,000 launches x 2 GB $6.20
Read/write total $134.60
Snapshot storage
Images 5 x 2 GB for a month $0.80
Suspended MicroVMs 2,000 x 2 GB x 5.5 h / 720 h $2.44
Storage total $3.24
----------------------------------------------------------------------------------
Monthly total $1,241.22
Per developer $12.41
Share: compute 88.9%, snapshot read/write 10.8%, snapshot storage 0.3%
(A página mostra as linhas de baseline como US$ 373,87 + US$ 99,00 = US$ 472,88. Parece um erro de um centavo, mas é a soma sem arredondamento, US$ 472,8753, arredondada.)
Para onde vai o dinheiro:
- A computação é 89% da conta, e os segundos de pico são 57% da computação. O quanto o agente exige do sandbox importa mais do que por quanto tempo o desenvolvedor o deixa aberto.
- Leituras e escritas de snapshot são 11%, e dois terços disso são escritas. Cada ciclo extra de suspensão/retomada por desenvolvedor por dia acrescenta US$ 21,40 por mês para o time.
- O armazenamento é 0,3%. Manter 100 sandboxes suspensos por 5,5 horas por dia custa US$ 2,44 por mês.
- Sem suspensão, o mesmo time pagaria US$ 2.497,48 por mês, US$ 24,97 por desenvolvedor.
Exemplo 2: Jobs de CI, um de cada vez
O segundo cenário da AWS é uma plataforma multi-tenant que roda código não confiável (instalação de dependências, scripts de build, scanners de vulnerabilidade), então cada job ganha sua própria MicroVM. Os jobs rodam uma vez e terminam; nada é suspenso. O baseline é 8 GB / 4 vCPU, com burst até 32 GB / 16 vCPU. Um job leva 10 minutos, 10% deles no pico, e inicia a partir de uma imagem de 2 GB. São 10.000 jobs por mês.
Passo 1: Um job de dez minutos
baseline 4 vCPU + 8 GB = $0.0001401112 per second ($0.5044 per hour)
540 s at baseline = $0.0757
peak 16 vCPU + 32 GB = $0.0005604448 per second
60 s at peak = $0.0336
launch read the 2 GB image = $0.0031
one job = $0.1124
O minuto de burst é 10% do tempo do job e 31% da sua computação. Rodar o job inteiro com 16 vCPU / 32 GB custaria US$ 0,3394, três vezes mais, o que resume em um número o argumento a favor da cobrança de burst.
Passo 2: 10.000 jobs
| Linha | Cálculo | Custo |
|---|---|---|
| Computação, pico | 600.000 s × 16 vCPU / 32 GB | US$ 336,27 |
| Computação, baseline | 5,4M s × 4 vCPU / 8 GB | US$ 756,60 |
| Leituras na inicialização | 10.000 × 2 GB × US$ 0,00155 | US$ 31,00 |
| Armazenamento de imagem | 1 × 2 GB × US$ 0,08 | US$ 0,16 |
| Total mensal | US$ 1.124,03 (US$ 0,1124 por job) |
A computação é 97% desta conta. Sem suspensão, não há custo de escrita nem armazenamento suspenso, e a única cobrança de snapshot é a leitura na inicialização. Essa leitura é calculada sobre a imagem de 2 GB, não sobre os 8 GB de memória, o que bate com a expressão “usados pelo snapshot” da lista de preços.
O que os exemplos deixam de fora
Os dois exemplos são internamente consistentes, mas cada um deixa de fora algo pelo qual você vai pagar:
| O quê | Por que importa | Efeito no Exemplo 1 |
|---|---|---|
| Tempo ocioso antes da suspensão automática | O maxIdleDurationSeconds da política de ociosidade tem mínimo de 60 (IdlePolicy), e a MicroVM fica rodando e sendo cobrada até ela disparar. Chamar SuspendMicrovm você mesmo evita isso. | +US$ 25,22 por mês com 60 s; +US$ 126,10 com 300 s |
| Tamanhos reais de snapshot | Cobrados pela memória e pelo disco usados, não pelos configurados, mas o tamanho cobrado também não é o do snapshot de memória. A única fatura pública que encontrei mostra inicializações lendo até 2,49 GB para um snapshot de memória de 0,59 GB, e o que muito provavelmente foi uma suspensão escrevendo 1,09 GB em uma MicroVM de 2 GB. | Pode ser menor ou maior que os 2 GB presumidos |
| Transferência de dados | O egress para a internet e o tráfego entre as MicroVMs e a sua VPC são cobrados pelas tarifas padrão da AWS. Nenhum dos exemplos inclui isso. | Depende do tráfego |
| Infraestrutura de egress | Se os sandboxes acessam a internet pela sua VPC, o NAT gateway, o proxy e o load balancer são contas à parte. A configuração da minha parte 2 custava cerca de US$ 0,095 por hora antes de qualquer MicroVM rodar. | Cerca de US$ 68 por mês, fixo |
| Armazenamento de imagens | Cada versão de imagem é cobrada por pelo menos uma semana, mesmo que você a apague antes. Uma imagem é construída uma vez por geração de Graviton, e a mesma fatura pública mostra cerca de 1,35 GB cobrados por versão para builds de cerca de 0,62 GB cada. | Cerca de US$ 0,04 por semana a cada 2 GB cobrados |
| Estados de transição | A documentação diz que MicroVMs em execução geram cobrança de computação, as suspensas apenas de armazenamento, e as encerradas nada. Ela não diz como PENDING (incluindo o hook /run), SUSPENDING ou TERMINATING são cobrados. | Desconhecido, provavelmente pequeno |
A linha do snapshot é a que eu verificaria primeiro para a sua carga de trabalho. Essa fatura pública é o ADR-0032 em cosmipixel/agentic-qa-platform, um runner de Chromium de 2 GB na us-east-2: as leituras na inicialização ficam próximas da soma do snapshot de memória da imagem, do snapshot de disco e da instalação de código de 1,69 GB. Então o GetMicrovmImageBuild, que reporta esses três tamanhos, é um guia melhor para as leituras na inicialização do que o snapshot de memória sozinho. A imagem que eu construí na parte 1 reportou um snapshot de memória de 534 MiB, um snapshot de disco de 23,5 MB e uma instalação de código de 573 MB. O que uma suspensão escreve depende do que a carga de trabalho tocou; por enquanto, é um único ponto de dados.
Conferindo com a minha fatura
Os três posts da minha série sobre MicroVMs rodaram seus testes de 2026-11-03 a 2026-11-05. Dois dias depois, o Cost Explorer mostrava tudo (o bill.py imprime a mesma tabela para a sua conta):
| Tipo de uso | Quantidade | Custo | Tarifa efetiva |
|---|---|---|---|
Lambda-MicroVM-vCPU-Second-ARM | 43.346,9 vCPU-s | US$ 1,20 | US$ 0,0000276944 |
Lambda-MicroVM-Snapshot-Read-GB | 677,3 GB | US$ 1,05 | US$ 0,0015467699 |
Lambda-MicroVM-Memory-GB-Second-ARM | 85.410,6 GB-s | US$ 0,31 | US$ 0,0000036667 |
Lambda-MicroVM-Snapshot-Write-GB | 61,6 GB | US$ 0,23 | US$ 0,0037977138 |
Lambda-MicroVM-Snapshot-Storage-GB-Hour | 1.952,3 GB-h | US$ 0,22 | US$ 0,0001111111 |
| Total | US$ 3,01 |
O que ela confirma:
- Os cinco tipos de uso e suas tarifas batem exatamente com a lista de preços. O armazenamento é medido por GB-hora, que é como os exemplos calculam o tempo suspenso.
- GB-s de memória dividido por vCPU-s dá 1,97, perto da proporção 2:1 dos tamanhos que eu rodei, então houve pouco burst só de CPU (um burst que usa vCPU e memória na mesma proporção mantém a razão em 2). Não há um tipo de uso separado para burst: ele é cobrado como vCPU-segundos e GB-segundos comuns.
- As leituras de snapshot ficaram em segundo lugar, logo atrás da vCPU. Meus testes iniciaram muitas MicroVMs de vida curta e suspenderam poucas, então as leituras de snapshot superaram as escritas em 11 para 1. O padrão do Exemplo 1, com muitas suspensões, é o oposto.
- O armazenamento continuou sendo cobrado depois que os testes terminaram: 578,7 GB-horas em 2026-11-06, um dia sem computação, cerca de 24 GB mantidos o dia inteiro. Isso bate com o mínimo de uma semana para cada versão de imagem que a série construiu, ou com imagens que eu ainda não tinha apagado.
O que ela não consegue confirmar: o Cost Explorer só me dá totais diários (a granularidade por hora precisa ser ativada na conta pagadora), então não consigo separar as leituras por inicialização e verificar quantos GB uma única inicialização ou suspensão teve cobrados.
Como se compara
Aqui estão os dois exemplos com os preços de outros serviços da AWS na us-east-1, em Graviton quando há escolha, usando preços de tabela em 9 de novembro de 2026. São cálculos meus a partir das tarifas publicadas pela AWS; as premissas importam tanto quanto os números.
Exemplo 1, por desenvolvedor por mês (20 dias úteis de 8 horas, 50 horas ativas, 12,5 delas precisando de 4 vCPU / 8 GB):
| Serviço | Premissas | Custo |
|---|---|---|
| Lambda MicroVMs | Exemplo 1 da AWS: burst cobrado enquanto é usado, a suspensão mantém a memória | US$ 12,41 |
| EC2 c8g.xlarge on-demand | 4 vCPU / 8 GiB (o pico), rodando 8 horas por dia, mais um volume gp3 de 20 GB | US$ 27,12 |
| Fargate ARM | 4 vCPU / 8 GB, rodando 8 horas por dia | US$ 25,28 |
| EC2 c8g.xlarge spot | o mesmo, pelo preço spot mediano da us-east-1 em 2026-11-07; pode ser interrompida | US$ 15,79 |
| EC2 t4g.large | 2 vCPU / 8 GiB burstable, rodando 8 horas por dia, mais 20 GB de gp3: a memória do pico, metade da CPU do pico | US$ 12,35 |
| EC2 c8g.xlarge, parada quando ociosa | o pico pelas 50 horas ativas, mais 20 GB de gp3; perde memória e processos, faz boot a cada sessão | US$ 9,58 |
| Fargate ARM, parado quando ocioso | 4 vCPU / 8 GB pelas 50 horas ativas; reinicia sem estado | US$ 7,90 |
| Fargate ARM no baseline | 1 vCPU / 2 GB, rodando 8 horas por dia, sem burst | US$ 6,32 |
Tudo o que fica ligado durante a jornada e consegue alcançar o pico custa mais que as MicroVMs, de US$ 15,79 no spot a US$ 27,12. A t4g.large custa mais ou menos o mesmo e mantém a memória, mas tem metade da CPU do pico. Todo o resto abaixo de US$ 12,41 ou perde a memória e os processos do sandbox enquanto o desenvolvedor está fora, ou nunca faz burst. Se manter uma sessão quente importa, as MicroVMs são as mais baratas dessas opções; se um cold start a cada sessão não é problema, não são.
Funções Lambda não estão na tabela porque não conseguem manter um sandbox: uma invocação roda por no máximo 15 minutos e não guarda nada em memória entre invocações. Por GB-segundo, elas custam US$ 0,0000133334 em Graviton, 24% menos que os US$ 0,0000175139 de uma MicroVM com 1 vCPU a cada 2 GB, e uma função de 2 GB recebe um pouco mais de CPU (cerca de 1,16 vCPU).
Exemplo 2, por job (10 minutos, 1 minuto precisando de 16 vCPU / 32 GB):
| Serviço | Premissas | Por job | 10.000 jobs |
|---|---|---|---|
| Lambda MicroVMs | Exemplo 2 da AWS | US$ 0,1124 | US$ 1.124,03 |
| EC2 c8g.4xlarge on-demand | 16 vCPU / 32 GiB durante o job inteiro, mais o tempo de boot | US$ 0,1063 | US$ 1.063,47 |
| Fargate ARM | 16 vCPU / 32 GB durante o job inteiro | US$ 0,1053 | US$ 1.053,33 |
| CodeBuild arm1.medium | 4 vCPU / 8 GiB, sem burst | US$ 0,0700 | US$ 700,00 |
| Função Lambda, Graviton | 8 GB (cerca de 4,6 vCPU), sem burst, sem Docker, limite de 15 minutos | US$ 0,0640 | US$ 640,01 |
CodeBuild lambda.arm.8GB | CodeBuild em computação Lambda: 8 GB, 4 vCPU, sem burst, sem Docker, limite de 15 minutos | US$ 0,0480 | US$ 480,00 |
| Fargate ARM | 4 vCPU / 8 GB, sem burst | US$ 0,0263 | US$ 263,33 |
Para CI, as MicroVMs custam mais ou menos o mesmo que uma task do Fargate ou uma instância EC2 dimensionada para o pico durante os dez minutos inteiros. As tarifas de MicroVM do Lambda são 3,08 vezes as do Fargate ARM por vCPU e 3,71 vezes por GB; a cobrança de burst apenas compensa a diferença. As opções dimensionadas para o baseline são de 38% a 77% mais baratas que o job com burst, mas rodam o minuto de pico com cerca de um quarto do tamanho. Se os seus jobs não precisam de burst nenhum, o mesmo job em uma MicroVM no baseline custa US$ 0,0872, e as opções de baseline são de 20% (CodeBuild arm1.medium) a 70% (Fargate) mais baratas. O argumento a favor das MicroVMs aqui é o isolamento por job e o início a partir de um snapshot, não o preço.
Veredito
O modelo de preços das MicroVMs tem cinco tarifas, mas só uma domina os dois exemplos: a computação. 89% da conta do sandbox de programação e 97% da conta de CI são vCPU e memória, e nos dois casos os segundos de burst são uma fatia desproporcional disso. As cobranças de snapshot só importam na proporção de quantas vezes você suspende e de quão grandes os seus snapshots realmente são.
O que o modelo recompensa:
- Cargas de trabalho que ficam ociosas por longos períodos e precisam da memória de volta. Um sandbox suspenso custa 1/570 de um rodando, e um ciclo completo se paga depois de cerca de cinco minutos. Esse é o caso do sandbox de programação, e é onde as MicroVMs batem todas as outras opções da AWS que eu calculei que mantêm a memória e conseguem alcançar o pico.
- Bursts curtos e ocasionais. Você paga os 4x apenas enquanto são usados, então o job do Exemplo 2 custa um terço do que custaria rodando no tamanho de pico o tempo todo.
O que ele penaliza:
- Rodar o dia inteiro. A US$ 0,126 por hora para 1 vCPU / 2 GB, uma MicroVM que nunca suspende custa cerca de três vezes o Fargate.
- Suspensões frequentes e curtas. Abaixo de cerca de cinco minutos de ociosidade, um ciclo custa mais do que ficar ligada, e o timer de suspensão automática acrescenta pelo menos 60 segundos cobrados a cada um.
- Sessões longas. O limite de 8 horas encerra toda MicroVM, suspensa ou não. O Exemplo 1 encaixa exatamente uma jornada de trabalho nele; qualquer coisa mais longa precisa da sua própria forma de persistir o estado.
Antes de confiar em qualquer um dos exemplos para o seu próprio orçamento, meça duas coisas: o tamanho dos seus snapshots de suspensão e quanto do seu tempo ativo roda acima do baseline. Depois, coloque esses valores na calculadora, que aceita qualquer premissa dos exemplos como override:
python microvm_cost.py scenarios/coding-sandboxes.json --set state_gb=1.1 --set cycles=10 --steps