¿Por qué BMW apostó por Arm para Vehículos Conectados?

BMW Connected Company gestiona servicios digitales para más de 24.5 millones de vehículos conectados en todo el mundo. En 2024, comenzaron a migrar su plataforma interna (Orbit) de x86 a AWS Graviton (basado en Arm) como parte de una estrategia de modernización. El objetivo: reducir costos, mejorar rendimiento y apoyar metas de sostenibilidad.

No fue un simple lift-and-shift. Con más de 130,000 builds y despliegues diarios, la migración requirió un enfoque cuidadosamente orquestado para no interrumpir servicios críticos de los vehículos. El equipo documentó la metodología en un post reciente del AWS Architecture Blog (fuente: post original).

El Playbook de Migración: De CI/CD a Node Pools

1. Builds Multi-Arquitectura

Cada imagen de contenedor necesitaba soportar amd64 y arm64. El equipo usó dos enfoques:

  • Builds emulados con Docker Buildx + QEMU (simple, pero más lento para cargas pesadas)
  • Builds nativos en runners Graviton (más rápido, expone problemas de arquitectura temprano)

Ambos producen una manifest list (índice de imagen OCI) para que una sola etiqueta funcione en ambas arquitecturas. Ejemplo simplificado de workflow de 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, prefirieron runners Graviton nativos para evitar el overhead de QEMU. Las etiquetas de los runners reflejan las de x86, así que cambiar es solo modificar x64 por arm64.

2. NodePools de Karpenter con Taints

Reemplazaron los Managed Node Groups fijos por Karpenter para aprovisionamiento dinámico. Los NodePools Graviton usan taints para evitar programación accidental:

# NodePool con 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

Las cargas deben optar explícitamente con toleration y node selector. Esto asegura que solo apps listas para Arm caigan en nodos Graviton.

3. Despliegue por Fases

Comenzaron con servicios de plataforma (Karpenter, Prometheus, herramientas operativas) antes de dejar que los equipos de aplicación optaran. Las imágenes dual-arch hicieron el rollback trivial: revierte el commit en Git y ArgoCD reconcilia el clúster de vuelta a x86.

Resultados y Lecciones Aprendidas

  • $600,000 de ahorro anualizado en infraestructura
  • 57% de reducción en consumo de CPU para el ingress controller NGINX
  • 40% mejor precio-rendimiento
  • 65%+ de las cargas de producción ahora en Graviton

Lecciones clave:

  • Usa taints, selectors y tolerations para programación opt-in.
  • Mantén imágenes multi-arch con una sola etiqueta de manifiesto para rollback fácil.
  • Valida primero en infraestructura compartida.
  • Evita QEMU para builds pesados; usa nativo o compilación cruzada.

Limitaciones y Próximos Pasos

Limitaciones:

  • No todas las dependencias tienen soporte para Arm; algunas pueden requerir bibliotecas alternativas.
  • Los builds emulados pueden ser mucho más lentos, impactando la productividad del equipo.
  • Los taints agregan complejidad; los equipos deben entender las restricciones de programación.

Próximos pasos:

  • Explora Graviton para cargas stateful (bases de datos, cachés) con benchmarks cuidadosos.
  • Considera toolchains de compilación cruzada (ej.: docker buildx con --platform y cross-compilers) para reducir aún más los tiempos de build.
  • Monitorea costo y rendimiento continuamente con AWS Cost Explorer y métricas de Prometheus.

Para más sobre agentes de codificación con IA para empresas, checa Claude Opus 4.6 en Azure. Y si estás preparando entrevistas de data science, ve nuestra guía de entrevistas conductuales.

Cloud architecture diagram showing AWS Graviton and x86 node pools in EKS cluster for connected vehicle platform Coding Session Visual

Deep Dive: Estrategias de Build Multi-Arquitectura

El equipo de BMW evaluó dos enfoques principales para builds multi-arquitectura:

EnfoqueProsContrasMejor Para
Emulado (QEMU)Runner único, pipeline simpleLento para builds pesados, mayor uso de CPUApps simples, pruebas rápidas
Nativo (runners Graviton)Rápido, expone problemas de arquitectura tempranoRequiere runners Arm dedicadosBuilds complejos, dependencias grandes

Soportaron ambos vía workflows reutilizables de GitHub Actions. Los Dockerfiles usan QEMU por defecto para evitar runners extra, pero equipos con builds pesados pueden optar por runners Graviton nativos.

Ejemplo de código: build nativo en 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

Este proceso en dos pasos construye cada arquitectura por separado y luego las combina en una manifest list. El resultado: una sola etiqueta myapp:latest que funciona en nodos x86 y Arm.

CI/CD pipeline with multi-architecture builds using GitHub Actions and Docker Buildx for Arm and x86 Developer Related Image

Aprendizajes Clave para Tu Migración

El éxito de BMW vino de reducir la fricción para los equipos de aplicación. Esto es lo que puedes replicar:

  • Comienza con servicios de plataforma para validar compatibilidad y crear patrones de rollback.
  • Usa taints y tolerations para hacer la adopción de Graviton opt-in, no forzada.
  • Automatiza builds multi-arch con workflows CI/CD reutilizables.
  • Monitorea costo y rendimiento de cerca; los beneficios de Graviton son reales pero dependen de la carga.

Advertencia: No asumas que todas las cargas se beneficiarán. Haz benchmarks antes de comprometerte. Algunas apps legacy pueden tener dependencias ocultas de x86.

Lectura adicional:

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

Conclusión

La migración de BMW Group a AWS Graviton es una clase magistral de adopción incremental y de bajo riesgo. Al enfocarse en la experiencia del desarrollador (builds duales, programación opt-in) y mantener un camino de rollback, lograron ahorros significativos sin sacrificar la confiabilidad. Si corres Kubernetes en AWS, vale la pena evaluar Graviton—empieza pequeño, mide y escala.

Artículos relacionados:

Este contenido fue redactado con la asistencia de herramientas de IA, basándose en fuentes confiables, y fue revisado por nuestro equipo editorial antes de su publicación. No reemplaza el asesoramiento de un profesional especializado.