Kubernetes SetupIntroduction & Minikube

When you start learning Kubernetes, the first question that comes up is:

Where do I get a cluster to practice Kubernetes on?

When we learned Docker, we installed Docker Desktop on our own laptop or desktop and ran containers.

But Kubernetes is a little different.

To use Kubernetes, we need a Kubernetes cluster where we can deploy, manage and scale applications.

The good news is that you don't need an expensive cloud server or production infrastructure to start learning Kubernetes.

You can create a Kubernetes cluster on your own laptop too.

Today we will look at the different ways to set up a Kubernetes cluster, the difference between Docker Desktop and Minikube, how Minikube works, and how to build a local Kubernetes environment.

1. Ways to set up a Kubernetes cluster

There are generally three kinds of environments for practicing Kubernetes.

                  Kubernetes Cluster
                          |
            +-------------+-------------+
            |             |             |
            ▼             ▼             ▼
       Local Setup    Cloud Setup    Playground
            |             |             |
       Docker Desktop     GKE        KodeKloud
       Minikube           EKS        Killercoda
       Kind               AKS        Online Labs
       kubeadm

Each approach has its own advantages and limitations.

Which one you use depends on your learning goal, the hardware you have and your infrastructure experience.

Option 1: Local Kubernetes setup

A local setup means creating a Kubernetes cluster on your own laptop, desktop or virtual machine.

No separate cloud provider is needed.

Common tools:

What are the advantages of a local setup?

With a cluster on your own machine, you can deploy applications as you like, change the configuration and practice all kinds of Kubernetes commands.

You don't have to worry about ongoing cloud infrastructure costs.

Keep in mind, though, that running a local Kubernetes cluster needs CPU, RAM and disk resources.

Option 2: Cloud-managed Kubernetes

In production, many organizations use a cloud provider's managed Kubernetes service.

Popular services:

With managed Kubernetes, the cloud provider takes care of much of the control plane's operational responsibility.

For example:

• Kubernetes control plane provisioning
• Managed control plane availability
• Control plane maintenance
• Supported version upgrades
• Cloud infrastructure integration

That does not mean everything is managed automatically, though.

Some responsibility for worker nodes, networking, security configuration, application deployment and resource management still lies with you. How much depends on the service and configuration you choose.

Cloud Kubernetes workflow

Developer
    |
    ▼
Cloud Console / CLI
    |
    ▼
Create Kubernetes Cluster
    |
    ▼
Configure Node Pools
    |
    ▼
Connect using kubectl
    |
    ▼
Deploy Applications

When is cloud Kubernetes the better choice?

When you want to practice with real cloud infrastructure, managed services, production-like deployments or cloud-native architecture.

But a cloud cluster is not required at the start of learning.

And depending on the cloud provider's pricing, there may be charges for the cluster, compute, storage and networking.

Option 3: Online Kubernetes playgrounds

Say your laptop doesn't have much RAM.

Or you just want to practice Kubernetes commands without installing anything.

In that case, online Kubernetes playgrounds are useful.

Examples:

KodeKloud Playgrounds

https://kodekloud.com/playgrounds/

Killercoda

https://killercoda.com/

These platforms can provide a browser-based terminal and temporary Kubernetes environments.

Advantages of a playground

• No local installation needed
• Practice Kubernetes commands right from the browser
• You get a temporary learning environment
• Quick hands-on labs
• Uses fewer of your own machine's resources

But there are limitations.

Playground sessions can be temporary, the environment can reset, there may be resource limits, and some features may depend on a subscription.

So for regular development and long-term experimentation, a local Kubernetes cluster can be more convenient.

2. Setting up Kubernetes with Docker Desktop

Docker Desktop is not only for running Docker containers.

It also has built-in Kubernetes support.

For people who already use Docker Desktop, it is an easy starting point for learning Kubernetes.

Docker Desktop is available for macOS, Windows and Linux desktop environments.

How to enable Kubernetes

First, open Docker Desktop.

Then go to the Kubernetes settings.

Docker Desktop
      |
      ▼
Settings
      |
      ▼
Kubernetes
      |
      ▼
Enable Kubernetes
      |
      ▼
Apply / Create Cluster
      |
      ▼
Local Kubernetes Cluster

The layout of the settings can differ a little depending on your Docker Desktop version.

Newer versions may offer kubeadm- or kind-based options for provisioning the cluster. So Docker Desktop's Kubernetes is not always strictly single-node.

Verifying the Kubernetes cluster

Once the cluster is ready, open a terminal.

kubectl cluster-info

This command shows information about the cluster's control plane.

Then:

kubectl get nodes

Expected example:

NAME             STATUS   ROLES           AGE   VERSION
docker-desktop   Ready    control-plane   2m    v1.x.x

This output shows that one Kubernetes node is available and in the Ready state.

The number and names of nodes can differ depending on Docker Desktop's provisioning method.

Advantages of Docker Desktop

When you enable Kubernetes in Docker Desktop, you skip much of the manual control plane configuration.

That makes it useful for learning Kubernetes basics such as Pods, Deployments, Services and ConfigMaps.

3. What is Minikube?

Now to today's main topic: Minikube.

Minikube is an open-source tool for creating a local Kubernetes cluster on your own computer.

Minikube usually creates a single-node Kubernetes cluster, but it also supports multi-node local clusters.

Its main purpose is to make learning, development and testing with Kubernetes easy.

In plain words:

Minikube is a tool that creates an environment for running Kubernetes inside your own laptop or desktop.

Say you have a Python FastAPI application.

Now you want to deploy it to Kubernetes.

You don't need to create an AWS EKS or Google GKE cluster to start.

With Minikube, you can practice the whole deployment process in a local environment.

4. How does Minikube work internally?

Before understanding Minikube, you need to know the basic architecture of a Kubernetes cluster.

A Kubernetes cluster is generally made up of two logical parts:

the control plane and worker nodes.

Control plane components

The control plane is responsible for the cluster's overall management and orchestration.

Its key components are:

Worker node components

Worker nodes are used to run application workloads.

Traditional Kubernetes architecture

                 Kubernetes Cluster
                         |
          +--------------+--------------+
          |                             |
          ▼                             ▼
     Control Plane                 Worker Nodes
          |                             |
     API Server                     Kubelet
          |                             |
        etcd                      Container Runtime
          |                             |
     Scheduler                      Containers
          |
  Controller Manager

Configuring a production-grade Kubernetes cluster by hand means setting up many components.

Networking, certificates, the API server, the container runtime, kubelet, the control plane configuration: everything has to be configured correctly.

Minikube automates much of this complex setup process.

Minikube single-node architecture

                Your Laptop
                    |
                    ▼
                Minikube
                    |
                    ▼
           VM / Container Driver
                    |
                    ▼
              Kubernetes Node
                    |
          +---------+---------+
          |                   |
          ▼                   ▼
     Control Plane       Worker Workloads
          |                   |
      API Server            Kubelet
         etcd                  |
      Scheduler         Container Runtime
     Controllers               |
                             Pods

In a single-node Minikube cluster, the control plane and the application workloads can live on the same node.

In production, it is common to use multiple nodes for availability and scalability.

5. What do you need to run Minikube?

A few key components are needed to set up Minikube.

Mainly:

1. The Minikube executable
2. A compatible driver
3. The Kubernetes CLI (kubectl)

Installing kubectl separately is convenient, but Minikube can also provide kubectl itself through the minikube kubectl -- command.

A. Driver — Where does the Kubernetes environment run?

Minikube uses a driver to run the cluster.

The driver decides which environment the Kubernetes node runs in.

Minikube generally supports VM-based or container-based drivers.

Common drivers

Which drivers are available depends on the operating system, hardware architecture and installed software.

How does a VM driver work?

Host Operating System
         |
         ▼
       Hypervisor
         |
         ▼
    Virtual Machine
         |
         ▼
   Kubernetes Node
         |
         ▼
    Application Pods

With a VM driver, Minikube can create the Kubernetes environment inside a virtual machine.

How does the Docker driver work?

Host Operating System
         |
         ▼
     Docker Engine
         |
         ▼
  Minikube Node Container
         |
         ▼
    Kubernetes Cluster
         |
         ▼
         Pods

With the Docker driver, Minikube builds the Kubernetes node environment on top of Docker.

There is a common confusion here:

Using Minikube's Docker driver does not mean Kubernetes uses Docker Engine as its CRI runtime to run application containers.

Here, Docker mainly acts as the driver that hosts the Minikube node environment.

Inside the node, Kubernetes can use a CRI-compatible runtime such as containerd.

6. kubectl — Kubernetes' command-line tool

Just as we use the docker CLI for Docker, we use kubectl for Kubernetes.

kubectl lets you talk to the Kubernetes cluster's API server.

Example:

kubectl get nodes

Lists the cluster's nodes.

kubectl get pods

Shows the Pods in the current namespace.

kubectl get pods -A

Shows the Pods in all namespaces.

kubectl cluster-info

Shows basic information about the cluster.

kubectl communication flow

Developer
    |
    ▼
  kubectl
    |
    ▼
Kubernetes API Server
    |
    ▼
Kubernetes Resources
    |
    ├── Pods
    ├── Deployments
    ├── Services
    ├── ConfigMaps
    └── Secrets

In other words, kubectl talks to the Kubernetes API.

It does not send commands directly to the container runtime to start or stop containers.

The difference between kubectl and the Docker CLI

A Docker container and a Kubernetes Pod are not the same thing.

A Pod is Kubernetes' smallest deployable workload unit, and it can contain one or more containers.

7. Minikube CLI — The tool for creating and managing the cluster

After installing the Minikube executable, we can manage a local Kubernetes cluster with the minikube command.

Common commands:

minikube start

Starts a new cluster.

minikube status

Shows Minikube's status.

minikube stop

Stops the cluster.

minikube delete

Deletes the cluster and the resources Minikube manages.

Minikube vs kubectl

The two tools have different responsibilities.

minikube
    |
    ▼
Create / Start / Stop Cluster
    |
    ▼
Kubernetes Cluster
    |
    ▲
    |
kubectl
    |
    ▼
Deploy / Inspect / Manage Workloads

Minikube: creates and manages the Kubernetes environment.

kubectl: manages the Kubernetes resources inside that environment.

8. Installing Minikube — A basic hands-on setup

Now let's walk through running a simple local Minikube cluster.

This example uses the Docker driver.

So Docker Engine or Docker Desktop has to be installed and running first.

Step 1: Verify Docker

docker version

Then:

docker run --rm hello-world

If Docker works properly, you can use Minikube's Docker driver.

Step 2: Install Minikube

Official installation guide:

https://minikube.sigs.k8s.io/docs/start/

The installation procedure differs by operating system.

macOS

If Homebrew is installed:

brew install minikube

Windows

If the Windows Package Manager is available:

winget install Kubernetes.minikube

Linux

You can install the official Minikube binary or package for your Linux distribution and CPU architecture.

For example, on a Linux x86-64 system:

curl -LO https://github.com/kubernetes/minikube/releases/latest/download/minikube-linux-amd64

Then:

sudo install minikube-linux-amd64 /usr/local/bin/minikube

On Apple Silicon or Linux ARM64 systems, use the installer for that architecture.

Step 3: Check the Minikube version

minikube version

If you see version information, the Minikube CLI is installed.

Step 4: Start the cluster with the Docker driver

minikube start --driver=docker

When you run this command, Minikube usually:

• Prepares the required Kubernetes environment
• Creates the Kubernetes node
• Starts the control plane components
• Configures the container runtime
• Initializes cluster networking
• Configures the cluster context for kubectl

The first start may download the required images.

Setting the default driver

If you always want to use the Docker driver:

minikube config set driver docker

After that, you can simply run:

minikube start

Step 5: Check the cluster status

minikube status

Example output:

minikube
type: Control Plane
host: Running
kubelet: Running
apiserver: Running
kubeconfig: Configured

The output format can differ a little between Minikube versions.

Step 6: Verify the Kubernetes node

kubectl get nodes

Expected example:

NAME       STATUS   ROLES           AGE   VERSION
minikube   Ready    control-plane   2m    v1.x.x

Here, Ready means the node is ready to run Kubernetes workloads.

If kubectl is not installed locally, you can use Minikube's bundled kubectl:

minikube kubectl -- get nodes

Step 7: Check the system Pods

kubectl get pods -A

Here you will see the Pods of Kubernetes' internal system components.

For example:

NAMESPACE     NAME                 STATUS
kube-system   coredns-xxxxx        Running
kube-system   etcd-minikube        Running
kube-system   kube-apiserver-...   Running

There may be more Pods, depending on the cluster configuration.

If everything is fine up to this point, your Minikube cluster is ready.

9. Deploying your first application on Minikube

The cluster is created. Now let's deploy a real application.

We will use Nginx.

Step 1: Create a Deployment

kubectl create deployment nginx-demo --image=nginx

Kubernetes now creates a Deployment resource.

The Deployment controller tries to maintain the desired Pod state.

Step 2: Check the Deployment

kubectl get deployments

Then:

kubectl get pods

Expected example:

NAME                          READY   STATUS    RESTARTS
nginx-demo-xxxxxxxxxx-xxxxx   1/1     Running   0

If it shows Running and READY 1/1, the application container is running and ready.

Step 3: Create a Service

kubectl expose deployment nginx-demo \
  --type=NodePort \
  --port=80

This creates a Kubernetes Service.

A Service's job is to provide a stable abstraction for getting network traffic to Pods.

Step 4: Check the Service

kubectl get services

Now, to access the service through Minikube:

minikube service nginx-demo

This command can open your local browser and, depending on the Minikube driver, provide an access URL or a forwarding mechanism.

If you only want to see the URL:

minikube service nginx-demo --url

In some environments, especially with the Docker driver on macOS or Windows, you may need to keep the terminal open to keep the service tunnel running.

Alternative: port forwarding

kubectl port-forward service/nginx-demo 8080:80

Then, in the browser:

http://localhost:8080

You will now see the Nginx welcome page.

Keep the terminal session running the command open for as long as you need port forwarding.

10. Minikube Dashboard

A useful feature of Minikube is its Kubernetes Dashboard integration.

The dashboard lets you inspect Kubernetes resources from a graphical interface.

To launch the dashboard:

minikube dashboard

In a supported configuration, this helps enable or open the Kubernetes Dashboard.

Through the dashboard, you can inspect the cluster's Pods, Deployments, Services and resource status.

Dashboard availability and supported versions can depend on the Minikube and Kubernetes configuration, though.

11. Stopping, restarting and deleting a Minikube cluster

Three commands are important to remember when using Minikube.

Stop the cluster

minikube stop

This stops the cluster. It usually does not delete persistent Minikube state.

Restart the cluster

minikube start

If an existing profile is there, Minikube can start it again.

Delete the cluster

minikube delete

This removes the Minikube cluster.

Important: using minikube delete can lose the cluster's resources and the persistent state Minikube manages.

So if there is important data, take a backup first.

Cleaning up the test application

To remove only the Nginx application while keeping the cluster running:

kubectl delete service nginx-demo
kubectl delete deployment nginx-demo

This does not delete the Minikube cluster.

12. Can Minikube create a multi-node cluster?

Many older Kubernetes tutorials explain Minikube as a single-node cluster tool only.

But Minikube now supports multiple local nodes.

Example:

minikube start --nodes=3 --driver=docker

This can create a local Minikube cluster with three nodes.

Then:

kubectl get nodes

Example:

NAME           STATUS   ROLES
minikube       Ready    control-plane
minikube-m02   Ready    <none>
minikube-m03   Ready    <none>

Worker nodes usually show <none> in the ROLES column, because no worker role label is set by default.

With multiple nodes, you can practice Pod scheduling, node management and cluster behavior.

But a multi-node Minikube cluster is not equivalent to a full, production-grade, highly available Kubernetes environment.

13. What is kubeadm, and how is it different from Minikube?

Minikube automates the process of creating a local learning environment.

With kubeadm, on the other hand, you learn the fundamental process of bootstrapping a Kubernetes cluster.

kubeadm is Kubernetes' official cluster bootstrapping tool.

It is used to initialize the Kubernetes control plane and to join additional nodes.

Typical kubeadm architecture

                 Kubernetes Cluster
                          |
             +------------+------------+
             |                         |
             ▼                         ▼
       Control Plane               Worker Nodes
             |                         |
       API Server                   Kubelet
          etcd                         |
       Scheduler                Container Runtime
      Controllers                      |
             |                     App Pods
             +-------------------------+

Common kubeadm commands

Control plane initialization:

sudo kubeadm init

The structure of the command for joining a worker node:

sudo kubeadm join <control-plane-endpoint> \
  --token <bootstrap-token> \
  --discovery-token-ca-cert-hash sha256:<hash>

These are only examples to show the command structure.

For a real cluster setup, you first need to configure a compatible container runtime, kubelet, kubectl, networking, certificates and other prerequisites.

After initializing the control plane, you usually also need to set up a compatible CNI plugin for Pod networking.

kubeadm is not a one-click desktop solution like Docker Desktop or Minikube.

It is useful for learning real Kubernetes cluster bootstrapping and administration.

14. Docker Desktop vs Minikube vs Kind vs kubeadm

Now let's compare all the options together.

Which one is best?

If you just want to start practicing Kubernetes quickly, Docker Desktop is enough.

If you want to learn Kubernetes concepts more systematically, Minikube is a good choice.

If you need automated integration testing or disposable multi-node Kubernetes clusters, Kind is useful.

And if you want a deep understanding of Kubernetes' real infrastructure architecture, node setup, networking and administration, learning kubeadm is important.

15. Kubernetes setup options — A real-life analogy

A simple example makes the whole thing easy to understand.

Say you want to learn to drive.

You have a few options.

You don't need to take the engine apart and reassemble it on day one.

First you learn the basics of driving.

Then, gradually, you understand the details of the engine and the infrastructure.

The same approach works for Kubernetes.

First, understand Pods, Deployments, Services and ConfigMaps.

Then move on to cluster networking, scheduling, storage, security and multi-node administration.

16. Recommended learning workflow

If you want to learn Kubernetes from scratch, you can follow this learning sequence.

Step 1:  Docker Fundamentals
      |
      ▼
Step 2:  Docker Images & Containers
      |
      ▼
Step 3:  Docker Networking & Volumes
      |
      ▼
Step 4:  Docker Compose
      |
      ▼
Step 5:  Minikube Installation
      |
      ▼
Step 6:  kubectl Fundamentals
      |
      ▼
Step 7:  Pods, Deployments & Services
      |
      ▼
Step 8:  ConfigMaps & Secrets
      |
      ▼
Step 9:  Storage & Persistent Volumes
      |
      ▼
Step 10: Ingress & Networking
      |
      ▼
Step 11: Helm
      |
      ▼
Step 12: Multi-Node Kubernetes
      |
      ▼
Step 13: kubeadm & Cluster Administration
      |
      ▼
Step 14: Production Kubernetes

With this sequence, you don't need production-grade infrastructure to start learning Kubernetes.

Most foundational concepts can be practiced hands-on with Minikube.

17. Quick Kubernetes setup verification commands

After setting up a local Minikube cluster, you can use these commands:

# Minikube Version
minikube version

# Cluster Start
minikube start --driver=docker

# Cluster Status
minikube status

# Kubernetes Cluster Information
kubectl cluster-info

# List Cluster Nodes
kubectl get nodes

# List All Pods
kubectl get pods -A

# List All Namespaces
kubectl get namespaces

# Create Test Deployment
kubectl create deployment nginx-demo --image=nginx

# Check Deployment
kubectl get deployments

# Check Pods
kubectl get pods

# Expose Application
kubectl expose deployment nginx-demo \
  --type=NodePort \
  --port=80

# Open Application
minikube service nginx-demo

# Cleanup Test Application
kubectl delete service nginx-demo
kubectl delete deployment nginx-demo

# Stop Cluster
minikube stop

If the cluster is Ready, the test Pods run and the application can be reached, your local Kubernetes environment is ready for basic practice.

18. Final takeaway — Which Kubernetes setup should you use?

You don't need to try every installation option at once to learn Kubernetes.

Picking one option that fits your available resources and learning goal is enough.

Docker Desktop: if you want the easiest way to start with Kubernetes.

Minikube: if you want a dedicated local Kubernetes learning environment.

Kind: for disposable test clusters and automated testing.

kubeadm: for understanding the real setup and administration of a Kubernetes cluster.

Managed Kubernetes: if you want to work with cloud infrastructure such as GKE, EKS or AKS.

Online Playground: if you want to practice Kubernetes commands quickly from the browser without installing anything.

In my view, Minikube is a good starting point for learning Kubernetes, because it lets you practice Kubernetes' important features in a local environment.

Later, once you have a good grasp of Pods, Deployments, Services, networking and storage, you can move on to setting up a multi-node cluster with kubeadm.

Official Documentation & References

• Kubernetes — Getting Started
• Kubernetes — Install Tools
• Minikube Official Documentation
• Minikube Installation
• Minikube Docker Driver
• Minikube kubectl Guide
• Docker Desktop Kubernetes
• Kubernetes — kubeadm Installation
• Kind — Official Documentation

One-line summary

You can create a Kubernetes cluster on your own computer with Docker Desktop, Minikube or Kind; you can use kubeadm to learn a real multi-node setup; in the cloud there are GKE, EKS and AKS; and online Kubernetes playgrounds let you practice without installing anything.

The most important thing when you start learning Kubernetes is getting a working cluster.

Because Kubernetes is not a technology you learn by reading theory alone. Its concepts make the most sense when you create Pods, manage Deployments, expose Services and run real applications.