The issue opens pre-filled with this page title and URL.
The kind create cluster command gives you a complete Kubernetes 1.37 cluster on your machine, in under a minute and without a cent of cloud. This course uses kind and nothing else: it delivers the version taught here, runs upstream Kubernetes (the project's own, called "vanilla"), the one the certifications assess, and starts fast. You will install the binary while verifying its checksum, create a cluster, check that it answers, stop it, delete it and recreate it, then move to a multi-node cluster when a single node is no longer enough.
What you will learn
Install kind while verifying the checksum of the binary.
Create a Kubernetes 1.37 cluster with one command.
Check that the Nodes are ready and that the system Pods are running.
Say where a kind cluster runs and what it adds to your kubeconfig.
Stop, restart and delete a cluster without losing control of the others.
Create a multi-node cluster from a configuration file.
Why learn Kubernetes on a local cluster?
Kubernetes is learned by breaking things, and a disposable cluster lets you do it with no consequence. You will delete Pods to see what recreates them, saturate a node to understand the scheduler, break a manifest to read the error. On a shared cluster, each of these actions disturbs someone. On your machine, a reset takes two commands.
What local brings
Why it matters for learning
Free
No cloud bill, so no reason to hold back
Fast
A new cluster in about twenty seconds
Disposable
You break it, delete it, recreate it
Standard
The kubectl commands are exactly those of production
Swipe to see more
Why kind, and not k3d or minikube?
Three tools create Kubernetes clusters in Docker: kind, k3d and minikube. This course chose kind, and the choice is not a matter of taste. It prepares CNCF certifications that assess Kubernetes in its current version, so it needs a tool that delivers version 1.37 as the project publishes it, with no added component. kind and minikube do; creation time and the behavior of volumes on multi-node clusters tell them apart, as the table shows.
Criterion
kind 0.33
k3d / k3s
minikube 1.39
Delivers Kubernetes 1.37
yes, by default
yes
yes
Runs upstream Kubernetes (no distribution)
yes
no, k3s is a CNCF-certified distribution
yes
Creating a 3-worker cluster
18 s
fast
147 s
Persistent volumes on multi-node
works without tuning
works
needs an extra add-on
Built-in load balancer
no
yes
through a tunnel
Swipe to see more
The durations were measured in September 2026 on the same machine, with images already downloaded. The first launch adds the time to fetch the node image, several hundred megabytes. On storage, the minikube documentation itself warns that its default volume provisioner does not handle multi-node clusters, which requires enabling an additional add-on before tackling persistent volumes.
k3s is not a lesser Kubernetes: it is a distribution certified conformant by the CNCF. The difference is what it runs. kind starts the upstream Kubernetes image as is, whereas k3s is a distribution with its own assembly that bundles, according to its documentation, Traefik, metrics-server and a storage provisioner.
Three reasons make kind the choice. It runs the upstream Kubernetes image unmodified. Its configuration is a YAML file you can version, so your demonstrations replay identically. Finally, no application component is preinstalled: what you see in the cluster is what you put there. The project itself states that kind "was primarily designed for testing Kubernetes".
k3d and minikube remain good tools, documented elsewhere on this site (k3d, kind in detail, both in French). The lessons of this course all assume a kind cluster, so that the displayed outputs match what you see.
Prerequisites
kind needs almost nothing, because it hands the heavy lifting to Docker: each node of the cluster is a container. If docker ps answers, you already hold most of the prerequisites. The objects mentioned below (Node, Pod, Namespace) are those of the lesson key concepts.
Docker installed and working.
kubectl installed in a version compatible with Kubernetes 1.37 (from 1.36 to 1.38), as in the previous lesson (install and configure kubectl).
About 2 GB of available memory for a single-node cluster, margin included: the control plane alone takes a little under 1 GB.
Check that Docker answers
dockerps
A list, even an empty one, means Docker is ready. The message Cannot connect to the Docker daemon means on the contrary that the service is not started: nothing that follows will work until you have fixed it.
Install kind
kind is distributed as a single binary, with no dependency and no service to start. Next to each release, the project publishes one SHA-256 checksum file per platform. Comparing the downloaded binary to this checksum, as you did for kubectl, shows that you are running what the project produced, and not a file altered along the way. The name written in the checksum file is the original name: keep it during the verification and only rename at installation. The commands below are for Linux on an amd64 processor; for another platform, replace the file name.
The verification must display kind-linux-amd64: OK. If it displays FAILED, delete the file, download again and do not install the binary. On macOS and Linux, brew install kind does the same job while handling updates.
Check the installed version
kindversion
Result
kind v0.33.0 go1.26.7 linux/amd64
Take a recent version, 0.33 or later. An earlier version cannot create a Kubernetes 1.37 cluster: it fails on an old API spec message that mentions kubeadm.k8s.io/v1beta3. This message talks about kubeadm and never about kind, which makes the cause hard to guess.
Create your first cluster
A single command is enough. The name you give is used as a prefix for everything that is created: containers, Docker network, kubectl context. Always specify the node image: without it, you inherit the version frozen in your kind binary, which falls behind as Kubernetes publishes new versions.
The lines Installing CNI and Installing StorageClass correspond to two
components that kind installs itself: the network that links the Pods, and
local storage. A new cluster has no other.
The @sha256:… that follows the tag is not decorative: a tag can be republished with different content, whereas a digest designates one content and only one. With the digest, you are sure to get the node image on which this course was written. The tag stays written in front so that the command remains readable.
The Ensuring node image line is the longest at the first launch: it downloads the kindest/node image, which contains a complete Kubernetes. Later creations reuse this image and finish in about twenty seconds. The last line is a suggestion, not a command that was run. However, the kubectl context has already been switched to this new cluster.
What kind created on your machine
Nothing kind just did is magic, and checking it demystifies a lot of Kubernetes. The cluster fits in one Docker container per node, which you can list, inspect and stop by hand. Practical consequence: a stopped cluster is nothing more than a set of stopped containers, and a docker system prune deletes it without going through kind. A running cluster is not touched, because this command only removes stopped containers and networks that no container uses (documentation of docker system prune).
The diagram places each piece. Follow kubectl: it reads the kubeconfig file
to know which cluster to talk to, then sends its commands to the Kubernetes API.
This API runs in the node's Docker container, and it is in that same
container that the Pods live, yours as well as the system ones.
monapp-control-plane kindest/node:v1.37.0 Up 17 seconds
Check that the cluster works
A cluster that answers is not necessarily a ready cluster. Four checks are done in order, from the most general to the most precise, and each one rules out a different cause: the wrong context, an unreachable API, a node not yet admitted, a failing system component.
Check the kubectl context
Terminal window
kubectlconfigcurrent-context
Result
kind-monapp
This check avoids the classic mishap: deploying to the last cluster created while believing you work on the previous one. The output must display kind-monapp.
Query the cluster API
Terminal window
kubectlcluster-info
Result
Kubernetes control plane is running at https://127.0.0.1:34201
CoreDNS is running at https://127.0.0.1:34201/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy
The command then adds a line that suggests kubectl cluster-info dump, which you do not have to run. The port number is drawn at random at creation: yours will be different, and that is normal. What matters is that the command answers. A message The connection to the server ... was refused means that the cluster is stopped, or that the context points elsewhere.
The VERSION column confirms the version you will work on: it must display v1.37.0. In the first seconds after creation, the status can stay NotReady, because the cluster network is not yet in place. This is normal: wait about ten seconds and rerun the command, or let kubectl wait --for=condition=Ready nodes --all wait for you: it only returns when all the nodes are Ready.
Kubernetes already runs with its own components, before you have deployed anything. All of them must eventually display Running. Right after creation, coredns and local-path-provisioner may still show 0/1 in ContainerCreating or Pending: rerun the command after about ten seconds. The random suffix of the names will be different on your machine.
This list of Pods is upstream Kubernetes, with nothing added: the etcd database, the three other control plane components, the network (kindnet and kube-proxy), name resolution (coredns) and the local storage provider. You will find neither an Ingress Controller nor a preinstalled load balancer, unlike what some distributions ship.
Manage the lifecycle of the cluster
Three actions cover everything you will do with a learning cluster: find it again, stop it to reclaim memory, destroy it when it is no longer useful. Only the last one is irreversible.
List your clusters
kind only knows its own clusters: a cluster created with another tool will not appear here, and vice versa.
Terminal window
kindgetclusters
Result
monapp
Stop and restart a cluster
kind has no stop subcommand, and many conclude that the cluster must be destroyed to free memory. That is inaccurate. Since the nodes are Docker containers, docker stop stops them and docker start restarts them without losing anything: your Deployments, your ConfigMaps and your volumes are still there at restart. The name=monapp- filter only touches the nodes of this cluster, your other kind clusters keep running.
Stop all the nodes of the cluster
dockerstop $(dockerps-q--filter"name=monapp-")
Restart them
dockerstart $(dockerps-aq--filter"name=monapp-")
Allow about ten seconds for the nodes to go back to Ready. The action also works on multi-node: on a four-node cluster carrying three replicas, the four nodes came back Ready in 9 seconds and the three Pods were found on their original nodes.
Check the return to normal
kubectlgetnodes
Delete a cluster
Deletion is final and has no confirmation. Everything that lived in the cluster disappears, volumes included. On a learning cluster this has no consequence, but get into the habit of rereading the name before validating: --name designates the only cluster deleted, the others stay intact.
Terminal window
kinddeletecluster--namemonapp
Result
Deleting cluster "monapp" ...
Deleted nodes: ["monapp-control-plane"]
The operation stops the containers, deletes them and removes the cluster context from your kubeconfig. If it was your only cluster, kubectl config current-context then answers error: current-context is not set, and kubectl get nodes fails on localhost:8080: there is no cluster left to query. If you had several clusters, check the active context before the next command.
Apply right away the reflex of the previous aside: recreate monapp, with the same command as at the start. The following lessons work on this single-node cluster, and since the node image is already downloaded, creation takes about twenty seconds.
A single-node cluster is enough to deploy an application, but it hides everything that has to do with distribution: the scheduler (the component that chooses the node of each Pod) has no choice to make, placement constraints have no visible effect, and a node failure cannot be simulated. Adding workers costs little, each node being just one more container.
Beyond one node, kind expects a configuration file rather than command-line options. This is an advantage: the file can be versioned, shared and replayed identically, whereas a command typed once is lost.
kind-multi.yaml
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
- role: worker
labels:
topology.kubernetes.io/zone: zone-a
- role: worker
labels:
topology.kubernetes.io/zone: zone-b
- role: worker
labels:
topology.kubernetes.io/zone: zone-c
The zone labels are not decorative. topology.kubernetes.io/zone is the standard label that cloud clusters put on their nodes to indicate their availability zone. By declaring it here, you get on your machine a cluster that behaves like a distributed cluster, and the placement constraints you write will have an observable effect.
The Joining worker nodes step is the only novelty compared to the single-node cluster: kubeadm, the official cluster installation tool, enrolls each worker with the control plane, as on an installation on servers. The complete cluster is ready in 18 to 30 seconds depending on the machine, with images already downloaded.
Look at the ZONE column: each worker carries the zone declared in the file. The ROLES column shows <none> for the workers, which is normal: Kubernetes puts no role label on a worker node, only the control plane carries one.
This output was taken once the four nodes were ready. Right after creation, a worker can stay NotReady for a few seconds, while its network comes up, exactly like the node of the single-node cluster. Before any observation, therefore, let kubectl wait until all the nodes are ready.
Wait until all the nodes are ready
kubectlwait--for=condition=Readynodes--all
The command returns as soon as the four nodes are Ready. As long as a worker is not, the scheduler places the Pods on the nodes that are already ready: a distribution observed at that moment proves nothing about the real behavior of the cluster.
What the multi-node cluster lets you observe
This four-node cluster takes about 1.7 GB of memory (measured in September 2026): a little under 900 MB for the control plane, about 300 MB per worker, much lighter. If monapp is still running while demo is created, plan for about 2.6 GB in total. You can also stop monapp for the duration of the exercise, with the docker stop command of the section "Stop and restart a cluster", then restart it with docker start before coming back to it.
In exchange for this memory, the cluster makes visible behaviors that a single node cannot show. Do not try to understand everything here: each line points to a lesson later in the course.
What you can finally observe
What becomes possible
Scheduler distribution
Six replicas spread across the three workers instead of piling up on one node
Placement constraints
topologySpreadConstraints and node affinity have a measurable effect
Maintenance mode
kubectl drain empties a node, the Pods move to the others
Node failure
docker stop on a worker makes it NotReady within a minute
Local storage
A PersistentVolumeClaim, an application's storage request, binds on one node and keeps its Pods there
Swipe to see more
The last point deserves an explanation. The storage class shipped by kind is local to the node: once the volume is created on a worker, any Pod that claims it is rescheduled on that same worker. This is the real behavior of local storage, and it explains why production often prefers network storage.
Work with several clusters
kubectlonly talks to one cluster at a time, the one designated by the current context. Creating a cluster switches this context automatically, hence the classic error of the deployment sent to the wrong place. At this point, you have two clusters: monapp with one node and demo with four nodes, created last. The next lesson, kubeconfig and contexts, details this file.
List the known contexts
kubectlconfigget-contexts
Result
CURRENT NAME CLUSTER AUTHINFO NAMESPACE
* kind-demo kind-demo kind-demo
kind-monapp kind-monapp kind-monapp
The asterisk is on kind-demo: the last cluster created became the active context. The following lessons work on monapp, so take back control with use-context.
Switch to a specific cluster
kubectlconfiguse-contextkind-monapp
Result
Switched to context "kind-monapp".
The demo cluster takes memory for nothing as long as no lesson uses it. Delete it: you will recreate it with kind-multi.yaml the day a lesson asks for it.
Check that only monapp remains, and that it is the active context. The kind-demo context disappeared from the kubeconfig together with the cluster.
Check the final state
kubectlconfigget-contexts
Result
CURRENT NAME CLUSTER AUTHINFO NAMESPACE
* kind-monapp kind-monapp kind-monapp
What you do not need to understand right away
You just saw component names go by in kubectl get pods -A. Wanting to understand everything now would be counterproductive: each one has its own lesson later in the course. For now, a cluster that answers kubectl is enough for you.
Component glimpsed
Why ignore it today
etcd
The cluster's internal database, managed for you
kindnet
The Pod network, preinstalled and working
local-path-provisioner
Local storage, already plugged in as the default class
kube-scheduler
The component that places Pods, no tuning needed
kube-proxy
The mechanism that makes Services reachable
Swipe to see more
Troubleshooting
The failures below are frequent blockers at this stage, and most of them do not come from Kubernetes itself. Keep the reflex of the aside "A cluster is thrown away, not repaired": on a learning cluster, destroying and recreating costs about twenty seconds and settles most cases.
The cluster does not start
The causes in the table lie outside Kubernetes: the Docker daemon, the host ports, the available memory. Before looking at the cluster, run docker ps: if this command fails, no step of this lesson can succeed.
Symptom
Likely cause
Solution
Cannot connect to the Docker daemon
Docker is not started
Start the Docker service or Docker Desktop
port is already allocated
The API port is taken
Set another port with networking.apiServerPort in the configuration file
Insufficient memory
Not enough memory
Close applications or reduce the number of nodes
Creation hangs on Joining worker nodes, or a worker never gets an active kubelet
Host inotify limits too low
Raise fs.inotify.max_user_instances and fs.inotify.max_user_watches (see below)
Swipe to see more
The last case is met mostly when several clusters run at the same time. Each kind node runs its own kubelet, and all the containers share the kernel's inotify limits of the host, which are not specific to each container. On the Debian 13 virtual machine of our tests, these limits were 61,865 watches (max_user_watches) and 128 instances (max_user_instances); the first depends on the memory of the machine. With a single-node cluster already running, the creation of demo (four nodes) hung there, and the kubelet log of a worker displayed inotify_init: too many open files.
The kind Known Issues page documents this case and the fix: raise the two limits on the host, delete the failed cluster, then recreate it.
Raise the inotify limits, delete and recreate the cluster
sudosysctlfs.inotify.max_user_watches=524288
sudosysctlfs.inotify.max_user_instances=512
kinddeletecluster--namedemo
Then rerun the kind create cluster --name demo ... command from the section "Create a multi-node cluster": with these values, the four nodes join the cluster in about thirty seconds. These settings disappear when the machine restarts. To keep them, write the two lines fs.inotify.max_user_watches = 524288 and fs.inotify.max_user_instances = 512 in a file of /etc/sysctl.d/, for example 99-kind.conf, then run sudo sysctl --system.
kubectl cannot find the cluster
The ~/.kube/config file may have been overwritten, typically by a cloud tool that regenerates it. Start by listing the contexts: if yours has disappeared, kubectl no longer knows where to connect, even though the containers are still running.
Check the available contexts
kubectlconfigget-contexts
If the context is missing, the simplest is to recreate the cluster:
A Pod in Pending has at least one container that has not started yet. Most often, the scheduler found no acceptable node for it. kubectl logs will therefore return nothing useful, since the container has written nothing. Events are the right source: they say what is blocking.
Look at the last column of the events, MESSAGE: it gives the reason. On a workstation, check first for a lack of resources. Do not confuse this case with a Service of type LoadBalancer whose EXTERNAL-IP column stays at <pending>: that is not a waiting Pod, but the absence of a load balancer on kind, described above.
Command summary
One syntax detail is worth remembering: kind expects the cluster name in the --name option. Without it, the command targets the default cluster, named kind, and not yours.
The guided lab has you write the configuration file of a three-node kind cluster, one control plane and two workers, then create this cluster under the name atelier. To make room for it, its setup removes the clusters of the other labs from the machine, which their own lab recreates. The validation reads your file, then the cluster itself: its name, its three Ready nodes on Kubernetes v1.37.0 and their roles. A cluster created without the file, so with a single node, or under another name, is refused.
Key takeaways
This course uses kind: it delivers upstream Kubernetes 1.37, the one the certifications assess, and a cluster comes up in about twenty seconds once the image is downloaded.
Always specify the node image, tag and digest: without --image, you inherit the version frozen in your binary; without the @sha256:, you depend on a tag that can be republished.
A kind cluster runs in Docker containers (one per node) and adds a kind-<name> context to your kubeconfig.
A kind cluster is thrown away: deleting and recreating costs about twenty seconds and settles most blockages.
kind has no stop command, but a cluster still stops with docker stop, and restarts without losing anything.
Multi-node goes through a configuration file, which can be versioned and replayed, and costs about 1.7 GB for four nodes.
Creating a cluster switches kubectl to it: with several clusters, read the active context with kubectl config current-context and go back to the right one with kubectl config use-context.
kind provides no load balancer: a LoadBalancer Service stays Pending there, and that is the normal behavior of a bare Kubernetes.
Test your knowledge
Seven questions on what costs time when you start: the node image you forget to specify, the context that switched without warning, and what is normal kind behavior rather than a failure.
Knowledge check
Check what you have learned with this interactive quiz
7 questions
5 min
80% to pass
How it works
The timer starts when you click Start
Multiple choice, true/false and short answer questions
You can move between questions
Detailed results are shown at the end
Starts the quiz and the timer
⏱️--:--
0 / 7
Review
(0/0)
--:--
0%
0Correct
0To review
0:00Time
-Level
Score by domain
A domain groups several guides and gets several questions, so its score is more reliable than a per-topic score, which often rests on a single question.
Summary
Strengths
No topic passed at 80% on at least two questions yet.