ARM64 Docker builds: the seven errors everyone hits first

1. exec format error

The image was built for amd64 and the host is arm64. Nothing inside the container will ever start.

Build on the ARM machine itself, or cross-build explicitly:

docker build --platform linux/arm64 -t myapp .
# or, for both architectures
docker buildx build --platform linux/amd64,linux/arm64 -t myapp --push .

2. Painfully slow builds under emulation

Building arm64 images on an x86 laptop uses QEMU emulation, which can be five to twenty times slower. Building on the Oracle VM instead is usually faster than emulating locally — which is exactly why Cheaploy builds on your instance.

3. No prebuilt Python wheel

Most major packages now ship aarch64 wheels. When one does not, pip falls back to compiling from source and fails on a missing toolchain. Install the build dependencies, or pick a slim variant with them available:

RUN apt-get update && apt-get install -y --no-install-recommends \
      build-essential python3-dev libffi-dev \
 && rm -rf /var/lib/apt/lists/*

4. Node native modules

bcrypt, sharp, canvas and better-sqlite3 compile native code. On Alpine ARM64 they need build-base plus the relevant -dev packages; on Debian slim they usually just work.

Where possible, prefer pure-JS alternatives (bcryptjs) or the platform-specific optional dependencies published by the maintainers.

RUN apk add --no-cache build-base python3 vips-dev

5. Base images without an arm64 tag

Some smaller community images are amd64 only. Check before you commit to one:

docker manifest inspect <image> | grep architecture

6. Out of memory during the build

Webpack, Turbopack, Vite and the Strapi admin build all spike memory. Give the build 4 GB or more, and never run it on the 1 GB AMD micro instance. Raising Node's heap helps on tight shapes:

ENV NODE_OPTIONS=--max-old-space-size=3072

7. Images that are far bigger than they need to be

Multi-stage builds matter more on a home connection than on a datacentre network. A Go binary in distroless is ~15 MB; a naive Node image is often 1.2 GB. Copy only build output into the final stage, use .dockerignore, and pin base image versions.

# .dockerignore
node_modules
.git
.env*
dist
coverage

Skip all of this

The free Dockerfile generator writes an ARM-ready multi-stage Dockerfile for your stack, and Cheaploy builds it on the instance so the architecture always matches.