¿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 buildxcon--platformy 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.

Deep Dive: Estrategias de Build Multi-Arquitectura
El equipo de BMW evaluó dos enfoques principales para builds multi-arquitectura:
| Enfoque | Pros | Contras | Mejor Para |
|---|---|---|---|
| Emulado (QEMU) | Runner único, pipeline simple | Lento para builds pesados, mayor uso de CPU | Apps simples, pruebas rápidas |
| Nativo (runners Graviton) | Rápido, expone problemas de arquitectura temprano | Requiere runners Arm dedicados | Builds 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.

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:

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: