Module 1.1: Your First Cluster
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.
What You’ll Be Able to Do
Section titled “What You’ll Be Able to Do”- Construct and verify a Kubernetes 1.35 local cluster with
kind, Docker, and thekubectlcommand-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.
Why This Module Matters
Section titled “Why This Module Matters”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 endThe 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.
| Tool | Underlying Architecture | Primary Use Case | Pros | Cons |
|---|---|---|---|---|
| minikube | Virtual machines, containers, or bare metal | Traditional local development | Multiple driver choices. | Driver and runtime choices affect setup. |
| kind (Kubernetes IN Docker) | Docker Containers acting as Nodes | CI/CD pipelines, automated testing, rigorous local dev | Extremely fast, identical to pure upstream Kubernetes, highly customizable multi-node topologies. | Requires Docker daemon. Complex networking edge cases when exposing services to host. |
| k3d | Docker Containers running k3s | Edge computing simulation, IoT | Uses lightweight k3s. | k3s is a compliant Kubernetes distribution with bundled components and its own defaults. |
| Docker Desktop / Colima | Integrated Hypervisor / Lightweight VM | Quick validation for Mac/Windows users | Zero 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 -.-> PodAThe 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.
Section 3: Kubeconfig Is Your Passport
Section titled “Section 3: Kubeconfig Is Your Passport”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: v1kind: Configpreferences: {}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-basicsThe 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 redactedkubectl config view
# See all the context "stamps" in your passportkubectl config get-contexts
# Explicitly switch your active contextkubectl 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.yamlkubectl get nodes # Operates against the temporary clusterYou 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.yamlPause 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”Set up the tools for your platform
Section titled “Set up the tools for your platform”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.
| Platform | Setup path |
|---|---|
| macOS | Install 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. |
| Ubuntu | Follow 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 distributions | Use 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.
docker version || exit 1docker context show || exit 1kind version || exit 1client_version=$(kubectl version --client -o yaml) || exit 1printf '%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.
umask 077lesson_dir=$(mktemp -d "${TMPDIR:-/tmp}/kubedojo-cluster.XXXXXX") || exit 1cd "$lesson_dir" || exit 1lesson_dir=$PWDlesson_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.
lesson_create dojo-basics --image kindest/node:v1.35.8@sha256:07b2536e30b803ed61d1677a79df6115f798ce64c80f9e22f6ed45afd09323c0When 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.
kubectl cluster-infoThe 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.
kubectl get nodesYou 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.
kubectl get pods --namespace kube-systemSystem 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:
lesson_workspace && cat > multi-node-config.yaml <<'YAML'kind: ClusterapiVersion: kind.x-k8s.io/v1alpha4nodes: # 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: workerYAMLDelete 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.
lesson_delete dojo-basicsNow 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.
lesson_create dojo-multi --config multi-node-config.yaml --image kindest/node:v1.35.8@sha256:07b2536e30b803ed61d1677a79df6115f798ce64c80f9e22f6ed45afd09323c0Verify 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.
kubectl wait node --all --for=condition=Ready --timeout=120skubectl get nodesIllustrative output for the distributed topology (ages will differ):
NAME STATUS ROLES AGE VERSIONdojo-multi-control-plane Ready control-plane 2m14s v1.35.8dojo-multi-worker Ready <none> 1m58s v1.35.8dojo-multi-worker2 Ready <none> 1m58s v1.35.8Run 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.
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.
systemctl status dockerDisk 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.
docker system dfWhen 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.”
kind export logs ./kind-troubleshooting-logs --name dojo-multiStrong 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.
Patterns & Anti-Patterns
Section titled “Patterns & Anti-Patterns”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.
| Pattern | When to Use It | Why It Works |
|---|---|---|
| Disposable named clusters | Any learning lab, reproduction case, or integration test | Names make kubeconfig contexts obvious, while deletion keeps resource use and state drift under control. |
| Version-pinned node images | Curriculum, CI, operator testing, and bug reproduction | Pinning a node image avoids accidental release drift. |
| Declarative topology files | Multi-node tests, ingress port mappings, or kubeadm patches | A checked-in config can be reviewed, recreated, and shared instead of reconstructed from memory. |
| Host-first diagnostics | Cluster creation failures, Docker errors, disk pressure, and port conflicts | Local clusters depend on the host runtime, so Docker and OS signals often explain failures before Kubernetes exists. |
| Anti-Pattern | What Goes Wrong | Better Alternative |
|---|---|---|
| Treating a local cluster as durable infrastructure | Manual changes disappear or become impossible to reproduce after deletion | Store manifests and kind configs, then recreate the cluster to prove repeatability. |
| Applying manifests without checking context | Workloads land in the wrong cluster, sometimes a costly shared environment | Run kubectl config current-context or inspect contexts before risky actions. |
| Expecting LoadBalancer Services to work like cloud providers | EXTERNAL-IP remains pending because no cloud controller provisions hardware | Use port-forwarding, mapped ingress, or a local load balancer implementation. |
| Leaving many clusters idle | CPU, memory, ports, and disk are consumed | Inspect with kind get clusters; delete only successfully created lesson clusters through the guarded helper. |
Decision Framework
Section titled “Decision Framework”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.
Did You Know?
Section titled “Did You Know?”- The name “Kubernetes” comes from a Greek word associated with a helmsman or pilot, which matches the project’s steering-wheel logo.
kindbegan as infrastructure for testing Kubernetes itself, which explains why it is fast, disposable, and friendly to automation.- The abbreviation
k8sis a numeronym: it keeps the first and last letters of Kubernetes and replaces the eight letters between them with8.
Common Mistakes
Section titled “Common Mistakes”| Mistake | Why It Happens | How to Fix It |
|---|---|---|
Building an image on the host and expecting a kind Pod to find it | The 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 active | kind 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 IP | There 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 days | Node containers, images, and volumes consume host resources | Use recorded creation evidence and guarded lesson cleanup; a familiar name alone never authorizes deletion. |
| Editing a node container by hand | Manual 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 limits | kind 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 pair | Kubernetes 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[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.
Hands-On Exercise
Section titled “Hands-On Exercise”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.
- 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. - 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.
- 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 tagkindest/node:v1.34.11@sha256:44e222ee2132dab25ff87301682f89eb82c7880ea3a1bf543bfe9708fd08d67d. - Predict which client and server versions each context will report. Context Switching Mastery: Use
kubectl config use-contextto choose each successfully created cluster in the private kubeconfig, then runkubectl version. Compare observed server versions without modifying the default file. - Optional topology practice: After cleaning up the two comparison clusters, create a declarative YAML configuration for
ha-dojowith exactly three control-plane nodes and zero worker nodes. Keep this advanced local topology separate from the essential single-node and context exercises. - Predict what
kubectl get nodeswill report after the node stops, then explain the result. Simulated Catastrophic Failure: Clean upha-dojoif you completed optional Task 5; the comparison clusters were already removed after Task 4. Create a newbroken-dojowith the guarded helper, then uselesson_failto kill its single owned control-plane node. Stop on failed creation, collision, or uncertain ownership; never select an arbitrary Docker container from a listing.
- 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. - Nudge: look for the destination and identity. Stronger hint: inspect the cluster, user and context entries with
kubectl config view. - Nudge: the node image determines the version. Stronger hint: use
lesson_createwith--imageand the v1.34.11 digest from the release notes. - 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. - Nudge: count the node roles in the configuration. Stronger hint: declare three
control-planenodes and no workers. - Nudge: consider which container hosts the API. Stronger hint: use the recorded target with
lesson_failand trykubectl get nodes.
Solutions
Section titled “Solutions”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.
# Provision the clusterlesson_create primary-dojo --image kindest/node:v1.35.8@sha256:07b2536e30b803ed61d1677a79df6115f798ce64c80f9e22f6ed45afd09323c0Once 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.
# Investigate the cluster connection metadatakubectl cluster-info
# Alternatively, find the port mapping directly from Dockerdocker port primary-dojo-control-planeExpected 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.
# Inspect redacted lesson configurationkubectl config viewLocate 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.
# Provision the version-pinned cluster in parallellesson_create legacy-dojo --image kindest/node:v1.34.11@sha256:44e222ee2132dab25ff87301682f89eb82c7880ea3a1bf543bfe9708fd08d67dThis 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.
# 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 clusterkubectl config use-context kind-primary-dojo
# Verify the observed server version matches the v1.35.8 pinkubectl version
# Explicitly switch the active context to the legacy clusterkubectl config use-context kind-legacy-dojo
# Verify the server version matches exactly v1.34.11kubectl version
# Record the comparison, then release both clusters before optional Task 5lesson_delete primary-dojolesson_delete legacy-dojoExpected 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:
lesson_workspace && cat > ha-config.yaml <<'YAML'kind: ClusterapiVersion: kind.x-k8s.io/v1alpha4nodes: - role: control-plane - role: control-plane - role: control-planeYAMLNow instruct kind to read this file during cluster creation.
# Provision the cluster using the configuration filelesson_create ha-dojo --config ha-config.yaml --image kindest/node:v1.35.8@sha256:07b2536e30b803ed61d1677a79df6115f798ce64c80f9e22f6ed45afd09323c0
# Validate the topologykubectl wait node --all --for=condition=Ready --timeout=120skubectl get nodesYou 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.
# If you completed optional Task 5, delete that recorded lesson clustertest ! -f "$lesson_dir/ha-dojo.owned" || lesson_delete ha-dojo || exit 1
# Create the target clusterlesson_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 statekubectl get nodesThe 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.
# Remove the failure-lab cluster when you are done observinglesson_delete broken-dojoSuccess Criteria
Section titled “Success Criteria”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
kubeconfigfile. - 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
kubectlwhen the control plane becomes catastrophically unreachable. - You practiced excellent infrastructure hygiene by successfully deleting all ephemeral clusters created during this exercise.
Sources
Section titled “Sources”- Kubernetes Components
- Kubernetes Nodes
- Organizing Cluster Access Using kubeconfig Files
- kubectl Reference
- Kubernetes Version Skew Policy
- Kubernetes Services
- Use Port Forwarding to Access Applications in a Cluster
- kind Project
- kind Quick Start
- kind v0.33.0 release and node images
- minikube drivers
- K3s documentation
- k3d documentation
- kind Configuration
- kind Known Issues
- Docker inspect: object IDs and formatted output
- etcd Learning Documentation
Next Module
Section titled “Next Module”Module 1.2: kubectl Basics — Learn to navigate cluster resources, inspect objects, and turn API access into practical operational control.