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 buildx com --platform e 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.

Cloud architecture diagram showing AWS Graviton and x86 node pools in EKS cluster for connected vehicle platform Development Concept Image

Mergulho Fundo: Estratégias de Build Multi-Arquitetura

A equipe da BMW avaliou duas abordagens principais para builds multi-arquitetura:

AbordagemPrósContrasMelhor Para
Emulada (QEMU)Runner único, pipeline simplesLenta para builds pesados, maior uso de CPUApps simples, testes rápidos
Nativa (runners Graviton)Rápida, expõe problemas de arquitetura cedoRequer runners Arm dedicadosBuilds 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.

CI/CD pipeline with multi-architecture builds using GitHub Actions and Docker Buildx for Arm and x86 Software Concept Art

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:

BMW connected vehicle fleet powered by AWS Graviton achieving cost savings and performance improvements IT Technology Image

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:

Este conteúdo foi elaborado com o auxílio de ferramentas de IA, com base em fontes confiáveis, e revisado pela nossa equipe editorial antes da publicação. Não substitui o aconselhamento de um profissional especializado.