CareerByteCode
ByteBlogby CareerByteCode

Running Kubernetes Locally: kind vs minikube vs Docker Desktop

🟢 Beginner

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.

Running Kubernetes Locally: kind vs minikube vs Docker Desktop

✍️ 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-demo

This 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=docker

This 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 environmentWhere to run the commands
WindowsPowerShell
Windows with WSL2 UbuntuDocker Desktop on Windows; Kubernetes CLI tools inside Ubuntu
macOSTerminal
Ubuntu/LinuxLinux 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:

  1. Open Docker Desktop.

  2. Make sure Docker Desktop is running.

  3. If you use the WSL2 backend, configure it in Docker Desktop settings.

  4. Open PowerShell and install the Kubernetes tools.

Install kubectl:

winget install -e --id Kubernetes.kubectl

Install kind:

winget install Kubernetes.kind

Install minikube:

winget install Kubernetes.minikube

If a package ID is not found, check the available package name using:

winget search kubectl
winget search kind
winget search minikube

Close and reopen PowerShell if necessary, then verify:

docker --version
kubectl version --client
kind version
minikube version
docker info

4.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 info

If Docker is working, continue.

Step 3: Install kubectl inside Ubuntu

sudo snap install kubectl --classic

Step 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/kind

Step 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-amd64

Step 6: Verify the installations

Run these commands in Ubuntu:

docker --version
kubectl version --client
kind version
minikube version
docker info

If 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 kubectl

Step 4: Install kind

brew install kind

Step 5: Install minikube

brew install minikube

Step 6: Verify the installations

docker --version
kubectl version --client
kind version
minikube version
docker info

4.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 info

If 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 --classic

Step 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/kind

Step 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-amd64

Step 5: Verify the installations

docker --version
kubectl version --client
kind version
minikube version
docker info

4.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:

ComponentVersion
Operating systemUbuntu 24.04.4 LTS on WSL2
Docker CLI29.5.3
kubectl clientv1.35.0
kindv0.26.0
minikubev1.38.1
kind Kubernetes clusterv1.32.0
minikube Kubernetes clusterv1.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-demo

This creates a Kubernetes cluster named local-kind-demo.

Step 2: Check the cluster

kubectl cluster-info --context kind-local-kind-demo

This checks whether the Kubernetes control plane is reachable.

Step 3: Check the nodes

kubectl get nodes --context kind-local-kind-demo

Expected result: The node should eventually show Ready.

kind cluster and node verification

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=docker

This starts a local Kubernetes cluster using Docker as the driver.

Step 2: Check the cluster status

minikube status

You should see the host, kubelet and API server running, with kubeconfig configured.

minikube status

Step 3: Check the Kubernetes node

kubectl get nodes --context=minikube

Expected 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-demo

A namespace helps organize Kubernetes resources.

kind-namespace

Step 2: Create a Deployment

kubectl create deployment nginx-blog --image=nginx --replicas=1 --namespace=blog-demo --context=kind-kubehealer-demo

This creates a Deployment named nginx-blog with one NGINX replica.

Step 3: Check the Pod

kubectl get pods -n blog-demo --context=kind-kubehealer-demo

Wait until the Pod shows:

1/1 Running

Step 4: Check the Deployment

kubectl get deployments -n blog-demo --context=kind-kubehealer-demo

The desired and available replica counts should become 1.

Create NGINX Deployment on kind

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-demo

This 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

kind NGINX Deployment, Pod and Service

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-demo

Keep this terminal running.

Open your browser and visit:

localhost:18081

You should see the NGINX welcome page.

NGINX welcome page running through kind

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

minikube-create a namespace

Step 2: Create a Deployment

kubectl create deployment nginx-blog --image=nginx --replicas=1 --namespace=blog-demo --context=minikube

Step 3: Check the Pod

kubectl get pods -n blog-demo --context=minikube

Wait until the Pod shows:

1/1 Running

Step 4: Check the Deployment

kubectl get deployments -n blog-demo --context=minikube

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=minikube

Step 6: Verify the Service

kubectl get services -n blog-demo --context=minikube

minikube NGINX Deployment, Pod and Service

8.4 Access the NGINX application running on minikube

Run:

kubectl port-forward service/nginx-blog-service 18080:80 --namespace=blog-demo --context=minikube

Keep the terminal running.

Open your browser and visit:

localhost:18080

You should see the NGINX welcome page.

minikube-Access NGINX from your browser

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:

Activitykindminikube
Cluster nodekubehealer-demo-control-planeminikube
Node statusReadyReady
Kubernetes versionv1.32.0v1.35.1
Namespaceblog-demoblog-demo
Deploymentnginx-blognginx-blog
Available replicas1/11/1
Pod status1/1 Running1/1 Running
Service typeClusterIPClusterIP
Service port8080
Local browser URLlocalhost:18081localhost:18080
Browser resultNGINX WelcomeNGINX 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

FeaturekindminikubeDocker Desktop Kubernetes
Main purposeLocal Kubernetes clusters using containersLocal Kubernetes learning and developmentKubernetes integrated with Docker Desktop
Cluster nodesDocker containersDepends on the selected driverManaged by Docker Desktop
Multi-node supportYesYesDepends on the available configuration
Setup experienceCommand lineCommand lineDesktop interface
Kubernetes learningVery usefulVery usefulUseful
CI testingParticularly usefulCan be usedLess commonly used for CI
Add-onsKubernetes-focused workflowsBuilt-in add-onsDepends on Docker Desktop features
Best suited forCluster testing and developmentLearning and local developmentDevelopers 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 info

Solution: Start Docker Desktop or your Docker Engine service, depending on your operating system.

Issue 2: Kubernetes node is NotReady

Check the node:

kubectl get nodes

Check the Pod status:

kubectl get pods -A

A 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-context

List all contexts:

kubectl config get-contexts

For 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-demo

Check the Service:

kubectl get services -n blog-demo

Check 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-demo

Remove the minikube practice namespace:

kubectl delete namespace blog-demo --context=minikube

If 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-demo

Do 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:

  1. Both tools can create local Kubernetes clusters.

  2. Kubernetes objects such as Pods, Deployments, Services and Namespaces work in both environments.

  3. kubectl is the command-line tool used to communicate with the Kubernetes API server.

  4. A ClusterIP Service is not directly exposed to the host browser, so port forwarding is useful for local testing.

  5. The Kubernetes version matters, and the kubectl client should be compatible with the cluster's API server.

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

📚 Sources
  1. kubernetes.io/docs/tasks/tools/
  2. kubernetes.io/releases/version-skew-policy/
  3. kind.sigs.k8s.io/docs/user/quick-start/
  4. minikube.sigs.k8s.io/docs/start/
  5. docs.docker.com/desktop/

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

Read next →Docker vs Kubernetes: Understanding Containers⏱ 16 min

🛍️ Malathi Shetty's shelf

Courses, cohorts and more from the author
Malathi Shetty
Written by Malathi Shetty
Cloud & DevOps | AWS โ€ข Azure โ€ข Docker โ€ข Kubernetes โ€ข CI/CD
🏅 Contributor writer

Iโ€™m a Senior Software Quality Engineer learning and transitioning into Cloud & DevOps. Iโ€™m currently working hands-on with AWS, Azure, Linux, Docker, Kubernetes, CI/CD and DevSecOps. I share what I learn through practical projects and real-world examples.

Visit my ByteStoreLearning, building and sharing practical Cloud & DevOps experiences.

🌟 See Malathi Shetty's full profile: blogs, work and verified certificates

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

💬 Comments (0)

Top · Newest

Sign in to comment

Related blogs

🛍️✨ From the author · ByteStore1:1 DevOps Project & Learning Discussionโ‚น500View offer →