Minikube on Apple Silicon M1/M2: ARM64 Setup Guide (2026)

Minikube on Apple Silicon M1/M2: ARM64 Setup Guide

Minikube, the tool for running a single-node Kubernetes cluster locally, can be a bit of a chameleon on Apple Silicon (M1/M2) chips, but it’s not the ARM64 architecture itself that’s the primary hurdle. The real trick is getting the right virtualization layer and ensuring your container images are built for the target architecture.

Let’s get Minikube running on your M1/M2 Mac.

1. Choose Your Driver: Virtualization is Key

Minikube needs a way to run a virtual machine (VM) on your Mac. For Apple Silicon, the native and recommended driver is virtualbox. While docker can also work, virtualbox offers a more robust and isolated Kubernetes environment.

Check Installed Drivers: First, see what drivers Minikube knows about.
```
minikube config get driver
```
If it’s not set, or set to something else, you’ll need to install VirtualBox.
Install VirtualBox: Head over to the VirtualBox website and download the latest version for macOS. Install it like any other macOS application.
Set the Driver: Once VirtualBox is installed, tell Minikube to use it.
```
minikube config set driver virtualbox
```
This command tells Minikube to use VirtualBox as its backend for creating and managing the Kubernetes VM.

2. Install Minikube

If you don’t have Minikube installed yet, the easiest way is via Homebrew.

Install Minikube (if needed):
```
brew install minikube
```
Homebrew handles downloading the correct ARM64 binary for Minikube.

3. Start Your Cluster

Now, let’s spin up your local Kubernetes cluster.

Start Minikube:
```
minikube start --driver=virtualbox --cpus=4 --memory=8192mb
```
- --driver=virtualbox: Explicitly tells Minikube to use the VirtualBox driver.
- --cpus=4: Allocates 4 CPU cores to the Minikube VM. Adjust this based on your Mac’s capabilities and what you plan to run.
- --memory=8192mb: Allocates 8GB of RAM to the Minikube VM. Again, adjust as needed.
This command will download the necessary Minikube ISO, create a VirtualBox VM, install Kubernetes within it, and configure kubectl to point to this new cluster.

4. Verify Your Cluster

Once minikube start completes without errors, check that everything is running.

Check Cluster Status:
```
minikube status
```
You should see output indicating that the VM and Kubernetes are running.
Check Node Status:
```
kubectl get nodes
```
You should see one node, named minikube, in a Ready state.

5. Working with ARM64 Container Images

This is where many M1/M2 users hit a snag. If you try to deploy an application whose container image is built for amd64 (Intel architecture), it won’t run on your ARM64 Minikube node.

Check Image Architecture: When you pull or build an image, ensure it’s for arm64. Docker Desktop on M1/M2 Macs defaults to building and pulling arm64 images. You can verify an image’s architecture using docker manifest inspect <image_name>:<tag>. Look for architecture: "arm64".
Building Images for ARM64: If you’re building your own Docker images, Docker Desktop on Apple Silicon will automatically build for arm64. If you encounter issues, ensure your Dockerfile doesn’t have architecture-specific instructions that might interfere.
Using minikube image load: If you have an amd64 image you must use (though this is generally discouraged for native ARM64 development), Minikube can attempt to load it. However, this won’t make it run on the ARM64 node; it’s more for scenarios where you might be running an amd64 VM within Minikube (which is complex and not typical). For native ARM64 development, always aim for arm64 images.
```
minikube image load my-arm64-app:latest
```
This command loads the specified image into Minikube’s Docker daemon, making it available for pods to pull.

6. Common Pitfalls and Solutions

"VT-x/AMD-V hardware acceleration is not enabled": This is a common error if you try to use a driver like kvm2 (which is not supported on macOS) or if VirtualBox isn’t configured correctly. Ensure you’re using the virtualbox driver and that VirtualBox is installed and functional.
Pods Stuck in ImagePullBackOff: This almost always means the container image you’re trying to pull is not available for the arm64 architecture of your Minikube node. Double-check the image tag and ensure it’s built for arm64.
Slow Performance: If your cluster feels sluggish, it’s likely due to insufficient CPU or memory allocated. Try minikube start --cpus=6 --memory=12288mb (or higher, depending on your Mac’s specs).
Networking Issues: Occasionally, Minikube’s networking can get confused. Running minikube delete and then minikube start can resolve persistent networking problems by recreating the VM from scratch.

7. Next Steps

Once your Minikube cluster is up and running, you’ll likely want to explore deploying your applications. The next logical step is to learn about Kubernetes Ingress, which allows you to expose your services to the outside world.