AWS HubAWS HubSão Paulo operando · 2 eventos no mundo

GravitonComputação

Nível de dificuldade: Especialista (5 de 5)

Auto Scaling Group com Graviton e x86 misturados em Spot: o passo a passo em sa-east-1

Por AWS Hub7 min de leitura

Um launch template por arquitetura, overrides de instância e a allocation strategy capacity-optimized-prioritized: o caminho completo para rodar Graviton e x86 no mesmo Auto Scaling Group sem quebrar o deploy na segunda.

Misturar c7g/m7g (Graviton, ARM64) com c6i/m6i (x86_64) no mesmo Auto Scaling Group não é truque: é o MixedInstancesPolicy do EC2 Auto Scaling fazendo o que ele sempre fez, só que com duas arquiteturas de CPU no mesmo pool de capacidade. A documentação da AWS trata isso dentro do tópico Use multiple launch templates, porque cada arquitetura precisa da sua própria AMI e, às vezes, do seu próprio userdata. O resto (allocation strategy, Capacity Rebalancing, pesos) é igual ao que você já configura num ASG só de x86.

Nota da redação: este artigo descreve três comportamentos de produto, o papel da ordem dos Overrides como desempate na allocation strategy capacity-optimized-prioritized, a lógica de antecipação do Capacity Rebalancing e a ausência de suporte a MixedInstancesPolicy no Fargate, que não puderam ser confirmados na documentação oficial usada como fonte desta matéria, a qual cobre apenas o tópico 'Use multiple launch templates'. Recomendamos validar esses pontos na documentação atual da AWS antes de usar essas premissas em decisões de produção.

O que essa política resolve e o que ela não resolve

O MixedInstancesPolicy resolve disponibilidade de Spot: quanto mais tipos de instância elegíveis o ASG puder lançar, menor a chance de o grupo todo ficar sem capacidade quando um pool específico entra em contenção. Misturar Graviton com x86 amplia ainda mais esse leque, porque você está competindo por capacidade em dois mercados de hardware diferentes dentro da mesma região.

O que ele não resolve sozinho é compatibilidade binária. Se a sua aplicação depende de um binário compilado só para x86_64, de uma extensão nativa sem build para arm64, ou de um agente de terceiros que só publica pacote Intel, o Auto Scaling vai subir a instância Graviton perfeitamente e sua aplicação vai morrer com exec format error assim que o processo tentar rodar. A política de scaling não testa compatibilidade de software; ela só decide onde há capacidade e qual é mais barato.

Pré-requisitos

  • AWS CLI v2 configurado com um profile que tenha permissão em autoscaling:* e ec2:CreateLaunchTemplate
  • Uma VPC com pelo menos duas subnets em AZs diferentes de sa-east-1 (Capacity Rebalancing funciona melhor com mais de uma AZ disponível)
  • Duas AMIs base: uma arm64 e uma x86_64 da mesma família de SO (aqui eu uso Amazon Linux 2023 nas duas)
  • Um security group e um IAM instance profile já existentes, reaproveitados nos dois launch templates
  • Se a carga sobe em container: uma imagem Docker multi-arch publicada com manifest list (docker buildx build --platform linux/amd64,linux/arm64)

Passo 1: um launch template por arquitetura

A AMI é o ponto onde Graviton e x86 divergem de verdade, então cada arquitetura ganha o seu launch template. Uso o parâmetro público do SSM para não fixar um ami-id que vai ficar velho em duas semanas:

json
// lt-graviton.json
{
 "ImageId": "resolve:ssm:/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-default-arm64",
 "InstanceType": "c7g.large",
 "SecurityGroupIds": ["sg-0123456789abcdef0"],
 "IamInstanceProfile": {"Name": "role-node-ec2"},
 "UserData": "<base64 do bootstrap.sh>"
}
json
// lt-x86.json
{
 "ImageId": "resolve:ssm:/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-default-x86_64",
 "InstanceType": "c6i.large",
 "SecurityGroupIds": ["sg-0123456789abcdef0"],
 "IamInstanceProfile": {"Name": "role-node-ec2"},
 "UserData": "<base64 do bootstrap.sh>"
}
bash
aws ec2 create-launch-template --region sa-east-1 \
 --launch-template-name lt-graviton \
 --launch-template-data file://lt-graviton.json

aws ec2 create-launch-template --region sa-east-1 \
 --launch-template-name lt-x86 \
 --launch-template-data file://lt-x86.json

O InstanceType de cada launch template funciona como valor padrão; na minha leitura da configuração, é a combinação de cada entrada da lista de Overrides com o launch template correspondente que decide o que sobe em cada lançamento, como mostra o próximo passo.

Passo 2: o Auto Scaling Group com overrides e allocation strategy

Cada entrada em Overrides aponta para o InstanceType e, separadamente, para o launch template daquela arquitetura. É essa combinação que faz o c7g.large sair com a AMI ARM e o c6i.large sair com a AMI x86, dentro do mesmo grupo:

json
// asg-mixed.json
{
 "AutoScalingGroupName": "asg-app-mixed",
 "MixedInstancesPolicy": {
 "LaunchTemplate": {
 "LaunchTemplateSpecification": {
 "LaunchTemplateId": "lt-graviton-id",
 "Version": "$Latest"
 },
 "Overrides": [
 {"InstanceType": "c7g.large", "LaunchTemplateSpecification": {"LaunchTemplateId": "lt-graviton-id", "Version": "$Latest"}},
 {"InstanceType": "m7g.large", "LaunchTemplateSpecification": {"LaunchTemplateId": "lt-graviton-id", "Version": "$Latest"}},
 {"InstanceType": "c6i.large", "LaunchTemplateSpecification": {"LaunchTemplateId": "lt-x86-id", "Version": "$Latest"}},
 {"InstanceType": "m6i.large", "LaunchTemplateSpecification": {"LaunchTemplateId": "lt-x86-id", "Version": "$Latest"}}
 ]
 },
 "InstancesDistribution": {
 "OnDemandBaseCapacity": 0,
 "OnDemandPercentageAboveBaseCapacity": 0,
 "SpotAllocationStrategy": "capacity-optimized-prioritized"
 }
 },
 "MinSize": 2,
 "MaxSize": 10,
 "DesiredCapacity": 4,
 "VPCZoneIdentifier": "subnet-aaa,subnet-bbb",
 "HealthCheckType": "EC2",
 "HealthCheckGracePeriod": 120
}
bash
aws autoscaling create-auto-scaling-group --region sa-east-1 \
 --cli-input-json file://asg-mixed.json

Organizei a lista de Overrides colocando c7g e m7g primeiro de propósito: a leitura comum sobre capacity-optimized-prioritized é que a ordem da lista pesa como critério de desempate quando a capacidade Spot disponível é parecida entre pools, então essa ordem sinaliza preferência por Graviton sempre que houver capacidade, caindo para x86 quando o pool ARM estiver apertado. Vale confirmar esse comportamento na documentação da sua conta antes de depender dele para decisões críticas.

Passo 3: Capacity Rebalancing

A proposta do Capacity Rebalancing, pelo que o nome do recurso já indica, é tentar antecipar a substituição de instâncias sinalizadas como em risco de interrupção, em vez de esperar a instância ser efetivamente interrompida. Vale conferir o comportamento exato na documentação da sua versão antes de assumir prazos específicos:

bash
aws autoscaling update-auto-scaling-group --region sa-east-1 \
 --auto-scaling-group-name asg-app-mixed \
 --capacity-rebalance

Com duas arquiteturas no mesmo grupo, essa troca proativa é ainda mais valiosa: se um pool Graviton específico entrar em contenção numa AZ, o rebalanceamento pode substituir a instância por outra arquitetura sem esperar o ASG inteiro ficar sem capacidade.

Passo 4: o que precisa mudar na AMI e no entrypoint

Nota da redação: o código desta seção não foi executado em ambiente real. Valide antes de usar em produção.

Se a carga roda direto na EC2 (sem container), o bootstrap.sh do userdata precisa checar a arquitetura antes de baixar qualquer binário externo:

bash
#!/bin/bash
ARCH=$(uname -m)
if [ "$ARCH" = "aarch64" ]; then
 curl -O https://.../agent-arm64.rpm
else
 curl -O https://.../agent-x86_64.rpm
fi
rpm -i agent-*.rpm

Se a carga roda em container, o caminho mais limpo é publicar uma imagem multi-arch com docker buildx build --platform linux/amd64,linux/arm64 -t minha-imagem:latest --push .; o runtime escolhe a camada certa sozinho, sem lógica condicional em lugar nenhum.

Os tropeços mais comuns ao migrar algo existente para esse esquema:

  • Dependências nativas (bcrypt, sharp, drivers de banco compilados) sem build arm64 publicado: o npm install roda, mas falha em runtime com exec format error ou erro de símbolo não encontrado
  • Agentes de terceiros (APM, CloudWatch agent antigo, scanners de segurança) que só têm pacote x86_64: checar a página de download antes de assumir compatibilidade
  • Scripts de deploy com caminho de binário hardcoded (/opt/app/bin-x86/app) em vez de resolver pelo uname -m

Medindo o custo real antes e depois

Spot muda de preço o tempo todo, então não existe número fixo para cravar aqui: a forma correta é você rodar a consulta no seu momento e comparar. Para ver o preço Spot atual dos quatro tipos de instância na sua AZ:

bash
aws ec2 describe-spot-price-history --region sa-east-1 \
 --instance-types c7g.large m7g.large c6i.large m6i.large \
 --product-descriptions "Linux/UNIX" \
 --start-time $(date -u -d '-1 hour' +%Y-%m-%dT%H:%M:%S) \
 --max-results 20

Para comparar o custo real do ASG antes e depois da migração, agrupe o Cost Explorer por tipo de instância, filtrando pela tag do grupo:

bash
aws ce get-cost-and-usage \
 --time-period Start=2026-10-16,End=2026-11-16 \
 --granularity DAILY \
 --filter file://filter-asg-mixed.json \
 --group-by Type=DIMENSION,Key=INSTANCE_TYPE \
 --metrics "UnblendedCost"

Rode a mesma consulta num período antes da mudança (só x86) e depois (com a mistura) para enxergar a diferença real na sua fatura, não numa estimativa. Graviton costuma ser citado como mais vantajoso em custo-benefício do que a geração x86 equivalente, mas sem um número fixo que valha para toda carga; o ganho real depende de quanto da sua aplicação tolera rodar em ARM, e por isso a comparação de fatura antes/depois importa mais do que qualquer estimativa genérica.

O que fica em aberto

Essa configuração funciona para EC2 puro, mas se a carga já roda em EKS, o equivalente é um Managed Node Group com múltiplos tipos de instância ou um NodePool do Karpenter com requirements cobrindo arm64 e amd64; a lógica de allocation strategy Spot por trás é a mesma. Fargate fica fora dessa conta: o modelo de provisionamento lá é diferente, sem gestão direta de MixedInstancesPolicy como no EC2, então misturar arquitetura em Fargate é um tema à parte, que este tutorial não cobre.

Também vale lembrar que nem toda carga se comporta igual nas duas arquiteturas. Workloads que dependem de instruções vetoriais específicas de x86 (AVX-512, por exemplo) ou de bibliotecas otimizadas só para Intel podem ter desempenho diferente por vCPU entre Graviton e x86, então a conta de custo por hora precisa vir acompanhada de uma checagem de custo por requisição ou por job antes de declarar vitória.

Fonte

Amazon EC2 Auto Scaling, "Auto Scaling groups with multiple instance types and purchase options" (https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-mixed-instances-groups.html)

Fonte: Amazon EC2 Auto Scaling — Auto Scaling groups with multiple instance types and purchase options

Serviços neste textoGraviton

Leve para a sua IA

Decida com o seu assistente, com o contexto deste texto já montado.

1. O que você quer saber

Ver o prompt
Li no AWS Hub: "Auto Scaling Group com Graviton e x86 misturados em Spot: o passo a passo em sa-east-1" (https://awshub.com.br/computacao/auto-scaling-group-com-graviton-e-x86-misturados-em-spot-o-passo-a-passo-em-sa-e).
Resumo: Um launch template por arquitetura, overrides de instância e a allocation strategy capacity-optimized-prioritized: o caminho completo para rodar Graviton e x86 no mesmo Auto Scaling Group sem quebrar o deploy na segunda.
Fonte oficial: https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-mixed-instances-groups.html
Serviços: Graviton

Minha stack: [descreva em uma linha: serviços, linguagem, volume, região]

Adapte este passo a passo para a minha stack, com os comandos.

Newsletter semanal

A semana da AWS, em português

Os lançamentos que importam, o que chegou à região São Paulo e o melhor tutorial da semana. Toda sexta, gratuita.