Quick Start

Tip

The default cluster name is kind. You can choose a different name by passing --name <name> to kinder create cluster.

Create a Cluster

kinder create cluster

You should see output like:

Creating cluster "kind" ...
 ✓ Ensuring node image (kindest/node:v1.35.1) 🖼
 ✓ Preparing nodes 📦
 ✓ Writing configuration 📜
 ✓ Starting control-plane 🕹️
 ✓ Installing CNI 🔌
 ✓ Installing StorageClass 💾
 ✓ Installing MetalLB
 ✓ Installing Metrics Server
 ✓ Tuning CoreDNS
 ✓ Installing Local Path Provisioner
 ✓ Installing Envoy Gateway
 ✓ Installing Dashboard
 ✓ Installing Local Registry
 ✓ Installing cert-manager

Addons:
 * MetalLB                 installed
 * Metrics Server          installed
 * CoreDNS Tuning          installed
 * Local Path Provisioner  installed
 * Envoy Gateway           installed
 * Dashboard               installed
 * Local Registry          installed
 * cert-manager            installed
Set kubectl context to "kind-kind"
You can now use your cluster with:

kubectl cluster-info --context kind-kind

kinder also prints a dashboard token and port-forward command — save these for later.

Addon profiles

kinder create cluster enables all 8 addons by default. Use --profile to select a preset:

• --profile minimal — no kinder addons (plain kind cluster)
• --profile gateway — MetalLB + Envoy Gateway only
• --profile ci — Metrics Server + cert-manager (CI-optimized)
• --profile full — all addons (same as default)

Offline / air-gapped

Add --air-gapped to create a cluster without any network calls for image pulls:

kinder create cluster --air-gapped

kinder fails fast with a complete list of missing images instead of hanging on failed pulls. See the Working Offline guide for the pre-load workflow.

What You Get

Addon	Namespace	Purpose
MetalLB	metallb-system	LoadBalancer IP assignment
Envoy Gateway	envoy-gateway-system	Gateway API ingress
Metrics Server	kube-system	kubectl top support
CoreDNS tuning	kube-system	Optimised DNS caching
Local Path Provisioner	local-path-storage	Automatic dynamic PVC provisioning with local-path as default StorageClass
Headlamp	kube-system	Web UI for cluster inspection
Local Registry	default (host network)	Private container registry at localhost:5001
cert-manager	cert-manager	Automatic TLS certificates with self-signed ClusterIssuer

Verify Core Addons

MetalLB

Deploy a LoadBalancer service and confirm it gets an external IP:

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

You should see a real IP under EXTERNAL-IP:

NAME    TYPE           CLUSTER-IP     EXTERNAL-IP      PORT(S)        AGE
nginx   LoadBalancer   10.96.150.34   172.19.255.200   80:30693/TCP   7s

macOS / Windows

On macOS and Windows, LoadBalancer IPs are not directly reachable from the host. Use port-forward to access the service:

kubectl port-forward svc/nginx 8081:80
# Open http://localhost:8081

Clean up:

kubectl delete svc nginx && kubectl delete deployment nginx

Metrics Server

Check that kubectl top returns real CPU and memory data:

kubectl top nodes

Expected output:

NAME                 CPU(cores)   CPU(%)   MEMORY(bytes)   MEMORY(%)
kind-control-plane   168m         0%       1385Mi          8%

Tip

Metrics may take a minute to populate after cluster creation.

CoreDNS Tuning

Verify that autopath and cache 60 are present in the Corefile:

kubectl get configmap coredns -n kube-system -o jsonpath='{.data.Corefile}'

Look for these entries in the output:

autopath @kubernetes

cache 60 {
    disable success cluster.local
    disable denial cluster.local
}

Verify Optional Addons

Envoy Gateway

Confirm the GatewayClass is accepted:

kubectl get gatewayclass eg

Expected output:

NAME   CONTROLLER                                      ACCEPTED   AGE
eg     gateway.envoyproxy.io/gatewayclass-controller   True       9m

Headlamp Dashboard

Port-forward to the dashboard:

kubectl port-forward -n kube-system service/headlamp 8080:80

Open http://localhost:8080 and paste the token that was printed during cluster creation.

If you need to retrieve the token later:

kubectl get secret kinder-dashboard-token -n kube-system \
  -o jsonpath='{.data.token}' | base64 -d

Local Registry

Confirm the registry container is running and accessible:

docker ps --filter name=kind-registry

Expected output:

CONTAINER ID   IMAGE        COMMAND                  PORTS                    NAMES
abc123def456   registry:2   "/entrypoint.sh /etc…"   0.0.0.0:5001->5000/tcp   kind-registry

Verify dev tool discovery ConfigMap is present:

kubectl get configmap local-registry-hosting -n kube-public

Expected output:

NAME                     DATA   AGE
local-registry-hosting   1      60s

cert-manager

Check all three cert-manager components are running:

kubectl get pods -n cert-manager

Expected output:

NAME                                       READY   STATUS    RESTARTS   AGE
cert-manager-...                           1/1     Running   0          60s
cert-manager-cainjector-...                1/1     Running   0          60s
cert-manager-webhook-...                   1/1     Running   0          60s

Confirm the self-signed ClusterIssuer is ready:

kubectl get clusterissuer selfsigned-issuer

Expected output:

NAME                READY   AGE
selfsigned-issuer   True    60s

Loading local images

To load a locally-built image into every node of the cluster, use kinder load images:

docker build -t myapp:dev .
kinder load images myapp:dev

This works with all three providers (docker, podman, nerdctl) and skips re-importing if the image is already present on every node. See the Load Images CLI reference for full details.

Something wrong?

Run kinder doctor to check prerequisites and identify issues:

kinder doctor

This checks that Docker (or Podman/nerdctl), kubectl, and other dependencies are installed and reachable.

Delete the Cluster

When you are done:

kinder delete cluster