Por que a BMW apostou em Arm para Veículos Conectados
A BMW Connected Company gerencia serviços digitais para mais de 24,5 milhões de veículos conectados no mundo. Em 2024, começaram a migrar a plataforma interna (Orbit) de x86 para AWS Graviton (baseado em Arm) como parte de uma estratégia de modernização. O objetivo: reduzir custos, melhorar desempenho e apoiar metas de sustentabilidade.
Não foi um simples lift-and-shift. Com mais de 130 mil builds e deploys diários, a migração exigiu uma abordagem cuidadosamente orquestrada para não interromper serviços críticos dos veículos. A equipe documentou a metodologia em um post recente do AWS Architecture Blog (fonte: post original).
O Playbook da Migração: Do CI/CD aos Node Pools
1. Builds Multi-Arquitetura
Toda imagem de contêiner precisava suportar amd64 e arm64. A equipe usou duas abordagens:
- Builds emulados com Docker Buildx + QEMU (simples, mas mais lento para cargas pesadas)
- Builds nativos em runners Graviton (mais rápido, expõe problemas de arquitetura cedo)
Ambos produzem uma manifest list (índice de imagem OCI) para que uma única tag funcione nas duas arquiteturas. Exemplo simplificado de workflow GitHub Actions:
# .github/workflows/build-multiarch.yml
name: Build Multi-Arch Image
on: push
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: docker/setup-qemu-action@v3
- uses: docker/setup-buildx-action@v3
- name: Build and push
uses: docker/build-push-action@v5
with:
platforms: linux/amd64,linux/arm64
push: true
tags: myapp:latest
Para builds pesados, preferiram runners Graviton nativos para evitar o overhead do QEMU. As labels dos runners espelham as do x86, então a troca é só mudar x64 para arm64.
2. NodePools Karpenter com Taints
Substituíram Managed Node Groups fixos por Karpenter para provisionamento dinâmico. Os NodePools Graviton usam taints para evitar agendamento acidental:
# NodePool com taint
apiVersion: karpenter.sh/v1beta1
kind: NodePool
metadata:
name: graviton
spec:
template:
spec:
requirements:
- key: kubernetes.io/arch
operator: In
values: ["arm64"]
taints:
- key: workload-type
value: graviton
effect: NoSchedule
As cargas precisam optar explicitamente com toleration e node selector. Isso garante que só apps prontos para Arm caiam nos nós Graviton.
3. Rollout Faseado
Começaram com serviços de plataforma (Karpenter, Prometheus, ferramentas operacionais) antes de deixar os times de aplicação optarem. Imagens dual-arch tornaram o rollback trivial: reverta o commit no Git e o ArgoCD reconcilia o cluster de volta para x86.
Resultados e Lições Aprendidas
- US$ 600 mil de economia anualizada em infraestrutura
- 57% de redução no consumo de CPU para o ingress controller NGINX
- 40% mais eficiência de preço-desempenho
- 65%+ das cargas de produção agora em Graviton
Lições principais:
- Use taints, selectors e tolerations para agendamento opt-in.
- Mantenha imagens multi-arch com uma única tag de manifesto para rollback fácil.
- Valide primeiro na infraestrutura compartilhada.
- Evite QEMU para builds pesados; use nativo ou compilação cruzada.
Limitações e Próximos Passos
Limitações:
- Nem todas as dependências têm suporte a Arm; algumas podem exigir bibliotecas alternativas.
- Builds emulados podem ser bem mais lentos, impactando a produtividade do time.
- Taints adicionam complexidade; os times precisam entender as restrições de agendamento.
Próximos passos:
- Explore Graviton para cargas stateful (bancos de dados, caches) com benchmarks cuidadosos.
- Considere toolchains de compilação cruzada (ex.:
docker buildxcom--platforme cross-compilers) para reduzir ainda mais os tempos de build. - Monitore custo e desempenho continuamente com AWS Cost Explorer e métricas Prometheus.
Para saber mais sobre agentes de codificação com IA para empresas, confira Claude Opus 4.6 no Azure. E se você está se preparando para entrevistas de data science, veja nosso guia de entrevistas comportamentais.

Mergulho Fundo: Estratégias de Build Multi-Arquitetura
A equipe da BMW avaliou duas abordagens principais para builds multi-arquitetura:
| Abordagem | Prós | Contras | Melhor Para |
|---|---|---|---|
| Emulada (QEMU) | Runner único, pipeline simples | Lenta para builds pesados, maior uso de CPU | Apps simples, testes rápidos |
| Nativa (runners Graviton) | Rápida, expõe problemas de arquitetura cedo | Requer runners Arm dedicados | Builds complexos, dependências grandes |
Suportaram ambas via workflows reutilizáveis do GitHub Actions. Dockerfiles usam QEMU por padrão para evitar runners extras, mas times com builds pesados podem optar por runners Graviton nativos.
Exemplo de código: build nativo em runner Graviton
# .github/workflows/build-native-arm.yml
name: Build on Graviton
on: push
jobs:
build-arm:
runs-on: [self-hosted, linux, arm64] # Runner Graviton
steps:
- uses: actions/checkout@v4
- name: Build and push
run: |
docker build -t myapp:arm64 .
docker push myapp:arm64
create-manifest:
needs: build-arm
runs-on: ubuntu-latest
steps:
- name: Create and push manifest
run: |
docker manifest create myapp:latest \
--amend myapp:amd64 \
--amend myapp:arm64
docker manifest push myapp:latest
Esse processo em duas etapas constrói cada arquitetura separadamente e depois as combina em uma manifest list. O resultado: uma única tag myapp:latest que funciona em nós x86 e Arm.

Principais Aprendizados para Sua Migração
O sucesso da BMW veio de reduzir o atrito para os times de aplicação. Veja o que você pode replicar:
- Comece com serviços de plataforma para validar compatibilidade e criar padrões de rollback.
- Use taints e tolerations para tornar a adoção do Graviton opt-in, não forçada.
- Automatize builds multi-arch com workflows CI/CD reutilizáveis.
- Monitore custo e desempenho de perto; os benefícios do Graviton são reais, mas dependem da carga.
Aviso: Não assuma que todas as cargas vão se beneficiar. Faça benchmarks antes de commitar. Alguns apps legados podem ter dependências ocultas de x86.
Leitura adicional:
- Guia de Introdução ao AWS Graviton
- Documentação do Karpenter
- Builds multi-plataforma com Docker Buildx

Conclusão
A migração da BMW Group para AWS Graviton é uma aula de adoção incremental e de baixo risco. Ao focar na experiência do desenvolvedor (builds duplos, agendamento opt-in) e manter um caminho de rollback, alcançaram economias significativas sem sacrificar a confiabilidade. Se você roda Kubernetes na AWS, vale a pena avaliar o Graviton—comece pequeno, meça e escale.
Artigos relacionados: