segunda-feira, 16 de novembro de 2026 Edição nº 240
Buscar
Avaliação Conduzido por humano, com apoio de IA · Infraestrutura · 26 min de leitura

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
Explica (TLDR) como se eu fosse...
O que é isso?

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.

GitHub Veja o código-fonte aqui: lambda-microvm-pricing

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 usoPágina de preçosLista de preços (o que a fatura cobra)Cobrado
Lambda-MicroVM-vCPU-Second-ARMUS$ 0,0000276944 por vCPU-segundoiguala cada segundo em que a MicroVM roda
Lambda-MicroVM-Memory-GB-Second-ARMUS$ 0,0000036667 por GB-segundoiguala cada segundo em que a MicroVM roda
Lambda-MicroVM-Snapshot-Write-GBUS$ 0,0038 por GBUS$ 0,0037977138a cada suspensão
Lambda-MicroVM-Snapshot-Read-GBUS$ 0,00155 por GBUS$ 0,0015467699a cada inicialização e retomada
Lambda-MicroVM-Snapshot-Storage-GB-HourUS$ 0,08 por GB-mêsUS$ 0,0001111111 por GB-horaimagens 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:

LeituraCálculoCusto
As linhas da AWS: segundos de pico no tamanho de pico, segundos de baseline no baseline2.250 s × US$ 0,0001401112 + 6.750 s × US$ 0,0000350278US$ 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 usadas9.000 s × US$ 0,0000350278 + 2.250 s × US$ 0,0001050834US$ 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:

rodando no baseline rodando no pico suspensa suspensão / retomada inicialização: lê a imagem de 2 GB 9:00 10:00 11:00 12:00 13:00 14:00 15:00 16:00 17:00 limite de 8 horas (o tempo suspenso conta) à noite:nada cobrado 7 trechos ativos: 2,5 h, um quarto disso no pico 6 intervalos suspensos: 5,5 h, 6 ciclos de suspensão/retomada
LinhaCálculoCusto
Inicializaçãoler a imagem de 2 GB: 2 GB × US$ 0,00155US$ 0,0031
ComputaçãoPasso 2US$ 0,5517
Suspensão/retomada6 ciclos × US$ 0,0107US$ 0,0642
Armazenamento suspenso2 GB × 5,5 h × US$ 0,08 / 720 hUS$ 0,0012
Um dia de desenvolvedorUS$ 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:

Exemplo 1 · US$ 1.241,22 por mês Armazenamento US$ 3,24 Segundos de baselineUS$ 472,88 Segundos de picoUS$ 630,50 Leitura/escrita de snapshotUS$ 134,60 Exemplo 2 · US$ 1.124,03 por mês Snapshots US$ 31,16 Segundos de baselineUS$ 756,60 Segundos de picoUS$ 336,27
  • 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

LinhaCálculoCusto
Computação, pico600.000 s × 16 vCPU / 32 GBUS$ 336,27
Computação, baseline5,4M s × 4 vCPU / 8 GBUS$ 756,60
Leituras na inicialização10.000 × 2 GB × US$ 0,00155US$ 31,00
Armazenamento de imagem1 × 2 GB × US$ 0,08US$ 0,16
Total mensalUS$ 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 importaEfeito no Exemplo 1
Tempo ocioso antes da suspensão automáticaO 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 snapshotCobrados 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 dadosO 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 egressSe 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 imagensCada 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çãoA 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 usoQuantidadeCustoTarifa efetiva
Lambda-MicroVM-vCPU-Second-ARM43.346,9 vCPU-sUS$ 1,20US$ 0,0000276944
Lambda-MicroVM-Snapshot-Read-GB677,3 GBUS$ 1,05US$ 0,0015467699
Lambda-MicroVM-Memory-GB-Second-ARM85.410,6 GB-sUS$ 0,31US$ 0,0000036667
Lambda-MicroVM-Snapshot-Write-GB61,6 GBUS$ 0,23US$ 0,0037977138
Lambda-MicroVM-Snapshot-Storage-GB-Hour1.952,3 GB-hUS$ 0,22US$ 0,0001111111
TotalUS$ 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çoPremissasCusto
Lambda MicroVMsExemplo 1 da AWS: burst cobrado enquanto é usado, a suspensão mantém a memóriaUS$ 12,41
EC2 c8g.xlarge on-demand4 vCPU / 8 GiB (o pico), rodando 8 horas por dia, mais um volume gp3 de 20 GBUS$ 27,12
Fargate ARM4 vCPU / 8 GB, rodando 8 horas por diaUS$ 25,28
EC2 c8g.xlarge spoto mesmo, pelo preço spot mediano da us-east-1 em 2026-11-07; pode ser interrompidaUS$ 15,79
EC2 t4g.large2 vCPU / 8 GiB burstable, rodando 8 horas por dia, mais 20 GB de gp3: a memória do pico, metade da CPU do picoUS$ 12,35
EC2 c8g.xlarge, parada quando ociosao pico pelas 50 horas ativas, mais 20 GB de gp3; perde memória e processos, faz boot a cada sessãoUS$ 9,58
Fargate ARM, parado quando ocioso4 vCPU / 8 GB pelas 50 horas ativas; reinicia sem estadoUS$ 7,90
Fargate ARM no baseline1 vCPU / 2 GB, rodando 8 horas por dia, sem burstUS$ 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çoPremissasPor job10.000 jobs
Lambda MicroVMsExemplo 2 da AWSUS$ 0,1124US$ 1.124,03
EC2 c8g.4xlarge on-demand16 vCPU / 32 GiB durante o job inteiro, mais o tempo de bootUS$ 0,1063US$ 1.063,47
Fargate ARM16 vCPU / 32 GB durante o job inteiroUS$ 0,1053US$ 1.053,33
CodeBuild arm1.medium4 vCPU / 8 GiB, sem burstUS$ 0,0700US$ 700,00
Função Lambda, Graviton8 GB (cerca de 4,6 vCPU), sem burst, sem Docker, limite de 15 minutosUS$ 0,0640US$ 640,01
CodeBuild lambda.arm.8GBCodeBuild em computação Lambda: 8 GB, 4 vCPU, sem burst, sem Docker, limite de 15 minutosUS$ 0,0480US$ 480,00
Fargate ARM4 vCPU / 8 GB, sem burstUS$ 0,0263US$ 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

Comments