Skip to content
Français
Account: not signed in, sync available My learning
Select theme
Français

Create your first local Kubernetes cluster with kind

By updated

Improve this page

Logo Kubernetes

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 bringsWhy it matters for learning
FreeNo cloud bill, so no reason to hold back
FastA new cluster in about twenty seconds
DisposableYou break it, delete it, recreate it
StandardThe kubectl commands are exactly those of production

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.

Criterionkind 0.33k3d / k3sminikube 1.39
Delivers Kubernetes 1.37yes, by defaultyesyes
Runs upstream Kubernetes (no distribution)yesno, k3s is a CNCF-certified distributionyes
Creating a 3-worker cluster18 sfast147 s
Persistent volumes on multi-nodeworks without tuningworksneeds an extra add-on
Built-in load balancernoyesthrough a tunnel

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

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.

Install kind with checksum verification
KIND_VERSION=v0.33.0
BASE="https://github.com/kubernetes-sigs/kind/releases/download/${KIND_VERSION}"
curl -sSLO "${BASE}/kind-linux-amd64"
curl -sSL "${BASE}/kind-linux-amd64.sha256sum" | sha256sum --check -
sudo install -m 0755 kind-linux-amd64 /usr/local/bin/kind

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
kind version
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.

Create the cluster
kind create cluster --name monapp --image kindest/node:v1.37.0@sha256:a1ed56cfb0e7b93589bdf97c8cd566405a265939e3620fc4f5de89adff580ae5
Result
Creating cluster "monapp" ...
✓ Ensuring node image (kindest/node:v1.37.0)
✓ Preparing nodes
✓ Writing configuration
✓ Starting control-plane
✓ Installing CNI
✓ Installing StorageClass
Set kubectl context to "kind-monapp"
You can now use your cluster with:
kubectl cluster-info --context kind-monapp

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.

On your machine, kubectl reads the kubeconfig file, which points to the kind-monapp context, then sends its commands to the monapp-control-plane Docker container. In this container, which is the cluster node, the Kubernetes API drives the system Pods and your Pods.Your machinekubectlkubeconfig filecontext kind-monappDocker container: the nodemonapp-control-planeKubernetes APISystem Podsand your Podsmanagesreadssends its commands
Source · SVG
Esc to close, + and − to zoom, scroll to move around. 100 %
Element createdWhat it is
Node containermonapp-control-plane, a container that runs a complete Kubernetes
Docker networkA network named kind, shared by all your kind clusters
kubectl contextkind-monapp, added to the kubeconfig and selected automatically
See the cluster container
docker ps --filter "name=monapp" --format "table {{.Names}}\t{{.Image}}\t{{.Status}}"
Result
NAMES IMAGE STATUS
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.

  1. Check the kubectl context

    Terminal window
    kubectl config current-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.

  2. Query the cluster API

    Terminal window
    kubectl cluster-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.

  3. List the nodes

    Terminal window
    kubectl get nodes
    Result
    NAME STATUS ROLES AGE VERSION
    monapp-control-plane Ready control-plane 25s v1.37.0

    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.

  4. Check the system components

    Terminal window
    kubectl get pods -A
    Result
    NAMESPACE NAME READY STATUS RESTARTS AGE
    kube-system coredns-559f6c778d-8qtdd 1/1 Running 0 15s
    kube-system coredns-559f6c778d-wdpf7 1/1 Running 0 15s
    kube-system etcd-monapp-control-plane 1/1 Running 0 24s
    kube-system kindnet-g9z8s 1/1 Running 0 15s
    kube-system kube-apiserver-monapp-control-plane 1/1 Running 0 24s
    kube-system kube-controller-manager-monapp-control-plane 1/1 Running 0 24s
    kube-system kube-proxy-kqhzt 1/1 Running 0 15s
    kube-system kube-scheduler-monapp-control-plane 1/1 Running 0 24s
    local-path-storage local-path-provisioner-75f7fc7dc5-drgb7 1/1 Running 0 15s

    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
kind get clusters
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
docker stop $(docker ps -q --filter "name=monapp-")
Restart them
docker start $(docker ps -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
kubectl get nodes

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
kind delete cluster --name monapp
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.

Recreate the monapp cluster
kind create cluster --name monapp --image kindest/node:v1.37.0@sha256:a1ed56cfb0e7b93589bdf97c8cd566405a265939e3620fc4f5de89adff580ae5
Result
Creating cluster "monapp" ...
✓ Ensuring node image (kindest/node:v1.37.0)
✓ Preparing nodes
✓ Writing configuration
✓ Starting control-plane
✓ Installing CNI
✓ Installing StorageClass
Set kubectl context to "kind-monapp"
You can now use your cluster with:
kubectl cluster-info --context kind-monapp

Create a multi-node cluster

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.

Create the multi-node cluster
kind create cluster --name demo \
--image kindest/node:v1.37.0@sha256:a1ed56cfb0e7b93589bdf97c8cd566405a265939e3620fc4f5de89adff580ae5 \
--config kind-multi.yaml
Result
Creating cluster "demo" ...
✓ Ensuring node image (kindest/node:v1.37.0)
✓ Preparing nodes
✓ Writing configuration
✓ Starting control-plane
✓ Installing CNI
✓ Installing StorageClass
✓ Joining worker nodes
Set kubectl context to "kind-demo"

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.

Check the nodes and their zones
kubectl get nodes -L topology.kubernetes.io/zone
Result
NAME STATUS ROLES AGE VERSION ZONE
demo-control-plane Ready control-plane 45s v1.37.0
demo-worker Ready <none> 30s v1.37.0 zone-a
demo-worker2 Ready <none> 30s v1.37.0 zone-b
demo-worker3 Ready <none> 30s v1.37.0 zone-c

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
kubectl wait --for=condition=Ready nodes --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 observeWhat becomes possible
Scheduler distributionSix replicas spread across the three workers instead of piling up on one node
Placement constraintstopologySpreadConstraints and node affinity have a measurable effect
Maintenance modekubectl drain empties a node, the Pods move to the others
Node failuredocker stop on a worker makes it NotReady within a minute
Local storageA PersistentVolumeClaim, an application's storage request, binds on one node and keeps its Pods there

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

kubectl only 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
kubectl config get-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
kubectl config use-context kind-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.

Delete the demo cluster
kind delete cluster --name demo
Result
Deleting cluster "demo" ...
Deleted nodes: ["demo-worker3" "demo-worker" "demo-control-plane" "demo-worker2"]

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
kubectl config get-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 glimpsedWhy ignore it today
etcdThe cluster's internal database, managed for you
kindnetThe Pod network, preinstalled and working
local-path-provisionerLocal storage, already plugged in as the default class
kube-schedulerThe component that places Pods, no tuning needed
kube-proxyThe mechanism that makes Services reachable

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.

SymptomLikely causeSolution
Cannot connect to the Docker daemonDocker is not startedStart the Docker service or Docker Desktop
port is already allocatedThe API port is takenSet another port with networking.apiServerPort in the configuration file
Insufficient memoryNot enough memoryClose applications or reduce the number of nodes
Creation hangs on Joining worker nodes, or a worker never gets an active kubeletHost inotify limits too lowRaise fs.inotify.max_user_instances and fs.inotify.max_user_watches (see below)

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.

Read the limits and the kubelet log
sysctl fs.inotify.max_user_watches fs.inotify.max_user_instances
docker exec demo-worker3 journalctl -u kubelet --no-pager | grep inotify

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
sudo sysctl fs.inotify.max_user_watches=524288
sudo sysctl fs.inotify.max_user_instances=512
kind delete cluster --name demo

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
kubectl config get-contexts

If the context is missing, the simplest is to recreate the cluster:

Start again cleanly
kind delete cluster --name monapp
kind create cluster --name monapp --image kindest/node:v1.37.0@sha256:a1ed56cfb0e7b93589bdf97c8cd566405a265939e3620fc4f5de89adff580ae5

A Pod stays in Pending

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.

Read the recent events
kubectl get events -A --sort-by='.lastTimestamp' | tail -20

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.

ActionCommand
Createkind create cluster --name monapp --image kindest/node:v1.37.0@sha256:a1ed56cfb0e7b93589bdf97c8cd566405a265939e3620fc4f5de89adff580ae5
Create multi-nodekind create cluster --name demo --image kindest/node:v1.37.0@sha256:a1ed56cfb0e7b93589bdf97c8cd566405a265939e3620fc4f5de89adff580ae5 --config kind-multi.yaml
Listkind get clusters
Stopdocker stop $(docker ps -q --filter "name=monapp-")
Restartdocker start $(docker ps -aq --filter "name=monapp-")
Deletekind delete cluster --name monapp

Put it into practice

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

  1. 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.
  2. 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.
  3. A kind cluster runs in Docker containers (one per node) and adds a kind-<name> context to your kubeconfig.
  4. A kind cluster is thrown away: deleting and recreating costs about twenty seconds and settles most blockages.
  5. kind has no stop command, but a cluster still stops with docker stop, and restarts without losing anything.
  6. Multi-node goes through a configuration file, which can be versioned and replayed, and costs about 1.7 GB for four nodes.
  7. 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.
  8. 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