01-local-kubernetes-setup-options

What You Will Learn

By the end of this guide you will:

• Understand what a local Kubernetes environment is and why you need one
• Know the four major local Kubernetes tools in depth
• Be able to choose the right tool for your specific use case
• Understand Minikube’s internal architecture completely
• Know exactly how each tool spins up a cluster on your machine

Why Run Kubernetes Locally?

Before learning the tools, understand why you need a local Kubernetes environment at all.

Real benefits of running Kubernetes locally:

• Learn without risk — break things freely without affecting production or teammates
• Offline development — work on trains, planes, and places without internet
• Faster iteration — test manifests, Helm charts, and operators in seconds
• Cost savings — a full local cluster costs $0 vs $100–$500/month on EKS/GKE
• CI/CD testing — test your GitHub Actions pipelines locally before pushing

The Four Local Kubernetes Options

There are four major tools for running Kubernetes locally. Each takes a fundamentally different approach:

1. Overview of Each Tool

🟢 Minikube

Created by: Google / Kubernetes community First released: 2016 Current version: v1.33+

Minikube is the official Kubernetes tool for local development, maintained by the Kubernetes project itself. It creates a single-node Kubernetes cluster inside a Virtual Machine or Docker container on your laptop.

Minikube was the first widely adopted local Kubernetes tool and remains the most feature-complete. It ships with a built-in addon system that lets you enable monitoring, ingress, dashboard, and metrics-server with a single command.

# What Minikube gives you out of the box
minikube addons list
# |-----------------------------|----------|
# | addon                       | profile  |
# |-----------------------------|----------|
# | dashboard                   | disabled |
# | default-storageclass        | enabled  |
# | ingress                     | disabled |
# | metrics-server              | disabled |
# | registry                    | disabled |
# | volumesnapshots             | disabled |

How it works in one sentence: Minikube downloads a VM image (or uses Docker), boots it, installs Kubernetes inside it, and configures your local kubectl to talk to it.

🔵 KIND (Kubernetes IN Docker)

Created by: Kubernetes SIGs (Special Interest Groups) First released: 2019 Stands for: Kubernetes IN Docker

KIND was built specifically for testing Kubernetes itself — the Kubernetes team uses KIND to run their own CI/CD tests. It runs entire Kubernetes nodes as Docker containers instead of VMs.

Each Docker container is a fully functional Kubernetes node with systemd, kubelet, and all other node components running inside it. This makes KIND extremely fast to start and stop, and perfect for automated testing pipelines.

# KIND can create multi-node clusters with a config file
cat kind-config.yaml
# kind: Cluster
# apiVersion: kind.x-k8s.io/v1alpha4
# nodes:
# - role: control-plane
# - role: worker
# - role: worker
# - role: worker

kind create cluster --config kind-config.yaml
# A 4-node cluster (1 control plane + 3 workers) in ~60 seconds

How it works in one sentence: KIND pulls a specially built Docker image that contains everything needed to run a Kubernetes node, starts it as a container, and bootstraps a full cluster inside those containers.

🟣 Docker Desktop

Created by: Docker Inc. First released: 2018 (K8s support added) Platforms: macOS and Windows only

Docker Desktop is the most beginner-friendly option — Kubernetes is built in and enabled with a single checkbox in the application settings. There is nothing to install separately.

When you enable Kubernetes in Docker Desktop, it runs a single-node cluster that shares the same Docker daemon you use for regular container work. This means images you build locally are immediately available to the Kubernetes cluster without any import step.

Docker Desktop → Preferences → Kubernetes → Enable Kubernetes → Apply

The trade-off is control. Docker Desktop manages everything for you — which means you have less visibility into what is happening and fewer configuration options. You also cannot run multiple clusters or choose Kubernetes versions easily.

How it works in one sentence: Docker Desktop runs a pre-configured single-node Kubernetes cluster inside its own Linux VM (on macOS/Windows), and exposes it through the same Docker context you already have.

🟠 MicroK8s

Created by: Canonical (makers of Ubuntu) First released: 2018 Distribution method: Snap package

MicroK8s is Canonical’s lightweight, opinionated Kubernetes distribution designed for Ubuntu and Linux. Unlike the others, MicroK8s installs Kubernetes as a proper system service using Ubuntu’s Snap package manager — it runs directly on your host OS without a VM layer.

This makes MicroK8s the most resource-efficient option and the best choice if you are running Kubernetes on a Raspberry Pi, a Linux server, or a resource-constrained environment.

# Installation is a single command on Ubuntu
sudo snap install microk8s --classic

# It installs its own kubectl variant
microk8s kubectl get nodes

# Or alias it
alias kubectl='microk8s kubectl'

MicroK8s also has an addon system similar to Minikube and supports HA (high-availability) multi-node clusters, which the others do not.

How it works in one sentence: MicroK8s installs Kubernetes binaries directly on your Ubuntu/Linux system as a Snap, running all components as host-level daemons without any VM or container overhead.

2. Comparison — Pros and Cons of Each

Quick Decision Matrix

Detailed Feature Comparison Table

🟢 Minikube — Pros and Cons

Best for:

• Learning Kubernetes from scratch
• Following official Kubernetes tutorials
• Testing Helm charts and operators locally
• Developers who need a full-featured local cluster

Not ideal for:

• CI/CD pipelines (too slow)
• Multi-node topology testing
• Teams on Windows without WSL2

🔵 KIND — Pros and Cons

Best for:

• CI/CD pipelines and automated testing
• Testing multi-node cluster behaviour
• Developers already comfortable with Kubernetes
• Running Kubernetes integration tests in GitHub Actions

Not ideal for:

• Absolute beginners (more manual setup)
• Persistent storage testing (ephemeral by default)

🟣 Docker Desktop — Pros and Cons

Best for:

• Absolute beginners who just want to try Kubernetes
• Developers already using Docker Desktop for containers
• Quick demos and tutorials on macOS or Windows
• Teams who want zero-friction setup

Not ideal for:

• Linux developers
• CI/CD pipelines
• Testing specific K8s versions
• Multi-node topology testing

🟠 MicroK8s — Pros and Cons

Best for:

• Ubuntu/Linux developers
• Raspberry Pi and edge computing
• Resource-constrained machines
• Developers who want Kubernetes as a persistent background service

Not ideal for:

• macOS or Windows users
• Developers wanting full control and portability

Side-by-Side Resource Usage

3. Minikube Architecture — Deep Dive

Minikube is the recommended starting point for learning Kubernetes, so understanding its architecture deeply gives you insight into how Kubernetes itself works.

High-Level Architecture

The Driver Layer — How Minikube Creates a Cluster

The driver is the most important architectural concept in Minikube. It decides where and how the Kubernetes node runs.

Choose your driver:

# Use Docker driver (default, recommended for most users)
minikube start --driver=docker

# Use VirtualBox (full VM isolation)
minikube start --driver=virtualbox

# Use HyperKit (macOS native hypervisor)
minikube start --driver=hyperkit

# Use Hyper-V (Windows native hypervisor)
minikube start --driver=hyperv

# No driver — runs directly on Linux host (fastest)
minikube start --driver=none

Control Plane Components Inside Minikube

Minikube runs a single-node cluster where the same node acts as both the control plane and the worker. Here is what runs inside:

Request Flow — What Happens When You Run kubectl

Networking Inside Minikube

Minikube creates its own network namespace. Understanding this helps you know how to access services:

Accessing services from your host machine:

# Method 1 — NodePort: access via minikube IP + NodePort
minikube ip
# 192.168.49.2
# Access at http://192.168.49.2:30080

# Method 2 — minikube service (opens browser automatically)
minikube service frontend-service

# Method 3 — kubectl port-forward
kubectl port-forward svc/frontend-service 8080:80
# Access at http://localhost:8080

# Method 4 — minikube tunnel (for LoadBalancer type services)
minikube tunnel
# Service gets a real IP on your host

Storage Architecture in Minikube

# Storage works automatically in Minikube
# Just create a PVC and it provisions automatically
kubectl apply -f - << 'EOF'
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
EOF

# PVC is immediately bound (no cloud provisioner needed)
kubectl get pvc
# NAME     STATUS   VOLUME          CAPACITY   STORAGECLASS
# my-pvc   Bound    pvc-abc123...   1Gi        standard

Minikube Profiles — Multiple Clusters

One of Minikube’s powerful features is profiles — you can run multiple completely separate Kubernetes clusters simultaneously:

# Default cluster (profile: minikube)
minikube start

# Create a second cluster with different K8s version
minikube start -p dev-cluster --kubernetes-version=v1.28.0

# Create a third cluster for testing
minikube start -p test-cluster --kubernetes-version=v1.29.0

# List all clusters
minikube profile list
# |----------------|-----------|---------|--------------|------|---------|---------|
# | Profile        | VM Driver | Runtime | IP           | Port | Version | Status  |
# |----------------|-----------|---------|--------------|------|---------|---------|
# | minikube       | docker    | docker  | 192.168.49.2 | 8443 | v1.30.0 | Running |
# | dev-cluster    | docker    | docker  | 192.168.49.3 | 8443 | v1.28.0 | Running |
# | test-cluster   | docker    | docker  | 192.168.49.4 | 8443 | v1.29.0 | Stopped |
# |----------------|-----------|---------|--------------|------|---------|---------|

# Switch between clusters
minikube profile dev-cluster
kubectl config use-context dev-cluster

# Stop specific cluster
minikube stop -p dev-cluster

# Delete specific cluster
minikube delete -p test-cluster

Minikube Addon Architecture

Minikube’s addon system installs additional components as Kubernetes deployments and DaemonSets on the cluster:

# Enable common addons
minikube addons enable ingress           # NGINX Ingress Controller
minikube addons enable dashboard         # Kubernetes Web Dashboard
minikube addons enable metrics-server    # Enable HPA
minikube addons enable registry          # Local Docker registry
minikube addons enable storage-provisioner-gluster  # Better storage

# Open dashboard in browser instantly
minikube dashboard

# List all available addons with status
minikube addons list

Hands-On Setup — Getting Started with Each Tool

Installing and Starting Minikube

# --- Linux ---
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube

# --- macOS ---
brew install minikube

# --- Windows (PowerShell as Admin) ---
winget install minikube

# Start cluster with recommended resources
minikube start \
  --driver=docker \
  --cpus=4 \
  --memory=4096 \
  --disk-size=20g \
  --kubernetes-version=v1.30.0

# Verify everything is working
minikube status
kubectl get nodes
kubectl get pods -A

Installing and Starting KIND

# --- Linux ---
curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.23.0/kind-linux-amd64
chmod +x ./kind
sudo mv ./kind /usr/local/bin/kind

# --- macOS ---
brew install kind

# --- Windows ---
winget install Kubernetes.kind

# Create single-node cluster
kind create cluster --name my-cluster

# Create multi-node cluster
cat > kind-config.yaml << 'EOF'
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
- role: worker
- role: worker
EOF
kind create cluster --name multi-node --config kind-config.yaml

# Verify
kubectl get nodes

Installing MicroK8s (Ubuntu/Linux)

# Install
sudo snap install microk8s --classic

# Add your user to microk8s group
sudo usermod -aG microk8s $USER
newgrp microk8s

# Wait for it to be ready
microk8s status --wait-ready

# Enable essential addons
microk8s enable dns storage dashboard ingress metrics-server

# Use kubectl via microk8s
microk8s kubectl get nodes

# Or set an alias
alias kubectl='microk8s kubectl'
echo "alias kubectl='microk8s kubectl'" >> ~/.bashrc

When Minikube Is the Right Choice — Real Scenarios

Summary Tables

Architecture Comparison

Command Comparison

Key Takeaways