Running Kubernetes Locally: kind vs minikube vs Docker Desktop
Learn how to set up Local Kubernetes with kind, minikube and Docker Desktop, deploy an NGINX application, and compare the tools through hands-on examples.

✍️ Translate this blog into Hindi, Tamil or Telugu
1. Introduction
Kubernetes is widely used to deploy, manage and scale containerized applications. But learning Kubernetes does not mean you must immediately create a cluster in AWS, Azure or Google Cloud.
Local Kubernetes makes it possible to learn and practise Kubernetes on your own computer without creating a cloud cluster. Tools like kind, minikube and Docker Desktop provide different ways to run Kubernetes locally.
I wanted to understand how these tools differ in practice, so I deployed the same NGINX application using kind and minikube and compared the results.
🛍️✨ From the author · ByteStore1:1 DevOps Project & Learning Discussionโน500View offer →Let's explore how each tool works, how to install it on different operating systems, and how to deploy a simple application.
Three popular options are:
kindย - Kubernetes IN Docker.
minikubeย - A tool for running a local Kubernetes cluster.
Docker Desktop Kubernetesย - Kubernetes integrated into Docker Desktop.
Each tool provides a different way to run Kubernetes locally. The choice depends on what you want to practise, how you prefer to work and the environment available on your computer.
I will explore their installation options, deploy the same NGINX application using kind and minikube, and share the results of my hands-on comparison.
2. Why do we need local Kubernetes?
Imagine you are learning how to drive.
You do not need to buy a car or drive on a busy highway on your first day. You can first practise in a controlled environment.
Local Kubernetes provides a similar learning environment.
You can practise:
Creating Kubernetes clusters.
Deploying applications using Pods and Deployments.
Exposing applications using Services.
Working with ConfigMaps and Secrets.
Understanding namespaces.
Practising scaling and troubleshooting.
Learning Kubernetes commands using kubectl.
The biggest advantage is that you can practise on your own computer without paying for a cloud Kubernetes cluster.
However, local Kubernetes is primarily for learning, development and testing. It does not automatically reproduce every feature or operational challenge of a production cluster.
3. Understanding the three local Kubernetes options
3.1 kind - Kubernetes IN Docker
kind stands for Kubernetes IN Docker.
It runs Kubernetes cluster nodes as Docker containers.
Think of Docker as a building and kind as creating small rooms inside that building. Each room represents a Kubernetes node.
You can create a Kubernetes cluster without creating separate virtual machines.
Why use kind?
Useful for learning Kubernetes.
Supports multi-node clusters.
Useful for testing Kubernetes manifests.
Useful for CI pipelines and automated testing.
Uses Docker containers as cluster nodes.
Example command:
kind create cluster --name local-demoThis creates a local Kubernetes cluster named local-demo.
3.2 minikube
minikube is a tool that creates and manages a local Kubernetes cluster.
It can run using different drivers, including Docker and virtual machines, depending on your operating system and configuration.
Think of minikube as a small Kubernetes practice environment on your computer.
Why use minikube?
Useful for learning Kubernetes fundamentals.
Supports Kubernetes features and add-ons.
Provides commands to manage the local cluster.
Can run with Docker as its driver.
Suitable for local application development and testing.
Example command:
minikube start --driver=dockerThis starts a local Kubernetes cluster using Docker.
3.3 Docker Desktop Kubernetes
Docker Desktop is a desktop application that provides Docker tools on Windows and macOS. It also offers Kubernetes integration.
When Kubernetes is enabled, Docker Desktop creates and manages a local Kubernetes cluster.
Think of it as having Docker and a local Kubernetes learning environment available through one desktop application.
Why use Docker Desktop Kubernetes?
Convenient for developers already using Docker Desktop.
Provides a graphical interface for managing Docker.
Allows you to practise Kubernetes locally.
Avoids installing a separate Kubernetes tool such as kind or minikube for its integrated cluster.
The exact Kubernetes options and settings can vary between Docker Desktop versions.
Important: This article explains Docker Desktop Kubernetes, but my hands-on comparison below was performed using kind and minikube. I have not included Docker Desktop Kubernetes as a personally tested result.
4. Before installation: Which operating system are you using?
The installation commands depend on your operating system.
Follow only the installation section that matches your computer. Do not run all four sections.
| Your environment | Where to run the commands |
|---|---|
| Windows | PowerShell |
| Windows with WSL2 Ubuntu | Docker Desktop on Windows; Kubernetes CLI tools inside Ubuntu |
| macOS | Terminal |
| Ubuntu/Linux | Linux Terminal |
You do not need to install these tools inside your application project folder. They are command-line tools that you can use from different project directories.
4.1 Windows installation - PowerShell
Open PowerShell on Windows.
First, install Docker Desktop.
Official installation guide:
docs.docker.com/desktop/setup/install/windows-install/
After installing Docker Desktop:
Open Docker Desktop.
Make sure Docker Desktop is running.
If you use the WSL2 backend, configure it in Docker Desktop settings.
Open PowerShell and install the Kubernetes tools.
Install kubectl:
winget install -e --id Kubernetes.kubectlInstall kind:
winget install Kubernetes.kindInstall minikube:
winget install Kubernetes.minikubeIf a package ID is not found, check the available package name using:
winget search kubectl
winget search kind
winget search minikubeClose and reopen PowerShell if necessary, then verify:
docker --version
kubectl version --client
kind version
minikube version
docker info4.2 Windows installation - WSL2 with Ubuntu
This is the setup I used for my hands-on testing.
If you use Windows with WSL2, there are two places to work:
Windows: Install and run Docker Desktop.
Ubuntu terminal inside WSL2: Install and use kubectl, kind and minikube.
You do not need to install a separate Docker Engine inside Ubuntu when Docker Desktop WSL integration is providing Docker.
Step 1: Install Docker Desktop on Windows
Download Docker Desktop:
docs.docker.com/desktop/setup/install/windows-install/
Open Docker Desktop and enable Ubuntu under:
Settings โ Resources โ WSL Integration
Make sure Docker Desktop is running.
Step 2: Open Ubuntu
Open Ubuntu from the Windows Start menu.
Check whether Docker is available:
docker --version
docker infoIf Docker is working, continue.
Step 3: Install kubectl inside Ubuntu
sudo snap install kubectl --classicStep 4: Install kind inside Ubuntu
For an x86-64 Linux environment:
curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.33.0/kind-linux-amd64
chmod +x ./kind
sudo mv ./kind /usr/local/bin/kindStep 5: Install minikube inside Ubuntu
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-amd64Step 6: Verify the installations
Run these commands in Ubuntu:
docker --version
kubectl version --client
kind version
minikube version
docker infoIf these commands return version information and Docker information, your tools are installed.
Remember: PowerShell commands and Ubuntu commands are not interchangeable. When using this setup, run the Docker Desktop installation on Windows and the Kubernetes CLI installation commands inside Ubuntu.
4.3 macOS installation - Terminal
Open the Terminal application on your Mac.
Step 1: Install Docker Desktop
Choose the correct installer for your Mac's processor: Apple silicon or Intel.
Official guide:
docs.docker.com/desktop/setup/install/mac-install/
Install and open Docker Desktop.
Step 2: Install Homebrew if it is not already installed
Official website: Goto this brew.sh website
brew.sh
Follow the installation instructions provided there.
Step 3: Install kubectl
brew install kubectlStep 4: Install kind
brew install kindStep 5: Install minikube
brew install minikubeStep 6: Verify the installations
docker --version
kubectl version --client
kind version
minikube version
docker info4.4 Ubuntu/Linux installation - Terminal
Open your Linux terminal.
The following commands are for Ubuntu on an x86-64 system.
Step 1: Install Docker Engine
Follow the official Docker Engine installation instructions for Ubuntu:
docs.docker.com/engine/install/ubuntu/
After installation, verify Docker:
docker --version
sudo docker infoIf you want to run Docker without typing sudo each time, follow Docker's official post-installation instructions. Be aware that membership in the Docker group grants powerful privileges on the system.
Step 2: Install kubectl
sudo snap install kubectl --classicStep 3: Install kind
curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.33.0/kind-linux-amd64
chmod +x ./kind
sudo mv ./kind /usr/local/bin/kindStep 4: Install minikube
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-amd64Step 5: Verify the installations
docker --version
kubectl version --client
kind version
minikube version
docker info4.5 Official installation references
Installation instructions and supported options can change as new versions are released. Always check the official documentation before installing.
- Kubernetes tools: kubernetes.io/docs/tasks/tools/
- kind quick start: kind.sigs.k8s.io/docs/user/quick-start/
- minikube installation: minikube.sigs.k8s.io/docs/start/
- Docker Desktop: docs.docker.com/get-started/get-docker/
5. My local testing environment
I performed the hands-on testing on a Windows computer using WSL2 with Ubuntu 24.04.4 LTS and Docker Desktop.
I already had the required tools installed, so I verified their versions rather than reinstalling them.
My environment was:
| Component | Version |
|---|---|
| Operating system | Ubuntu 24.04.4 LTS on WSL2 |
| Docker CLI | 29.5.3 |
| kubectl client | v1.35.0 |
| kind | v0.26.0 |
| minikube | v1.38.1 |
| kind Kubernetes cluster | v1.32.0 |
| minikube Kubernetes cluster | v1.35.1 |
I used the same simple NGINX application in both clusters so that I could compare the deployment and access experience.
A version compatibility detail: My kubectl client was v1.35.0, while the kind cluster was running Kubernetes v1.32.0. That is a three-minor-version difference. Although the commands worked in my test, this combination is outside Kubernetes' supported kubectl version-skew policy.
Kubernetes recommends that kubectl be within one minor version of the kube-apiserver. For example, a v1.35 kubectl client should normally be used with a Kubernetes API server running v1.34, v1.35 or v1.36.
My minikube cluster was running Kubernetes v1.35.1, which was within the supported range for my v1.35.0 kubectl client.
For your own setup, check the Kubernetes version of your cluster and select a compatible kubectl version.
6. Creating a Kubernetes cluster using kind
Now let's create a local Kubernetes cluster using kind.
Open your terminal.
Step 1: Create a cluster
For a new cluster, run:
kind create cluster --name local-kind-demoThis creates a Kubernetes cluster named local-kind-demo.
Step 2: Check the cluster
kubectl cluster-info --context kind-local-kind-demoThis checks whether the Kubernetes control plane is reachable.
Step 3: Check the nodes
kubectl get nodes --context kind-local-kind-demoExpected result: The node should eventually show Ready.

My hands-on environment: I used an existing kind cluster named kubehealer-demo, with the context kind-kubehealer-demo. Its Kubernetes node was Ready and was running Kubernetes v1.32.0.
7. Creating a Kubernetes cluster using minikube
Next, let's create a local Kubernetes cluster using minikube.
Step 1: Start minikube
minikube start --driver=dockerThis starts a local Kubernetes cluster using Docker as the driver.
Step 2: Check the cluster status
minikube statusYou should see the host, kubelet and API server running, with kubeconfig configured.

Step 3: Check the Kubernetes node
kubectl get nodes --context=minikubeExpected result: The node should eventually show Ready.
My hands-on environment: My minikube cluster was running Kubernetes v1.35.1. Its node was Ready.
8. Deploying the same NGINX application on both clusters
Creating a Kubernetes cluster is only the first step. Let's deploy an application and access it.
We will use NGINX, a popular web server.
The same application will be deployed in both clusters.
8.1 Deploy NGINX on kind
For my existing kind cluster, I used the context kind-kubehealer-demo.
Step 1: Create a namespace
kubectl create namespace blog-demo --context=kind-kubehealer-demoA namespace helps organize Kubernetes resources.

Step 2: Create a Deployment
kubectl create deployment nginx-blog --image=nginx --replicas=1 --namespace=blog-demo --context=kind-kubehealer-demoThis creates a Deployment named nginx-blog with one NGINX replica.
Step 3: Check the Pod
kubectl get pods -n blog-demo --context=kind-kubehealer-demoWait until the Pod shows:
1/1 RunningStep 4: Check the Deployment
kubectl get deployments -n blog-demo --context=kind-kubehealer-demoThe desired and available replica counts should become 1.

Step 5: Create a Service
kubectl expose deployment nginx-blog --name=nginx-blog-service --port=80 --target-port=80 --type=ClusterIP --namespace=blog-demo --context=kind-kubehealer-demoThis creates a ClusterIP Service to expose the NGINX application inside the cluster.
Step 6: Verify the Service
kubectl get services -n blog-demo --context=kind-kubehealer-demo
8.2 Access the NGINX application running on kind
A ClusterIP Service is accessible inside the Kubernetes cluster. To access it from your computer, we can use port forwarding.
Run:
kubectl port-forward service/nginx-blog-service 18081:80 --namespace=blog-demo --context=kind-kubehealer-demoKeep this terminal running.
Open your browser and visit:
localhost:18081
You should see the NGINX welcome page.

After checking the page, return to the terminal and press Ctrl + C to stop port forwarding.
8.3 Deploy NGINX on minikube
Now let's repeat the same steps on minikube.
Step 1: Create a namespace
kubectl create namespace blog-demo --context=minikube
Step 2: Create a Deployment
kubectl create deployment nginx-blog --image=nginx --replicas=1 --namespace=blog-demo --context=minikubeStep 3: Check the Pod
kubectl get pods -n blog-demo --context=minikubeWait until the Pod shows:
1/1 RunningStep 4: Check the Deployment
kubectl get deployments -n blog-demo --context=minikubeStep 5: Create a Service
kubectl expose deployment nginx-blog --name=nginx-blog-service --port=80 --target-port=80 --type=ClusterIP --namespace=blog-demo --context=minikubeStep 6: Verify the Service
kubectl get services -n blog-demo --context=minikube
8.4 Access the NGINX application running on minikube
Run:
kubectl port-forward service/nginx-blog-service 18080:80 --namespace=blog-demo --context=minikubeKeep the terminal running.
Open your browser and visit:
localhost:18080
You should see the NGINX welcome page.

After checking the page, press Ctrl + C in the terminal to stop port forwarding.
9. Comparing the hands-on results
I deployed the same NGINX application on both kind and minikube.
Here are the results from my testing:
| Activity | kind | minikube |
|---|---|---|
| Cluster node | kubehealer-demo-control-plane | minikube |
| Node status | Ready | Ready |
| Kubernetes version | v1.32.0 | v1.35.1 |
| Namespace | blog-demo | blog-demo |
| Deployment | nginx-blog | nginx-blog |
| Available replicas | 1/1 | 1/1 |
| Pod status | 1/1 Running | 1/1 Running |
| Service type | ClusterIP | ClusterIP |
| Service port | 80 | 80 |
| Local browser URL | localhost:18081 | localhost:18080 |
| Browser result | NGINX Welcome | NGINX Welcome |
Both tools successfully ran the same NGINX application and allowed me to access it through port forwarding.
This hands-on exercise helped me understand that the basic Kubernetes objects and commands remain the same even when the local cluster tool changes.
10. kind vs minikube vs Docker Desktop: Comparison
| Feature | kind | minikube | Docker Desktop Kubernetes |
|---|---|---|---|
| Main purpose | Local Kubernetes clusters using containers | Local Kubernetes learning and development | Kubernetes integrated with Docker Desktop |
| Cluster nodes | Docker containers | Depends on the selected driver | Managed by Docker Desktop |
| Multi-node support | Yes | Yes | Depends on the available configuration |
| Setup experience | Command line | Command line | Desktop interface |
| Kubernetes learning | Very useful | Very useful | Useful |
| CI testing | Particularly useful | Can be used | Less commonly used for CI |
| Add-ons | Kubernetes-focused workflows | Built-in add-ons | Depends on Docker Desktop features |
| Best suited for | Cluster testing and development | Learning and local development | Developers already using Docker Desktop |
There is no single best option for everyone.
Choose kind when you want to create lightweight clusters and practise multi-node Kubernetes or automated testing.
Choose minikube when you want a dedicated local Kubernetes learning environment with useful add-ons.
Choose Docker Desktop Kubernetes when you already use Docker Desktop and prefer an integrated local development experience.
11. Common issues and troubleshooting
Issue 1: Docker is not running
You may see errors when starting kind or minikube if Docker is not running.
Check:
docker infoSolution: Start Docker Desktop or your Docker Engine service, depending on your operating system.
Issue 2: Kubernetes node is NotReady
Check the node:
kubectl get nodesCheck the Pod status:
kubectl get pods -AA cluster may need some time to start. If a node remains NotReady, inspect its conditions and events before changing anything.
Issue 3: kubectl is connected to the wrong cluster
kubectl uses a current context. If you have multiple clusters, commands may accidentally target the wrong one.
Check the current context:
kubectl config current-contextList all contexts:
kubectl config get-contextsFor commands in this article, I used explicit --context options to avoid accidentally sending commands to another cluster.
Issue 4: Application is not opening in the browser
Check whether the Pod is running:
kubectl get pods -n blog-demoCheck the Service:
kubectl get services -n blog-demoCheck the port-forward terminal for errors. Keep the port-forward command running while accessing the browser.
12. Cleanup: Remove only the practice resources
After completing the exercise, you can remove the NGINX resources created for this article.
Important: The following commands delete only the blog-demo namespace and the resources inside it. They do not delete your entire kind or minikube cluster.
Remove the kind practice namespace:
kubectl delete namespace blog-demo --context=kind-kubehealer-demoRemove the minikube practice namespace:
kubectl delete namespace blog-demo --context=minikubeIf you created a separate new kind cluster only for this exercise and want to remove that entire cluster, you can use:
kind delete cluster --name local-kind-demoDo not run that last command against an existing cluster that contains other workloads you want to keep.
13. What I learned from this exercise
Before doing this hands-on exercise, I understood that kind and minikube could both run Kubernetes locally.
But deploying the same application on both tools made the differences clearer.
I learned that:
Both tools can create local Kubernetes clusters.
Kubernetes objects such as Pods, Deployments, Services and Namespaces work in both environments.
kubectl is the command-line tool used to communicate with the Kubernetes API server.
A ClusterIP Service is not directly exposed to the host browser, so port forwarding is useful for local testing.
The Kubernetes version matters, and the kubectl client should be compatible with the cluster's API server.
Local Kubernetes is a convenient way to practise before working with managed Kubernetes services in the cloud.
The most important takeaway for me was that the Kubernetes concepts remain the same, even when the tool used to create the local cluster changes.
Final thought
You do not need a cloud Kubernetes cluster to begin learning Kubernetes. Start locally, practise the fundamentals, deploy applications, troubleshoot problems and gradually move towards managed Kubernetes services.
The best tool is the one that helps you understand Kubernetes concepts and gives you enough opportunity to practise.
❓ Questions readers ask
What is Local Kubernetes?
Local Kubernetes allows you to run a Kubernetes cluster on your own computer for learning, development and testing.
What is the difference between kind and minikube?
kind runs Kubernetes nodes as Docker containers, while minikube creates and manages a local Kubernetes cluster using a supported driver.
Can I learn Kubernetes without AWS or Azure?
Yes. Tools such as kind, minikube and Docker Desktop let you practise Kubernetes locally without creating a cloud cluster.
What is kubectl used for?
kubectl is the command-line tool used to communicate with the Kubernetes API server and manage Kubernetes resources.
🛍️ Malathi Shetty's shelf
Courses, cohorts and more from the authorGet Malathi Shetty's next blog by email
One email a week when they publish. Add the weekly Best of ByteBlog too. No spam, unsubscribe with one click.
We email you once to confirm. By subscribing you agree to the privacy policy.
Related blogs

Docker vs Kubernetes: Understanding Containers
Docker made it easier to package and run applications. But what happens when you need to manage hundreds of containers across multiple servers?
#cloudcomputing
Kubernetes Basics Through a Restaurant Kitchen
Have you ever opened a Kubernetes tutorial, seen words like Pod, Node, Control Plane, ReplicaSet and DaemonSet, and wondered how they all connect?
#aiworkload
Kubernetes for AI Workloads: GPU Infrastructure Without the GPU
Learn what changes in Kubernetes when deploying AI workloads. Explore GPU scheduling, gang scheduling, inference serving, and cost management patterns.
#aws
Multi-Cloud Linux Deployment on AWS and Azure
Introduction Have you ever wondered how the same website can be hosted on two different cloud platforms? In this hands-on Multi-Cloud Linux Deployment...

💬 Comments (0)
Top · NewestSign in to comment