Getting Started with Kubernetes on Windows Using WSL2: A Beginner’s Guide

Welcome to the world of Kubernetes! If you’re new to container orchestration, Kubernetes (often abbreviated as K8s) is a powerful tool that automates the deployment, scaling, and management of containerized applications. But before diving into Kubernetes, it’s helpful to understand the basics of Docker and containers, as Kubernetes relies heavily on them. This beginner-friendly guide will walk you through setting up Kubernetes locally on Windows using the Windows Subsystem for Linux (WSL2). We’ll start with a quick recap of Docker and containers to ensure you’re ready, then provide clear, step-by-step instructions to install and run Kubernetes with Minikube.

---

🐳 Docker and Containers: A Quick Recap

What Is Docker?

Docker is a platform that lets you package and run applications in containers. It simplifies the process of building, shipping, and running applications across different environments.

What’s a Container?

A container is a lightweight, standalone, and executable package that includes everything needed to run a piece of software:

• Code
• Runtime
• System tools
• Libraries
• Settings

Containers are isolated from each other but share the same operating system (OS) kernel, making them much more efficient than traditional virtual machines (VMs).

Analogy: Think of containers as lightweight virtual machines. They’re faster, smaller, and use fewer resources because they don’t need a full OS for each instance.

Containers vs. Virtual Machines

Here’s a quick comparison to clarify the difference:

Feature	Containers	Virtual Machines
Startup Time	Seconds	Minutes
Resource Usage	Low (shares host kernel)	High (requires full OS)
OS Requirements	Shares host OS kernel	Needs a full OS per VM
Isolation Level	Process-level	Full OS-level

Basic Docker Workflow

To understand how Docker works, here’s a simple example of creating and running a containerized Node.js application:

1. Create a Dockerfile: A text file with instructions to build a container image.

   FROM node:18
   WORKDIR /app
   COPY . .
   RUN npm install
   CMD ["node", "app.js"]
   

2. Build the Image: Use the Dockerfile to create an image.

   docker build -t my-node-app .
   

3. Run the Container: Start a container from the image.

   docker run -d -p 3000:3000 my-node-app
   

Why Containers Matter for Kubernetes

Kubernetes doesn’t run your applications directly—it manages your containers. It handles tasks like:

• Starting containers
• Restarting them if they crash
• Scaling them up or down
• Exposing them via networking

With a basic understanding of Docker and containers, you’re ready to let Kubernetes orchestrate them in a smart, automated way!

---

✅ Step-by-Step: Setting Up Kubernetes with Minikube on Windows (Using WSL2)

In this section, we’ll install and configure Kubernetes locally using Minikube, a tool that runs a single-node Kubernetes cluster on your machine. We’ll use WSL2 (Windows Subsystem for Linux) as the environment and kubectl, the Kubernetes command-line tool, to interact with the cluster.

🔧 Step 1: Prerequisites

Before starting, ensure you have the following:

• WSL2 installed and set as the default version.
• An Ubuntu or Debian distribution running in WSL2.
• Virtualization enabled in your BIOS (required for running virtual machines).
• Windows Terminal or PowerShell installed for easy access to WSL.

To verify WSL2 is set up correctly, run this command in PowerShell or Windows Terminal:

wsl -l -v

Look for your distro (e.g., Ubuntu) and ensure it shows VERSION 2. If it’s version 1 or not installed, update WSL2 by following Microsoft’s official guide: Install WSL.

🔄 Step 2: Install kubectl in WSL2

kubectl is the command-line tool for interacting with Kubernetes clusters. To install it in your WSL2 Ubuntu/Debian terminal:

1. Download the latest stable version of kubectl:

   curl -LO "https://dl.k8s.io/release/$(curl -Ls https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
   

2. Make it executable:

   chmod +x kubectl
   

3. Move it to a system-wide location:

   sudo mv kubectl /usr/local/bin/
   

4. Verify the installation:

   kubectl version --client
   

   You should see the kubectl client version (e.g., v1.28.0).

📦 Step 3: Install Minikube in WSL2

Minikube runs a local Kubernetes cluster. To install it in WSL2:

1. Download the latest Minikube binary:

   curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
   

2. Install it to a system-wide location:

   sudo install minikube-linux-amd64 /usr/local/bin/minikube
   

3. Verify the installation:

   minikube version
   

   You should see the Minikube version (e.g., minikube version: v1.32.0).

⚙️ Step 4: Start Minikube with the Docker Driver

Minikube supports several drivers, but the Docker driver is recommended for WSL2 because it integrates well with Docker Desktop on Windows.

Option A: If Docker Desktop Is Already Installed

If you have Docker Desktop installed on Windows with WSL2 integration enabled:

1. Start Minikube:

   minikube start --driver=docker
   

   This uses the Docker daemon from Docker Desktop (via WSL2 integration).

Option B: If Docker Is Not Installed

If you don’t have Docker Desktop installed:

1. Download and install Docker Desktop from Docker’s official site.
2. During setup, enable WSL2 integration in Docker Desktop’s settings (Settings > Resources > WSL Integration > Enable integration with your WSL distro).
3. Restart your WSL terminal and run:

   minikube start --driver=docker
   

Verify Minikube Is Running

Check if the Kubernetes cluster is up:

kubectl get nodes

You should see a node named minikube in the Ready state, like this:

NAME       STATUS   ROLES           AGE     VERSION
minikube   Ready    control-plane   2m      v1.28.0

---

🚀 Running Your First Pod (Nginx)

Now that your Kubernetes cluster is running, let’s deploy a simple Nginx pod—a small containerized web server.

Step 1: Create an Nginx Pod

Run this command in your WSL2 terminal:

kubectl run nginx-pod --image=nginx --restart=Never

This command tells Kubernetes to:

• Create a pod named nginx-pod.
• Use the nginx image from Docker Hub.
• Run it as a single pod (--restart=Never ensures it’s not managed by a Deployment or ReplicaSet).

Step 2: Check Pod Status

Verify the pod is running:

kubectl get pods

You should see output like:

NAME        READY   STATUS    RESTARTS   AGE
nginx-pod   1/1     Running   0          10s

If the pod is stuck in ContainerCreating or ImagePullBackOff, it may be pulling the image or facing network issues. Wait a few seconds and check again, or troubleshoot by running:

kubectl describe pod nginx-pod

Step 3: See Pod Details

To get more information about the pod (e.g., events, IP, or image details):

kubectl describe pod nginx-pod

This displays detailed logs, which can help with debugging if needed.

Step 4: Access the Nginx Web Server

Pods are isolated by default, so we’ll use port forwarding to access the Nginx web server from your local machine.

Run this command:

kubectl port-forward pod/nginx-pod 8080:80

You’ll see output like:

Forwarding from 127.0.0.1:8080 -> 80

This maps port 8080 on your local machine to port 80 (Nginx’s default port) in the pod.

Now, open your browser and go to:

http://localhost:8080

You should see the Nginx welcome page, confirming your pod is running successfully! 🎉

---

What’s Next?

You’ve just set up a local Kubernetes cluster using Minikube on WSL2 and deployed your first Nginx pod! From here, you can explore:

• Deployments: For managing multiple pod replicas.
• Services: For exposing pods to external traffic.
• ConfigMaps and Secrets: For managing configuration and sensitive data.
• Scaling: To handle more traffic by adding pod replicas.

If you run into issues, use kubectl describe or kubectl logs to troubleshoot, or feel free to ask for help!