Skip to content

Module 1.1: Your First Cluster

▶ Hands-On Lab Available
K8s Cluster beginner 25 min
Launch Lab ↗

Opens in Killercoda in a new tab

Complexity: [MEDIUM]

Time to Complete: 80–110 minutes (long-form read + hands-on exercise)

Prerequisites: Docker installed, Cloud Native 101 completed


Throughout this module, kubectl is the official Kubernetes command-line client, and every runnable command uses the full binary name. Many engineers configure a short interactive alias on their own machines, but aliases are shell-local conveniences and do not expand reliably in scripts, copied command blocks, or non-interactive automation. Using kubectl everywhere keeps the examples clear, portable, and safe to paste into a terminal or lab notebook without hidden setup.

  • Construct and verify a Kubernetes 1.35 local cluster with kind, Docker, and the kubectl command-line workflow.
  • Compare local cluster tools and design a topology that matches the development or testing problem in front of you.
  • Diagnose local cluster startup, networking, kubeconfig, and control plane failures by reading concrete signals from Docker and Kubernetes.
  • Evaluate how control plane and worker node components cooperate, then predict how failures affect scheduling and access.
  • Implement a repeatable local development routine that keeps clusters disposable, version-pinned, and isolated from cloud cost risk.

A Kubernetes cluster is a distributed control system, not a command-line tool that gets installed and forgotten. It runs an authenticated API, a scheduler that places workloads, controllers that continuously reconcile desired state against reality, a container runtime on every node, network translation between pods, and a key-value store holding the truth that the API server protects. The first time most engineers meet that machinery, it is in a shared environment — a team dev cluster, a staging GKE project, sometimes production itself. That is the wrong place to learn. Mistakes in a shared cluster spread outward: one bad manifest blocks other engineers, consumes scarce cloud resources, or quietly hides a bug behind someone else’s active workload. The blast radius of a learning mistake should be the laptop the mistake was made on.

Cloud-managed Kubernetes is the right answer for many production workloads, yet it is a poor first sandbox for learning. A managed control plane can take many minutes to provision, incurs a fee simply for existing, and often brings attached costs for nodes, disks, load balancers, and cross-zone traffic. A forgotten learning cluster can create a real invoice, while a local kind cluster can be deleted without leaving behind cloud infrastructure. This module teaches you to build that local arena, inspect its moving parts, and decide when a single-node cluster is enough versus when a multi-node topology is worth the extra resources.

The goal is not to memorize a cluster creation command. The goal is to develop an operational model: you should know what kind builds, where kubectl sends requests, why kubeconfig controls your identity, which component schedules a Pod, why a local LoadBalancer stays pending, and how to recover when Docker, disk space, version skew, or the control plane fails. Once you can deliberately create, break, inspect, and delete your first cluster, later modules about workloads, services, storage, security, and automation become much less abstract.

Section 1: Anatomy of a Kubernetes Cluster

Section titled “Section 1: Anatomy of a Kubernetes Cluster”

Before you construct a cluster, you need to know what is being assembled. Kubernetes is not a single process that “runs containers”; it is a collection of cooperating services that maintain desired state through an API. A useful first split is the control plane and the data plane. The control plane stores decisions and coordinates work, while the data plane runs the actual application containers on nodes. That separation is why a cluster can keep existing Pods running even when some management components are temporarily unhealthy, but it is also why new changes can freeze when the API or scheduler is unavailable.

Think about an orchestra where the musicians are the worker nodes and the conductor is the control plane. The musicians create the sound, but the conductor decides timing, coordination, and interpretation of the score. In Kubernetes, your YAML manifests are the score: they describe what should exist, not every mechanical step required to create it. The control plane accepts that desired state, stores it, and continuously guides worker nodes toward it. If you remember that model, many confusing behaviors become predictable rather than mysterious.

flowchart TD
subgraph KUBERNETES_CLUSTER [KUBERNETES CLUSTER]
direction TB
subgraph CONTROL_PLANE [CONTROL PLANE]
direction TB
API[API Server]
SCHED[Scheduler]
CM[Controller Manager]
ETCD[etcd]
API --- SCHED
API --- CM
API --- ETCD
end
subgraph WORKER_NODES [WORKER NODES]
direction LR
subgraph NODE_1 [NODE 1]
direction TB
K1[Kubelet]
P1[Proxy]
CE1[Container Engine]
POD1A[POD]
POD1B[POD]
K1 --- CE1
P1 --- CE1
CE1 --- POD1A
CE1 --- POD1B
end
subgraph NODE_2 [NODE 2]
direction TB
K2[Kubelet]
P2[Proxy]
CE2[Container Engine]
POD2A[POD]
POD2B[POD]
K2 --- CE2
P2 --- CE2
CE2 --- POD2A
CE2 --- POD2B
end
end
CONTROL_PLANE -. "Network / gRPC API Calls" .-> WORKER_NODES
end

The API server is the front door of the cluster. Every external command, controller request, and internal status update flows through it, and it is the only component that talks directly to the backing datastore. When you run a command with kubectl, the API server authenticates who you are, authorizes the action through RBAC, applies admission policies, validates the object, and then persists accepted state. If the API server is down, you may still have containers running on worker nodes, but you cannot reliably read or change cluster state through the Kubernetes API.

etcd is the cluster’s memory. It is a strongly consistent key-value store that holds objects such as namespaces, Deployments, Secrets, Services, and Pod records. The scheduler does not keep an independent private database, and neither does the controller manager; they watch the API server and write their decisions back into persisted state. This design makes Kubernetes auditable and declarative, but it also means that etcd health is not optional. If the datastore cannot accept writes, the cluster cannot safely accept new desired state.

The scheduler is the matchmaker. It watches for Pods that exist in the API but do not yet have a node assignment, filters nodes that cannot run them, scores the remaining nodes, and writes the selected node name back onto the Pod object. It does not start containers itself. The kubelet on the chosen node later observes the assignment and works with the container runtime to make the Pod real. This distinction is important when debugging: a Pending Pod is often a scheduling problem, while a Pod assigned to a node but failing to start is usually a node, image, runtime, or configuration problem.

The controller manager is the cluster’s collection of reconciliation loops. A controller repeatedly compares observed state with desired state and takes small corrective actions. If a Deployment says three replicas should exist and one Pod disappears, the relevant controller creates another Pod object. If a node stops reporting, the node controller marks that condition. Kubernetes feels automatic because many controllers are constantly watching and nudging state toward the declarations you made. They are not magic; they are programs repeatedly asking, “What changed, and what needs to happen next?”

Worker nodes run the kubelet, kube-proxy, and a container engine such as containerd. The kubelet receives Pod specifications assigned to its node and ensures the required containers are running and reporting health. Kube-proxy manages network rules so Services can route traffic to changing Pod IPs. The container engine pulls images and asks the operating system kernel to create isolated processes using cgroups and namespaces. Kubernetes also delegates networking to CNI plugins and runtime integration to the CRI, which is why clusters can use different networking and runtime implementations while exposing the same Kubernetes API.

This component split also explains why Kubernetes debugging is usually a process of narrowing responsibility. If the API server rejects a manifest, you inspect schema, authentication, authorization, or admission. If a Pod stays Pending, you inspect scheduling constraints and node capacity. If a Pod is assigned but not running, you inspect kubelet events, image pulls, runtime errors, probes, and volumes. If traffic reaches a Service but not a backend, you inspect selectors, endpoints, kube-proxy behavior, and network policy. A local cluster gives you a place to practice that narrowing without waiting for a production incident to teach it under pressure.

Pause and predict: If the kube-scheduler process crashes but the API server and etcd remain healthy, what happens when you create a new Deployment?

Check your prediction

The request can still be accepted and stored, but the new Pods remain Pending because nothing assigns them to nodes. Existing running Pods usually continue because kubelets already know about them. Separate “the API accepted my desired state” from “a worker can actually execute it.”

Section 2: Choosing a Local Kubernetes Tool

Section titled “Section 2: Choosing a Local Kubernetes Tool”

Local Kubernetes tools all answer the same high-level need, but they do not build the same kind of environment. Some tools create virtual machines, some run clusters inside containers, and some integrate with a desktop virtualization layer. The right choice depends on whether you care most about startup speed, distribution fidelity, resource limits, multi-node behavior, or convenience. For this curriculum, we use kind because it is fast, scriptable, upstream-oriented, and excellent for disposable clusters used in tests and exercises.

ToolUnderlying ArchitecturePrimary Use CaseProsCons
minikubeVirtual machines, containers, or bare metalTraditional local developmentMultiple driver choices.Driver and runtime choices affect setup.
kind (Kubernetes IN Docker)Docker Containers acting as NodesCI/CD pipelines, automated testing, rigorous local devExtremely fast, identical to pure upstream Kubernetes, highly customizable multi-node topologies.Requires Docker daemon. Complex networking edge cases when exposing services to host.
k3dDocker Containers running k3sEdge computing simulation, IoTUses lightweight k3s.k3s is a compliant Kubernetes distribution with bundled components and its own defaults.
Docker Desktop / ColimaIntegrated Hypervisor / Lightweight VMQuick validation for Mac/Windows usersZero configuration, GUI integration, easy volume mounting.Inflexible compared with scriptable tools; Docker Desktop Kubernetes was historically single-node, though newer versions can provision multi-node clusters via the kind provisioner. Tightly coupled to the virtualization engine.

kind stands for Kubernetes IN Docker, and the name is literal. A kind node is a Docker container that is privileged enough to run Kubernetes node processes inside it. When you create a three-node kind cluster, Docker starts three node containers, and each node container runs its own kubelet and containerd. The cluster feels distributed to Kubernetes because each node has a separate identity and network address, even though all of those nodes are ultimately containers on your workstation. This is not the same as production hardware, but it is close enough to teach scheduling, kubeconfig, controller behavior, and many networking patterns.

flowchart TD
Host[Your Laptop/Workstation]
DockerDaemon[Docker Daemon on Host]
Host --> DockerDaemon
subgraph kind Cluster
Node1[kind-control-plane Container]
Node2[kind-worker-1 Container]
Node3[kind-worker-2 Container]
end
DockerDaemon --> Node1
DockerDaemon --> Node2
DockerDaemon --> Node3
subgraph Inside kind-control-plane
API[API Server daemon]
ETCD[etcd daemon]
KubeletCP[Kubelet process]
ContainerdCP[containerd process]
end
Node1 -.-> API
Node1 -.-> ETCD
Node1 -.-> KubeletCP
Node1 -.-> ContainerdCP
subgraph Inside kind-worker-1
KubeletW1[Kubelet process]
ContainerdW1[containerd process]
PodA[Your Application Pod]
end
Node2 -.-> KubeletW1
Node2 -.-> ContainerdW1
Node2 -.-> PodA

The hidden tradeoff is that a kind cluster depends on the host Docker daemon. If Docker stops, the node containers stop, and your cluster disappears with them. That makes kind a poor home for durable state and a strong home for learning, integration testing, and quick reproduction. A local cluster should be treated like a whiteboard, not a records archive. Build it, test the hypothesis, export logs if you need evidence, and delete it when the exercise is over.

That tradeoff is exactly why kind fits the early Kubernetes learning path. You are not trying to preserve customer data, survive a zone outage, or prove a managed cloud integration. You are trying to learn the shape of the API, observe controllers, compare node topology, and build confidence with failure. The cheaper the environment is to recreate, the more willing you become to test dangerous questions: what if the scheduler is gone, what if an image is missing, what if the active context is wrong, or what if the host Docker daemon stops. Those experiments are valuable precisely because cleanup is quick.

Before running commands, choose the smallest topology that can prove the behavior you care about. A single-node cluster is enough for basic API interaction, simple manifests, and most early workload tests. A multi-node cluster becomes valuable when you need scheduling spread, node selectors, taints, tolerations, DaemonSets, or realistic network paths between nodes. Which approach would you choose here and why: testing a basic ConfigMap mount, or testing whether two replicas land on different nodes? The first needs little topology; the second requires a cluster that can express placement.

Kubernetes is secure by default, so kubectl cannot simply send anonymous HTTP requests to a cluster and hope for the best. It needs an API server address, a trusted certificate authority, and credentials that identify you. That information lives in kubeconfig, usually at ~/.kube/config. A kubeconfig file is not merely a convenience file; it is the passport that tells your client where to travel, which identity to present, and which cluster/user pairing is active right now.

The structure has three major pieces. A cluster entry defines the destination API server and the certificate authority data used to verify that server, much like knowing which country you are entering and trusting its passport control. A user entry defines the identity material, such as certificates, tokens, or an external login plugin. A context binds one user to one cluster, optionally with a default namespace. Switching context changes where future commands go and which credentials they use, which is why context mistakes can be dangerous.

Kubeconfig becomes especially important once you have more than one cluster. A single file might contain a local kind context, a staging context, and a production context, all available to the same command-line tool. That convenience is powerful, but it means the active context is part of the safety model. Before applying anything that creates, deletes, or changes workloads, make it a habit to ask, “Which cluster will receive this request, which user will I be, and which namespace will be assumed?” Beginners often treat kubeconfig as plumbing; operators treat it as a control surface.

Here is a simplified kubeconfig. The certificate fields are shortened because real files contain long base64-encoded values, and those values are sensitive when they grant cluster access. Notice that the context does not contain a server URL or a private key itself; it references the named cluster and user. That indirection is what lets one kubeconfig file hold multiple clusters and multiple identities without duplicating every field.

apiVersion: v1
kind: Config
preferences: {}
current-context: kind-dojo-basics
clusters:
- cluster:
certificate-authority-data: LS0tLS1CR...
server: https://127.0.0.1:6443
name: kind-dojo-basics
users:
- name: kind-dojo-basics
user:
client-certificate-data: LS0tLS1CR...
client-key-data: LS0tLS1CR...
contexts:
- context:
cluster: kind-dojo-basics
user: kind-dojo-basics
name: kind-dojo-basics

The following are illustrative configuration commands, not instructions to change your current context. Context selection is persisted in kubeconfig and can affect other clients using that file; it is not merely shell-local. Default config view redacts credential fields, but metadata may still be sensitive. The runnable lab below uses its own kubeconfig and explicit contexts; never add --raw or print unrelated credentials.

# View configuration with credential fields redacted
kubectl config view
# See all the context "stamps" in your passport
kubectl config get-contexts
# Explicitly switch your active context
kubectl config use-context <context-name>

Sometimes you do not want to modify your default kubeconfig. A teammate might send a temporary staging config, or a CI job might generate a short-lived file for one deployment. The KUBECONFIG environment variable lets you point the client at a specific file for the current process environment. That is useful because it makes access explicit, temporary, and reversible instead of merging unknown credentials into your everyday configuration.

export KUBECONFIG=/path/to/my/temporary/config.yaml
kubectl get nodes # Operates against the temporary cluster

You can also combine multiple kubeconfig files by separating paths with a colon on Unix-like systems. Kubernetes reads them as a merged view, which is helpful when your personal clusters, staging clusters, and generated CI credentials live in separate files. The merge behavior is powerful, but it also means names matter. Two contexts with the same name can create confusing collisions, so use clear cluster names when creating local environments.

export KUBECONFIG=~/.kube/config:/path/to/another/config.yaml

Pause and predict: If a kubeconfig containing administrator credentials for a production cluster is committed to a public repository, what happens next?

Check your prediction

Treat it as an incident now. Automated scanners look for exposed credentials, and an attacker with valid cluster credentials can read Secrets, create workloads, or run compute at your expense. Kubeconfig files are keys, not notes.

Section 4: Bootstrapping and Verifying the First Cluster

Section titled “Section 4: Bootstrapping and Verifying the First Cluster”

Start with Docker Fundamentals: Installing Docker if you have a clean machine. Installing a client binary does not start a container engine. Choose one local engine and follow its platform instructions; you do not need several engines for this lesson.

PlatformSetup path
macOSInstall and launch Docker Desktop for Mac, choosing Apple silicon or Intel as appropriate. An existing OrbStack installation is another Docker-compatible environment; start it and verify its Docker context.
UbuntuFollow Docker Engine’s Ubuntu installation steps for a supported release. Confirm the daemon is running and your account has authorized access to its socket. Do not copy Ubuntu package commands onto a different distribution.
Other Linux distributionsUse the Docker Engine installation guide for your distribution rather than assuming its package manager or service setup matches Ubuntu.

Next install kind using its Quick Start, selecting the v0.33.0 release binary for your operating system and CPU architecture. This lesson’s image pins are from the v0.33.0 release notes, checked 2026-11-03; for another kind release, check its release notes and update the pins. For kubectl on macOS or Linux, use the specific-version download procedure with v1.35.0, not the page’s latest-release default or stable.txt. For example, the Apple-silicon binary is https://dl.k8s.io/release/v1.35.0/bin/darwin/arm64/kubectl; Linux x86-64 uses https://dl.k8s.io/release/v1.35.0/bin/linux/amd64/kubectl. Verify the matching .sha256 download as the instructions show, then install using your platform’s steps. This client supports both the v1.35.8 lesson clusters and the v1.34.11 comparison. An engine-bundled client may have a different version.

Open a dedicated terminal and run bash before the checks and helpers below. Require kubectl minor v1.35 for this lesson; the check exits that dedicated shell if a different minor is selected.

Terminal window
docker version || exit 1
docker context show || exit 1
kind version || exit 1
client_version=$(kubectl version --client -o yaml) || exit 1
printf '%s\n' "$client_version"
printf '%s\n' "$client_version" | grep -Eq '^ gitVersion: v1[.]35[.]' || { echo 'Install kubectl v1.35.x before continuing' >&2; exit 1; }

Require a successful Docker Server response, not just a Client version, and check which local engine the context selects. If the daemon is unavailable, start your chosen engine and retry before creating clusters. These checks establish tool access, not ownership of existing resources. Keep this dedicated Bash shell for the lesson rather than assuming the default terminal shell supports every helper.

Use only an authorized local Docker endpoint under your exclusive control, with no concurrent cluster creators. After installing the tools, open a dedicated Bash terminal and run this setup once. It points KUBECONFIG at a private file for this shell; your default file stays unchanged. The helpers refuse existing names and record successful creation, including a Docker object ID. These receipts are scoped evidence, not general ownership proof: stop if the shell, runtime endpoint, or ownership becomes uncertain. Failed partial creations require inspection with the lab owner, not automatic deletion. The other tools compared above are alternatives, not extra lab steps.

Terminal window
umask 077
lesson_dir=$(mktemp -d "${TMPDIR:-/tmp}/kubedojo-cluster.XXXXXX") || exit 1
cd "$lesson_dir" || exit 1
lesson_dir=$PWD
lesson_kubeconfig_was_set=${KUBECONFIG+x}
lesson_previous_kubeconfig=${KUBECONFIG-}
export KUBECONFIG="$lesson_dir/config"
printf 'Lesson workspace: %s\n' "$lesson_dir"
lesson_workspace() { test "$PWD" = "$lesson_dir" && test -d "$lesson_dir" && test "$KUBECONFIG" = "$lesson_dir/config"; }
lesson_finish() {
if test "$lesson_kubeconfig_was_set" = x; then export KUBECONFIG="$lesson_previous_kubeconfig"; else unset KUBECONFIG; fi
}
lesson_create() {
lesson_workspace || return 1
local name=$1 existing node; shift
test ! -e "$lesson_dir/$name.owned" || return 1
existing=$(kind get clusters) || return 1
if printf '%s\n' "$existing" | grep -Fxq "$name"; then echo 'Name exists: stop and choose an unused name' >&2; return 1; fi
kind create cluster --name "$name" --kubeconfig "$KUBECONFIG" "$@" || return 1
node=$(docker inspect --type=container --format '{{.Id}}' "$name-control-plane") || return 1
[[ "$node" =~ ^[0-9a-f]{64}$ ]] || return 1
printf '%s\n' "$node" > "$lesson_dir/$name.owned"
}
lesson_delete() {
lesson_workspace && test -s "$lesson_dir/$1.owned" || return 1
kind delete cluster --name "$1" --kubeconfig "$KUBECONFIG" &&
rm "$lesson_dir/$1.owned"
}
lesson_fail() {
lesson_workspace && test "$1" = broken-dojo || return 1
local node; node=$(cat "$lesson_dir/$1.owned") || return 1
[[ "$node" =~ ^[0-9a-f]{64}$ ]] || return 1
docker kill "$node"
}

The setup exits the dedicated shell if workspace creation or navigation fails. Keep the printed directory and protect its kubeconfig as a credential. Stop after any failed command; do not continue to dependent steps. kubectl is the real client: its context commands now edit only this private file. Close the lesson shell when finished to discard its environment and functions. Substitute an unused name consistently on collision; never remove the conflicting cluster to make an example work.

Treat the helper block as lesson setup; you do not need to memorize its Bash syntax. lesson_create runs kind and saves a creation receipt, lesson_delete checks for that receipt before cleanup, and lesson_fail targets the recorded container for the failure exercise. You will still use normal kubectl commands to inspect the cluster and switch contexts.

Keep the API server on kind’s loopback binding; do not change it to 0.0.0.0 or add public port mappings for this lesson. This also applies on a remote Linux machine: its API should stay private to that host. The exercise needs no publicly exposed application or Docker API port.

A default kind cluster is created with one command. In that default topology, one container acts as both control plane and worker node. That is acceptable for first contact because it gives you the API server, etcd, scheduler, controller manager, kubelet, kube-proxy, CoreDNS, and a runtime in one compact environment. Pin the node image to the v1.35.8 tag and digest shown here so the exercise does not silently follow kind’s changing default.

Terminal window
lesson_create dojo-basics --image kindest/node:v1.35.8@sha256:07b2536e30b803ed61d1677a79df6115f798ce64c80f9e22f6ed45afd09323c0

When this command runs, kind pulls the kindest/node image, starts a privileged node container, generates certificates, runs kubeadm init, starts control plane components, installs networking, and writes access details into kubeconfig. That final kubeconfig step is why your next kubectl command knows where the new API server lives. The cluster is local, but it is not fake: you are talking to a real Kubernetes API server whose loopback port is mapped from your host into the node container.

This sequence is worth slowing down because every step leaves a different diagnostic trail. A pull failure points toward registry access or disk space. A node container failure points toward Docker health, permissions, or resource allocation. A kubeadm init failure points toward Kubernetes bootstrap logs inside the node. A kubeconfig failure points toward client access rather than cluster creation. When you read a kind error, do not collapse all of those stages into “cluster failed.” Identify which stage failed, then choose the tool that can see that layer.

The --image flag pins the Kubernetes version instead of relying on kind’s changing default. Pinning matters when you are learning from written material because Kubernetes evolves. A command, API default, or warning can change between releases, and you want differences to be deliberate rather than accidental. In real teams, version pinning also makes bug reports reproducible because everyone can create the same local cluster shape before discussing the failure.

Terminal window
kubectl cluster-info

The cluster-info output should show the Kubernetes control plane running at a loopback address such as https://127.0.0.1:42315, plus system services such as CoreDNS. This confirms three things at once: kubeconfig points to the new cluster, your credentials authenticate successfully, and the API server can answer requests. If this command fails, do not jump straight to workload debugging. First prove whether the client can reach the control plane.

Terminal window
kubectl get nodes

You should see one node named dojo-basics-control-plane in the Ready state. In many production clusters, control plane nodes are tainted so normal workloads cannot run there. In a default single-node kind cluster, the tool makes that node schedulable so you can run application Pods without needing separate workers. That is convenient, but it is also a reminder that local clusters intentionally trade some production separation for speed and simplicity.

Terminal window
kubectl get pods --namespace kube-system

System Pods in kube-system show the cluster running itself as Kubernetes-managed workloads. You should see components such as etcd, kube-apiserver, kube-controller-manager, and kube-scheduler. This is a useful mental shift: Kubernetes does not hide every internal process from you. Many core components are visible as Pods, which means you can inspect their status, logs, and restarts using the same habits you will later use for your own workloads.

Do not skip verification just because the create command ended successfully. A command can return after bootstrapping while some background components are still settling, image pulls are completing, or CoreDNS is restarting. The node list, system Pod list, and cluster-info output together give you a fast health snapshot from three angles: node readiness, control plane reachability, and add-on state. In professional workflows, those checks become preconditions for running tests. You want failures to point at the thing under test, not at a half-created cluster that was never ready.

Pause and predict: After you create a default dojo-basics kind cluster, what does docker ps on the host show?

Check your prediction

Expect one outer Docker container for the single kind node, not one Docker container per Kubernetes Pod. The Pods run through containerd inside the node container. Host Docker sees the node. Kubernetes sees the Pods inside it.

Section 5: Local Networking and Multi-Node Design

Section titled “Section 5: Local Networking and Multi-Node Design”

Networking is where local clusters often stop feeling intuitive. Your Pods receive IP addresses from a cluster network, but your laptop does not automatically route to that Pod network. In a kind cluster, nodes sit on a Docker bridge network, and the API server is the one port mapped by default so kubectl can communicate. If you deploy a web application, a Pod IP such as 10.244.0.5 is meaningful inside the cluster, but your browser has no native route to that address from the host.

The quickest access pattern is port forwarding. A command like kubectl port-forward svc/my-web-app 8080:80 opens a local client-side tunnel through the API server to a Service or Pod. It is useful for debugging because it requires no permanent cluster networking setup. A separately authorized ingress exercise can configure kind port mappings before creation, explicitly using a loopback listenAddress for private practice; this lesson adds no such mappings. For local LoadBalancer behavior, you need an implementation such as MetalLB because your laptop does not have a cloud load balancer controller.

Pause and predict: If you start a port-forward, load the application in your browser, and then close the terminal window, what happens to the browser connection?

Check your prediction

The tunnel disappears immediately because the forwarding path is maintained by the local process. Kubernetes did not create a durable Service exposure on your host. It carried traffic through a live debugging connection. Closing the terminal ends that connection.

A single-node cluster is enough for many first exercises, but it cannot represent placement constraints. If every control plane process and every workload share one node, you cannot test whether replicas spread across nodes, whether a DaemonSet runs once per node, or whether a workload with a node selector lands only where intended. Multi-node kind clusters solve that by declaring multiple node containers in a configuration file. You still run locally, but Kubernetes now has a meaningful set of nodes to choose from.

The multi-node step also prepares you for a key production reality: Kubernetes placement is an API decision, not a wish. You can request replicas, set affinity rules, add tolerations, label nodes, and constrain resources, but the scheduler still evaluates the current node set before binding each Pod. In a one-node cluster, many placement mistakes are invisible because there is nowhere else to go. In a multi-node cluster, those mistakes surface as Pending Pods, unexpected distribution, or workloads landing on nodes you did not intend. That feedback is exactly what a local training topology should reveal.

Write the topology only from the initialized lesson workspace. The guard runs before the shell opens the output file:

Terminal window
lesson_workspace && cat > multi-node-config.yaml <<'YAML'
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
# The control plane node (API server, etc.)
- role: control-plane
# The first worker node (Application workloads)
- role: worker
# The second worker node (Application workloads)
- role: worker
YAML

Delete only the successfully created lesson cluster using the receipt-checked helper before creating the next topology. Deletion destroys its workloads and data; it is appropriate only for this disposable run. If creation failed, ownership changed, or the helper refuses, stop rather than deleting by a familiar name.

Terminal window
lesson_delete dojo-basics

Now create the multi-node topology. kind starts three Docker containers, initializes the first as the control plane, generates join material, and has the other two join as workers over the Docker bridge network. The command takes a little longer than the single-node cluster, but it gives you a topology that can teach scheduling decisions instead of merely API submission.

Terminal window
lesson_create dojo-multi --config multi-node-config.yaml --image kindest/node:v1.35.8@sha256:07b2536e30b803ed61d1677a79df6115f798ce64c80f9e22f6ed45afd09323c0

Verify the architecture through Kubernetes, not only through Docker. The Kubernetes node list is what the scheduler uses when it chooses placement, so it is the view that matters for later workload behavior. Worker nodes normally show <none> in the roles column unless you label them, which is expected and not an error.

Terminal window
kubectl wait node --all --for=condition=Ready --timeout=120s
kubectl get nodes

Illustrative output for the distributed topology (ages will differ):

NAME STATUS ROLES AGE VERSION
dojo-multi-control-plane Ready control-plane 2m14s v1.35.8
dojo-multi-worker Ready <none> 1m58s v1.35.8
dojo-multi-worker2 Ready <none> 1m58s v1.35.8

Run kubectl get nodes -o wide and examine the internal IPs. Each node is really a Docker container, yet Kubernetes sees distinct node addresses and can schedule across them. That makes the topology valuable for practicing node labels, taints, tolerations, affinity, anti-affinity, and DaemonSets. If you later test a workload that must run one copy per node, the multi-node cluster is the first topology in this module that can prove the behavior rather than merely accept the manifest.

Multi-node local clusters are still approximations, so use them honestly. They do not reproduce separate physical machines, independent power domains, real cloud routing, or storage hardware failure. They do reproduce enough of the Kubernetes control loop to teach scheduling, node identity, Pod placement, and many networking patterns. That boundary matters when reporting results. You can say, “This manifest schedules correctly across three kind nodes,” but you should not claim it proves production availability. Good local testing answers the Kubernetes question first and leaves cloud-specific questions for environments that actually contain those cloud behaviors.

Section 6: Troubleshooting and Local Development Discipline

Section titled “Section 6: Troubleshooting and Local Development Discipline”

Local cluster failures usually come from the host environment. Docker might be stopped, Docker might lack memory, the disk might be full, your client might be outside the supported Kubernetes version skew, or a port might already be bound by another process. These are not distractions from Kubernetes learning; they are the first diagnostic layer. Production debugging also starts by separating client, control plane, node, network, and storage signals. Local clusters simply make those layers visible and cheap to reproduce.

The fastest troubleshooting loop starts with the error boundary. If kind cannot create a node container, Kubernetes is not ready for inspection yet. If the node exists but the API is unreachable, inspect control plane logs and kubeconfig. If the API is reachable but a workload is Pending, inspect events and scheduling constraints. If the workload is Running but inaccessible, inspect Services, endpoints, port-forwarding, and ingress mappings. Writing those branches down may feel mechanical, but it prevents a common beginner mistake: running random commands until one seems relevant.

If kind create cluster hangs at control-plane startup, inspect Docker first. A Kubernetes control plane needs memory, and the node image is not small. Docker Desktop users should allocate enough memory for the engine, especially for multi-node clusters, while Linux users should check host pressure and swapping. When the API is not available yet, kubectl cannot help you, so you bypass Kubernetes and read the node container logs directly through Docker.

Terminal window
docker logs <container-id>

Port conflicts produce a different failure shape. By default, kind selects a random open host port for the API server; check the active address with kubectl cluster-info or the node mapping with docker port primary-dojo-control-plane. For an explicitly configured host port, use lsof -i :PORT on macOS or Linux, or netstat -tulpn | grep PORT on Linux, substituting that port. Prefer choosing a different configured port over killing unknown processes.

Version skew can affect a client that is either too old or too new. Kubernetes supports kubectl within one minor version of the API server, so choosing the latest client is not always the repair. Check both versions and select a compatible client; use v1.35 for this lesson’s v1.35/v1.34 comparison. Do not diagnose a client compatibility problem from healthy Docker containers alone.

The most basic failure is a missing container runtime. kind cannot create nodes if Docker is not reachable, and the error often says exactly that:

failed to create cluster: failed to get docker info: Cannot connect to the Docker daemon at unix:///var/run/docker.sock.

On Linux, verify the service and permissions. On desktop platforms, confirm the virtualization engine is running before retrying. The docker group grants root-level privileges; accept that trade-off only on a machine you own, and consult Docker’s post-install guide for group and rootless options.

Terminal window
systemctl status docker

Disk pressure can come from node images, writable layers, or volumes, but the Docker daemon may also hold other projects. Inspect usage first. Do not run host-wide prune commands for this lesson; use the guarded cluster cleanup for successful creations and ask the runtime owner to review any retained artifacts individually. Unused does not mean disposable.

Terminal window
docker system df

When a cluster fails in a way worth studying, export logs before deleting it. kind can collect kubelet, container runtime, API server, and other component logs from node containers into a local directory. This is the local version of preserving evidence during an incident. It lets you inspect after the cluster is gone and gives teammates concrete data instead of a vague report that “kind broke.”

Terminal window
kind export logs ./kind-troubleshooting-logs --name dojo-multi

Strong local development discipline keeps these problems bounded. Pin Kubernetes versions, name clusters clearly, check the active context before applying manifests, load local images into the cluster when needed, and delete idle clusters when the test is complete. Avoid manually editing files inside node containers because that creates invisible state drift; put node-level changes into kind configuration and recreate the cluster. The point of local Kubernetes is not to preserve one perfect snowflake. The point is to make realistic environments disposable.

A useful routine is to start each session with a named cluster, a clear version, and one written hypothesis. For example, “I am testing whether this Deployment schedules on workers labeled workload=frontend in Kubernetes 1.35.” After the test, capture the commands, events, and final observation, then delete the cluster. That routine gives you reproducible evidence instead of a half-remembered terminal session. It also makes later automation obvious: once the manual sequence is clear, a script or Makefile can recreate it consistently for teammates and CI.

Reliable local Kubernetes work depends less on one clever command and more on repeatable habits. The patterns below are the habits worth building early because they scale into team workflows. The anti-patterns are tempting because they feel faster in the moment, but they create the exact hidden state, cost, and ambiguity that local clusters are supposed to remove.

PatternWhen to Use ItWhy It Works
Disposable named clustersAny learning lab, reproduction case, or integration testNames make kubeconfig contexts obvious, while deletion keeps resource use and state drift under control.
Version-pinned node imagesCurriculum, CI, operator testing, and bug reproductionPinning a node image avoids accidental release drift.
Declarative topology filesMulti-node tests, ingress port mappings, or kubeadm patchesA checked-in config can be reviewed, recreated, and shared instead of reconstructed from memory.
Host-first diagnosticsCluster creation failures, Docker errors, disk pressure, and port conflictsLocal clusters depend on the host runtime, so Docker and OS signals often explain failures before Kubernetes exists.
Anti-PatternWhat Goes WrongBetter Alternative
Treating a local cluster as durable infrastructureManual changes disappear or become impossible to reproduce after deletionStore manifests and kind configs, then recreate the cluster to prove repeatability.
Applying manifests without checking contextWorkloads land in the wrong cluster, sometimes a costly shared environmentRun kubectl config current-context or inspect contexts before risky actions.
Expecting LoadBalancer Services to work like cloud providersEXTERNAL-IP remains pending because no cloud controller provisions hardwareUse port-forwarding, mapped ingress, or a local load balancer implementation.
Leaving many clusters idleCPU, memory, ports, and disk are consumedInspect with kind get clusters; delete only successfully created lesson clusters through the guarded helper.

Use a local cluster when the learning or test question is about Kubernetes API behavior, scheduling, manifests, controllers, Services, or basic networking. Use a cloud-managed cluster when the question depends on cloud integrations such as managed load balancers, IAM identity, persistent disks, autoscaling groups, or production-grade failure domains. Use a single-node local cluster when the topology does not matter. Use a multi-node local cluster when placement, node-specific behavior, DaemonSets, or inter-node networking are part of the hypothesis.

Start with the question you need to answer
|
+-- Is the question about cloud-managed integrations?
| +-- Yes: use a real cloud cluster with strict cost controls.
| +-- No: continue locally.
|
+-- Does the behavior depend on multiple nodes?
| +-- Yes: create a multi-node kind cluster from YAML.
| +-- No: create a single-node kind cluster.
|
+-- Do you need deterministic version behavior?
| +-- Yes: pin kindest/node:v1.35.8@sha256:07b2536e30b803ed61d1677a79df6115f798ce64c80f9e22f6ed45afd09323c0 or the required test version.
| +-- No: still record the version so results are explainable.

The practical decision is usually about feedback speed and fidelity. Local clusters give rapid feedback and low risk, but they cannot prove every cloud behavior. Cloud clusters give high fidelity for provider integrations, but they cost money and take longer to rebuild. Good engineers do not pick one forever; they choose the cheapest environment that can honestly answer the question. For this module, the honest question is how Kubernetes itself behaves, so a local kind cluster is the right default.

  1. The name “Kubernetes” comes from a Greek word associated with a helmsman or pilot, which matches the project’s steering-wheel logo.
  2. kind began as infrastructure for testing Kubernetes itself, which explains why it is fast, disposable, and friendly to automation.
  3. The abbreviation k8s is a numeronym: it keeps the first and last letters of Kubernetes and replaces the eight letters between them with 8.
MistakeWhy It HappensHow to Fix It
Building an image on the host and expecting a kind Pod to find itThe node container has its own internal containerd, separate from the host Docker image list.Run kind load docker-image my-app:v1 --name <cluster-name> or push the image to a registry the cluster can reach.
Forgetting which kubeconfig context is activekind updates kubeconfig automatically, and multiple clusters can coexist in one file.Inspect contexts before applying changes and use clear cluster names such as kind-dojo-basics.
Assuming a local LoadBalancer Service provisions an external IPThere is no cloud provider controller on your laptop to create external load balancer infrastructure.Use kubectl port-forward, configured ingress port mappings, or a local implementation such as MetalLB.
Leaving idle clusters running for daysNode containers, images, and volumes consume host resourcesUse recorded creation evidence and guarded lesson cleanup; a familiar name alone never authorizes deletion.
Editing a node container by handManual docker exec changes are invisible to your cluster configuration and vanish on recreate.Encode node behavior in kind config, manifests, or automation, then recreate the cluster to prove it persists.
Ignoring Docker memory and disk limitskind relies on Docker, so host resource pressure prevents Kubernetes components and images from starting.Allocate enough Docker memory, keep free disk space, and inspect Docker logs when cluster creation fails.
Using an incompatible client/server pairKubernetes supports limited minor-version skew in either direction.Select compatible versions; the newest client is not necessarily suitable for an older cluster.
[Tests LO4] A Pod has already been assigned to a node but its container fails to start. Which component should you inspect first? Inspect the kubelet and node events: the scheduler assigns the Pod, while the kubelet works with the container runtime to start its containers.
[Tests LO2] Your team needs to test a DaemonSet that must run one Pod on every node. Should you use a single-node or multi-node `kind` cluster, and what would the single-node test fail to prove? Use a multi-node `kind` cluster because the behavior depends on node count and placement. A single-node cluster can prove that the DaemonSet object is accepted and that one Pod can run, but it cannot prove per-node scheduling across multiple workers. A multi-node topology lets you verify that each node receives exactly one Pod and that node-level conditions or labels affect the outcome as expected.
[Tests LO3] A developer builds `my-app:v1` with Docker, applies a Deployment, and gets `ImagePullBackOff` in `kind`. The image name is correct. What should they check and do? They should check whether the image was loaded into the `kind` cluster's internal runtime. Host Docker can know about an image while the node container's `containerd` cannot see it, so Kubernetes tries to pull the image from a registry and fails. The local fix is to run `kind load docker-image my-app:v1 --name ` before creating or restarting the Pod. In team workflows, pushing to a registry can be more repeatable.
[Tests LO1] You are required to reproduce a bug on Kubernetes v1.35.8, but your default `kind` installation creates a different version. What is the safest local workflow? Use `lesson_create repro-135 --image kindest/node:v1.35.8@sha256:07b2536e30b803ed61d1677a79df6115f798ce64c80f9e22f6ed45afd09323c0` in the initialized lesson shell, then record the observed version. A pinned image supports reproduction; it does not authorize adopting or deleting an existing cluster. Stop on collision or failed creation and use `lesson_delete repro-135` only after successful owned creation.
[Tests LO5] You receive a temporary kubeconfig for a staging cluster, but you do not want it merged into your default `~/.kube/config`. How should you use it? Set the `KUBECONFIG` environment variable for the shell session or command that needs access. That makes the client read the provided file instead of silently modifying or depending on your default configuration. After the session ends or the variable is unset, your normal contexts return. This reduces the chance of accidentally applying manifests to the wrong cluster later.
[Tests LO3] `kind create cluster` fails before any Kubernetes objects are available, and the error says it cannot connect to the Docker daemon. Why is `kubectl get pods` the wrong next diagnostic command? `kubectl get pods` depends on a reachable Kubernetes API server, and the API server does not exist yet if `kind` cannot create node containers. The failure is below Kubernetes, at the host runtime layer. The right next checks are Docker service status, Docker Desktop state, socket permissions, and whether the current user can run Docker commands. Once Docker is reachable, `kind` can create the node container that hosts the control plane.
[Tests LO3] A local Service of type `LoadBalancer` stays in `` for a long time. The Pods are healthy. What is missing from the local cluster? The cluster is missing a load balancer implementation that can satisfy the Service request. In cloud clusters, a provider controller creates external infrastructure and updates the Service status with an address. A plain local `kind` cluster has no such controller or external hardware, so the request remains pending. For local access, use port-forwarding, configured ingress mappings, or install a local load balancer implementation appropriate for the lab.

In the core exercise, you will create local clusters, inspect kubeconfig, compare pinned Kubernetes versions, switch contexts, and observe control-plane failure. Optional Task 5 adds a three-control-plane topology after the comparison clusters are cleaned up. First prove basic creation, then identity and version control, then simulate failure; keep notes on what each command establishes.

Setup Requirements: Use the authorized local runtime and same-shell helpers initialized in Section 4; do not run this exercise independently with ambient kubeconfig. If you skipped setup, return there first. Stop if the runtime endpoint or ownership is uncertain. Cleanup is limited to the successful creations recorded by this lesson.

Finish the earlier topology before starting this exercise: if this run still has its dojo-multi.owned receipt, run lesson_delete dojo-multi. The version comparison needs two single-node clusters together. After recording that comparison, remove both before the optional three-control-plane topology in Task 5. That topology uses more host resources and is not proof of production availability; stop and inspect startup failures rather than adding clusters or changing host limits blindly.

  1. Predict how many nodes and which address you expect to see. The Baseline Cluster Initialization: Create a standard single-node cluster named primary-dojo. Verify it is running and determine the API server’s host loopback address and port.
  2. Predict which entries a context must connect. The Kubeconfig Deep Dive: Use the redacted view of this lesson’s private kubeconfig. Identify the cluster, user, and context references without printing raw credentials or opening your default configuration.
  3. Predict whether this cluster will use the same server version as the first. Strict Version Pinning: Create a second, completely simultaneous cluster named legacy-dojo. This cluster must rigidly enforce running an older version of Kubernetes, specifically v1.34.11, utilizing the specific image tag kindest/node:v1.34.11@sha256:44e222ee2132dab25ff87301682f89eb82c7880ea3a1bf543bfe9708fd08d67d.
  4. Predict which client and server versions each context will report. Context Switching Mastery: Use kubectl config use-context to choose each successfully created cluster in the private kubeconfig, then run kubectl version. Compare observed server versions without modifying the default file.
  5. Optional topology practice: After cleaning up the two comparison clusters, create a declarative YAML configuration for ha-dojo with exactly three control-plane nodes and zero worker nodes. Keep this advanced local topology separate from the essential single-node and context exercises.
  6. Predict what kubectl get nodes will report after the node stops, then explain the result. Simulated Catastrophic Failure: Clean up ha-dojo if you completed optional Task 5; the comparison clusters were already removed after Task 4. Create a new broken-dojo with the guarded helper, then use lesson_fail to kill its single owned control-plane node. Stop on failed creation, collision, or uncertain ownership; never select an arbitrary Docker container from a listing.
  1. Nudge: start with the cluster’s name and connection details. Stronger hint: use the creation helper and kubectl cluster-info; a name-collision refusal means you must choose an unused name, not delete the existing cluster.
  2. Nudge: look for the destination and identity. Stronger hint: inspect the cluster, user and context entries with kubectl config view.
  3. Nudge: the node image determines the version. Stronger hint: use lesson_create with --image and the v1.34.11 digest from the release notes.
  4. Nudge: compare the client and server separately. Stronger hint: inspect the current context and switch with kubectl config use-context; an unexpected server version may mean the wrong context is active.
  5. Nudge: count the node roles in the configuration. Stronger hint: declare three control-plane nodes and no workers.
  6. Nudge: consider which container hosts the API. Stronger hint: use the recorded target with lesson_fail and try kubectl get nodes.
Solution for Task 1: Baseline Cluster Initialization

First, execute the standard creation command. The custom name makes the generated node container and kubeconfig context easier to identify later.

Terminal window
# Provision the cluster
lesson_create primary-dojo --image kindest/node:v1.35.8@sha256:07b2536e30b803ed61d1677a79df6115f798ce64c80f9e22f6ed45afd09323c0

Once the cluster indicates it has started successfully, find out exactly where it is listening. kind maps a random high-numbered port on your host’s localhost address to port 6443 inside the container.

Terminal window
# Investigate the cluster connection metadata
kubectl cluster-info
# Alternatively, find the port mapping directly from Docker
docker port primary-dojo-control-plane

Expected outcome: one node and an API address on 127.0.0.1 with a randomly assigned port.

Solution for Task 2: The Kubeconfig Deep Dive

Inspect only this lesson’s private kubeconfig through the scoped client. The default view redacts credential fields; do not use --raw, and keep context metadata private when sharing evidence.

Terminal window
# Inspect redacted lesson configuration
kubectl config view

Locate clusters:, users:, and contexts: in the redacted private file. For primary-dojo, their referenced name is kind-primary-dojo. The file’s current context determines the request destination; a stored context name alone is not proof that a cluster belongs to this lesson.

Expected outcome: the context, cluster, and user references are named kind-primary-dojo.

Solution for Task 3: Strict Version Pinning

Run multiple kind clusters simultaneously only if your computer has enough memory. The --image flag overrides the default node image and pulls the requested Kubernetes version.

Terminal window
# Provision the version-pinned cluster in parallel
lesson_create legacy-dojo --image kindest/node:v1.34.11@sha256:44e222ee2132dab25ff87301682f89eb82c7880ea3a1bf543bfe9708fd08d67d

This command may take a moment if Docker must download the node image for version 1.34.11.

Expected outcome: legacy-dojo runs Kubernetes v1.34.11, while primary-dojo runs v1.35.8.

Solution for Task 4: Context Switching Mastery

Select each successfully created lesson cluster with the real client. KUBECONFIG directs these persistent context changes to the private lesson file, preserving your default kubeconfig and its stored current context.

Terminal window
# List all available contexts in your configuration file.
# The active one will have a '*' next to it.
kubectl config get-contexts
# Explicitly switch the active context to the primary cluster
kubectl config use-context kind-primary-dojo
# Verify the observed server version matches the v1.35.8 pin
kubectl version
# Explicitly switch the active context to the legacy cluster
kubectl config use-context kind-legacy-dojo
# Verify the server version matches exactly v1.34.11
kubectl version
# Record the comparison, then release both clusters before optional Task 5
lesson_delete primary-dojo
lesson_delete legacy-dojo

Expected outcome: both contexts report client v1.35.x; kind-primary-dojo reports server v1.35.8 and kind-legacy-dojo reports server v1.34.11.

Solution for Optional Task 5: Topology Engineering and Declaration

To build complex architectures, use a configuration file instead of a long set of command-line flags. Create a file named ha-config.yaml:

Terminal window
lesson_workspace && cat > ha-config.yaml <<'YAML'
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
- role: control-plane
- role: control-plane
YAML

Now instruct kind to read this file during cluster creation.

Terminal window
# Provision the cluster using the configuration file
lesson_create ha-dojo --config ha-config.yaml --image kindest/node:v1.35.8@sha256:07b2536e30b803ed61d1677a79df6115f798ce64c80f9e22f6ed45afd09323c0
# Validate the topology
kubectl wait node --all --for=condition=Ready --timeout=120s
kubectl get nodes

You should see exactly three nodes listed, all explicitly marked with the control-plane role. Notice how the generated names are suffixed to keep each node distinct.

Solution for Task 6: Simulated Catastrophic Failure

Finally, practice cleaning up the environment and observing a raw control plane failure.

Terminal window
# If you completed optional Task 5, delete that recorded lesson cluster
test ! -f "$lesson_dir/ha-dojo.owned" || lesson_delete ha-dojo || exit 1
# Create the target cluster
lesson_create broken-dojo --image kindest/node:v1.35.8@sha256:07b2536e30b803ed61d1677a79df6115f798ce64c80f9e22f6ed45afd09323c0
# The creation receipt contains the original control-plane Docker ID.
# A later container reusing the name is never the failure target.
# Kill only the owned single-node failure target; stop if the helper refuses.
lesson_fail broken-dojo
# Attempt to interact with the broken cluster state
kubectl get nodes

The connection will either hang until timeout or immediately fail with a TCP connection refused error. This demonstrates that without the API server container operating, the cluster interface is unavailable. You cannot read state through Kubernetes, nor can you alter it, even if some previous workload process might have existed before the control plane disappeared.

Before cleanup, reflect: which signals would distinguish a stopped node container from a wrong context or a wrong port?

Reflection answer

docker ps -a shows an exited node container. kubectl config current-context shows a wrong context. A wrong port appears when docker port broken-dojo-control-plane differs from the server address in kubectl cluster-info.

Terminal window
# Remove the failure-lab cluster when you are done observing
lesson_delete broken-dojo

At the end, inspect the remaining *.owned receipts in the printed workspace and run lesson_delete NAME for each cluster from this run that you no longer need. Keep receipts if cleanup fails and ask the lab owner for recovery. Do not delete unrelated clusters, prune shared Docker state, or print the private kubeconfig. Run lesson_finish to restore the previous KUBECONFIG value (including unset or empty), then close the lesson shell. The default file and its stored context were never changed.

  • You successfully provisioned and ran multiple distinct, isolated Kubernetes clusters on your host machine simultaneously.
  • You identified and explained the structural components of the kubeconfig file.
  • You switched the private kubeconfig’s current context and compared server versions without altering your default file.
  • If you attempted optional Task 5, you verified its declared three-control-plane topology and cleaned it up.
  • You empirically observed and documented the exact failure mode of kubectl when the control plane becomes catastrophically unreachable.
  • You practiced excellent infrastructure hygiene by successfully deleting all ephemeral clusters created during this exercise.

Module 1.2: kubectl Basics — Learn to navigate cluster resources, inspect objects, and turn API access into practical operational control.