How to Install Minikube on Ubuntu (Complete Guide)

To install Minikube on Ubuntu, install Docker Engine, add your user to the docker group, download the Minikube binary with curl, then run minikube start --driver=docker as a normal user. It takes about ten minutes on a supported LTS release, and the one rule that trips up most people is never prefixing that start command with sudo.

Ubuntu is the nicest place to run Minikube. The Docker driver talks to a native Docker Engine with no VM in the middle, so clusters start in seconds instead of minutes, and two addons that are Linux-only, ingress and ingress-dns, actually work. The current Minikube release is v1.38.1 and it defaults to Kubernetes v1.36.2.

Step 1: Check your release and your resources

Minikube’s documented minimums are two CPU cores, 2 GB of free memory, 20 GB of free disk and an internet connection. Confirm what you are running:

lsb_release -a
nproc
free -h
df -h /
grep -c vmx /proc/cpuinfo || grep -c svm /proc/cpuinfo

Pick an LTS. There is no reason to run a local Kubernetes lab on an interim release that expires in nine months.

Step 2: Install Docker Engine

Do not use the docker.io package from the Ubuntu archive. It lags behind and you will hit driver bugs Minikube has long since fixed upstream. Use Docker’s own repository, following the official Docker Engine install guide:

sudo apt update
sudo apt install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF

sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Docker has moved to the deb822 .sources format, so if you are copying an older tutorial that writes to /etc/apt/sources.list.d/docker.list, it is out of date. Confirm the daemon is alive and set it to start on boot:

sudo systemctl enable docker.service
sudo systemctl enable containerd.service
sudo docker run hello-world

Step 3: Add your user to the docker group

Minikube’s Docker driver refuses to run as root. If you try, it exits with DRV_AS_ROOT: The "docker" driver should not be used with root privileges. The fix is to give your normal user access to the Docker socket:

sudo groupadd docker
sudo usermod -aG docker $USER
newgrp docker
docker run hello-world

newgrp docker only fixes the current shell. Log out and back in (or reboot) so every new session inherits the group. On a desktop session, a full logout is the reliable option.

Step 4: Install kubectl

Three ways to get kubectl on Ubuntu, and they are genuinely different in how they behave over time.

The binary route, which is what I use:

curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl.sha256"
echo "$(cat kubectl.sha256)  kubectl" | sha256sum --check
sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
kubectl version --client

The apt repository, which pins a minor version in the URL. Kubernetes 1.36 is the current stable line:

sudo apt-get install -y apt-transport-https ca-certificates curl gnupg
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.36/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.36/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list
sudo apt-get update && sudo apt-get install -y kubectl

Whichever you pick, keep kubectl within one minor version of the cluster. A v1.36 client is supported against v1.35, v1.36 and v1.37 control planes, which comfortably covers Minikube’s default.

Step 5: Install Minikube

Two supported options on x86-64. The generic binary is the one to use if you want minikube to update independently of apt:

curl -LO https://github.com/kubernetes/minikube/releases/latest/download/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube && rm minikube-linux-amd64
minikube version

Or the Debian package:

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube_latest_amd64.deb
sudo dpkg -i minikube_latest_amd64.deb

On arm64, swap amd64 for arm64 in both URLs. There is no snap package worth recommending.

Step 6: Start the cluster

minikube start --driver=docker
minikube config set driver docker

# More headroom on a bigger machine
minikube start --driver=docker --cpus=4 --memory=8g

Notice there is no sudo. That is deliberate and it matters enough to spell out.

Why you must not use sudo with the Docker driver

Running sudo minikube start --driver=docker fails on purpose. Minikube would create the cluster as root, write its state into /root/.minikube, and write a kubeconfig into /root/.kube/config. Your normal user would then run kubectl get nodes, read ~/.kube/config, find nothing, and you would spend an hour confused. Minikube’s DRV_AS_ROOT guard exists to stop that split-brain before it happens. If you truly need it, --force overrides the check, and you will regret it.

Step 7: Verify and enable addons

minikube status
kubectl get nodes
kubectl cluster-info

minikube addons list
minikube addons enable metrics-server
minikube addons enable ingress
minikube dashboard --url

The ingress and ingress-dns addons only function on Linux, which is one of the real advantages of running Minikube on Ubuntu rather than on Minikube on Windows 10. Enable metrics-server before you open the dashboard or its CPU and memory graphs stay blank and kubectl top pods errors out.

Step 8: Expose a service

kubectl create deployment web --image=nginx
kubectl expose deployment web --type=NodePort --port=80
kubectl get svc

minikube service web --url
minikube service web

NodePort services get a port in the 30000–32767 range on the node IP, which you can read with minikube ip. minikube service runs as a foreground process that tunnels to the cluster, so it needs its own terminal window and dies when you press Ctrl-C.

Services of type LoadBalancer are different. Minikube has no cloud load balancer to call, so the external IP stays <pending> forever until you run:

minikube tunnel

That creates a network route on the host to the cluster’s service CIDR, so it asks for your password. Keep it running in a separate terminal for as long as you need the LoadBalancer. This is exactly the mechanism you will need again when you install Helm in Minikube and a chart’s service defaults to LoadBalancer.

Step 9: Clean up

minikube stop            # keep the cluster, free the RAM
minikube start           # bring it back
minikube delete          # destroy this cluster
minikube delete --all --purge   # destroy everything, including ~/.minikube
docker system prune -a   # reclaim the image cache

Troubleshooting

“permission denied while trying to connect to the Docker daemon socket”

Your user is not in the docker group, or the group membership has not taken effect in this shell. Check with groups. If docker is missing, run sudo usermod -aG docker $USER and then log out and back in. If groups shows docker but the error persists, the daemon is not running: sudo systemctl status docker. Do not fix this with sudo; the driver will reject it.

Cgroup v2 problems

Ubuntu 22.04 and later boot with cgroup v2 as the unified hierarchy, which Minikube and Docker handle fine. Where it goes wrong is on trimmed-down kernels and some virtualized hosts where the memory or CPU controllers are not delegated. You will see a warning along the lines of “Your cgroup does not allow setting memory” and Minikube will ignore your --memory value. Check what is available:

cat /sys/fs/cgroup/cgroup.controllers
stat -fc %T /sys/fs/cgroup   # cgroup2fs means cgroup v2

If memory is absent from the controller list, the cluster will still start but resource limits will not be enforced. On a Raspberry Pi or a custom kernel you may need to add cgroup parameters to the boot command line. On a normal Ubuntu LTS install this is not something you will hit.

Minikube fails on a small VPS

This is the most common Ubuntu failure and it is not a bug. A 1 GB or 2 GB VPS cannot host a Kubernetes control plane with any room left over. Minikube’s floor is 2 GB of free memory on top of the OS, and the apiserver alone will happily eat most of that. Symptoms are the apiserver crash-looping, the node flipping to NotReady, or the start timing out at “Verifying Kubernetes components”.

free -h
minikube logs --problems
minikube start --driver=docker --alsologtostderr --v=2

Give the box 4 GB of RAM and 2 vCPUs and the problem disappears. Adding swap is a workaround at best. If you want a single-node cluster on a genuinely small VPS, k3s is the honest recommendation instead of Minikube.

The cluster works but pulls fail

Check the node can reach the registry, then look at the actual pod event. kubectl describe pod <name> tells you whether it is ImagePullBackOff, ErrImagePull, or an authentication failure. On a corporate network, export HTTP_PROXY, HTTPS_PROXY and NO_PROXY before minikube start so the in-cluster components inherit them too.

Frequently asked questions

Do I need to install Minikube on Ubuntu with sudo?

You need sudo to copy the binary into /usr/local/bin and to install Docker, but not to run Minikube. minikube start --driver=docker must run as your normal user. Minikube rejects the Docker driver under root with a DRV_AS_ROOT error precisely to prevent a broken kubeconfig.

Which Ubuntu version should I use for Minikube?

Pick a current LTS. Ubuntu 24.04 Noble is the safe default, 26.04 Resolute is fine and supported by Docker’s repository, and 22.04 Jammy still works until May 2027. Avoid 20.04, which left standard support in May 2025, and avoid interim releases for anything you plan to keep.

Can I run Minikube on Ubuntu Server without a desktop?

Yes. Everything here works headless. The only differences are that minikube dashboard cannot open a browser, so use minikube dashboard --url and forward the port over SSH, and minikube service likewise prints a URL rather than launching anything.

Does Minikube on Ubuntu need VirtualBox or KVM?

No. The Docker driver needs no hypervisor at all, which is why it is the default recommendation on Linux. KVM2 and QEMU drivers exist if you want stronger isolation between the cluster and the host, but they are slower to start and add a layer you probably do not need locally.

How do I access a database or search service running in Minikube?

Use kubectl port-forward svc/<name> 9200:9200 for quick access, a NodePort service for something semi-permanent, or minikube tunnel for a LoadBalancer. Local clusters are a fine place to prototype, but for a stateful search service you actually depend on, a managed host is less work than a Minikube PVC. Our guide to installing Elasticsearch on Cloudways covers that path.

How do I upgrade Minikube later?

Download the latest binary and reinstall it over the old one with the same sudo install command, or sudo dpkg -i the new .deb. Existing clusters keep running. To move an existing cluster to a newer Kubernetes version, use minikube start --kubernetes-version=v1.36.2, and delete and recreate if the in-place upgrade misbehaves.

Wrapping up

The whole job is four commands and one habit. Install Docker from Docker’s repository rather than the Ubuntu archive, put your user in the docker group, drop the Minikube binary into /usr/local/bin, and run minikube start --driver=docker without sudo. Everything that goes wrong afterwards is almost always the group membership, the memory ceiling, or a forgotten minikube tunnel.

Give the machine 4 GB of RAM if you can. Minikube’s 2 GB minimum is real but it is a floor, not a target, and the difference between a cluster that limps and a cluster that feels instant is a couple of gigabytes. Once it is up, add Helm and stop hand-writing YAML.