Why BMW Bet on Arm for Connected Vehicles

BMW Connected Company manages digital services for over 24.5 million connected vehicles worldwide. In 2024, they began migrating their internal platform (Orbit) from x86 to Arm-based AWS Graviton as part of a modernization strategy. The goal: reduce costs, improve performance, and support sustainability targets.

This wasn't a simple lift-and-shift. With over 130,000 daily builds and deployments, the migration required a carefully orchestrated approach to avoid disrupting critical vehicle services. The team documented their methodology in a recent AWS Architecture Blog post (근거자료: original post).

The Migration Playbook: From CI/CD to Node Pools

1. Multi-Architecture Builds

Every container image needed to support both amd64 and arm64. The team used two approaches:

  • Emulated builds with Docker Buildx + QEMU (simple, but slower for heavy workloads)
  • Native builds on Graviton runners (faster, surfaces architecture issues early)

Both produce a manifest list (OCI image index) so a single tag works on both architectures. Here's a simplified GitHub Actions workflow snippet:

# .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

For compute-heavy builds, they preferred native Graviton runners to avoid QEMU overhead. Runner labels mirror x86 labels, so switching is as simple as changing x64 to arm64.

2. Karpenter Node Pools with Taints

They replaced fixed Managed Node Groups with Karpenter for dynamic provisioning. Graviton node pools use taints to prevent accidental scheduling:

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

Workloads must explicitly opt in with a toleration and node selector. This ensures only Arm-ready apps land on Graviton nodes.

3. Phased Rollout

They started with platform services (Karpenter, Prometheus, operational tooling) before letting application teams opt in. Dual-arch images meant rollback was trivial: revert the Git commit and ArgoCD reconciles the cluster back to x86.

Results and Lessons Learned

  • $600,000 annualized infrastructure savings
  • 57% reduction in CPU consumption for NGINX ingress controller
  • 40% better price-performance
  • 65%+ of production workloads now on Graviton

Key lessons:

  • Use taints, selectors, and tolerations for opt-in scheduling.
  • Keep multi-arch images with a single manifest tag for easy rollback.
  • Validate on shared infrastructure first.
  • Avoid QEMU for compute-heavy builds; use native or cross-compilation.

Limitations and Next Steps

Limitations:

  • Not all dependencies have Arm support; some may require alternative libraries.
  • Emulated builds can be significantly slower, impacting developer productivity.
  • Taints add complexity; teams must understand scheduling constraints.

Next steps:

  • Explore Graviton for stateful workloads (databases, caches) with careful benchmarking.
  • Consider cross-compilation toolchains (e.g., docker buildx with --platform and cross-compilers) to further reduce build times.
  • Monitor cost and performance continuously using AWS Cost Explorer and Prometheus metrics.

For more on enterprise AI coding agents, check out Claude Opus 4.6 on Azure. And if you're prepping for data science interviews, see our behavioral interview guide.

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

Deep Dive: Multi-Arch Build Strategies

BMW's team evaluated two main approaches for building multi-architecture images:

ApproachProsConsBest For
Emulated (QEMU)Single runner, simple pipelineSlow for compute-heavy builds, higher CPU usageSimple apps, quick tests
Native (Graviton runners)Fast, surfaces arch issues earlyRequires dedicated Arm runnersComplex builds, large dependencies

They supported both via GitHub Actions reusable workflows. Dockerfiles default to QEMU to avoid extra runners, but teams with heavy builds can opt for native Graviton runners.

Code example: Native build on Graviton runner

# .github/workflows/build-native-arm.yml
name: Build on Graviton
on: push
jobs:
  build-arm:
    runs-on: [self-hosted, linux, arm64]  # Graviton runner
    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

This two-step process builds each architecture separately, then combines them into a manifest list. The result: a single myapp:latest tag that works on both x86 and Arm nodes.

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

Key Takeaways for Your Migration

BMW's success hinged on reducing friction for application teams. Here's what you can replicate:

  • Start with platform services to validate compatibility and build rollback patterns.
  • Use taints and tolerations to make Graviton adoption opt-in, not forced.
  • Automate multi-arch builds with reusable CI/CD workflows.
  • Monitor cost and performance closely; Graviton benefits are real but workload-dependent.

Warning: Don't assume all workloads will benefit. Benchmark before committing. Some legacy apps may have hidden x86 dependencies.

Further reading:

BMW connected vehicle fleet powered by AWS Graviton achieving cost savings and performance improvements Coding Session Visual

Conclusion

BMW Group's migration to AWS Graviton is a masterclass in incremental, low-risk adoption. By focusing on developer experience (dual builds, opt-in scheduling) and maintaining a rollback path, they achieved significant savings without sacrificing reliability. If you're running Kubernetes on AWS, Graviton is worth evaluating—start small, measure, and scale.

Related articles:

This content was drafted using AI tools based on reliable sources, and has been reviewed by our editorial team before publication. It is not intended to replace professional advice.