Creating Kubernetes Clusters with Claude

curl -sS https://claude.ai/install.sh | bash

claude

Browser didn't open? Use the url below to sign in:

https://claude.ai/oauth/authorize?code=true&client_id=<...>&response_type=code&redirect_uri=...
Paste code here if prompted >

Welcome to Claude Code!
/help for help, /status for your current setup
cwd: /home/ubuntu

Tips for getting started:
Run /init to create a CLAUDE.md file with instructions for Claude
Use Claude to help with file analysis, editing, bash commands and git
Be as specific as you would with another engineer for the best results

Note: You have launched claude in your home directory. For the best experience, launch it in a project directory instead.

> Try "refactor <filepath>"

You are an expert DevOps assistant. On THIS Ubuntu VM, please execute the following plan non-interactively using only the Bash tool:

PLAN
1) Install prerequisites: ca-certificates, curl, gnupg, apt-transport-https, conntrack, socat, ebtables, ethtool. Apply sysctls: net.bridge.bridge-nf-call-iptables=1 and net.ipv4.ip_forward=1.
2) Install Docker (docker.io), enable/start it, and add the current user to the docker group.
3) Install kubectl via the official APT repo.
4) Install Minikube (latest Linux binary).
5) Start a 3-node Minikube cluster named "demo" using the Docker driver with --cpus=2 and --memory=4096 per node.
6) Enable addons: metrics-server, ingress, dashboard.
7) Create a Deployment "hello" using nginx and expose as NodePort.
8) Print nodes, services, and a reachable URL using minikube service --url. Also print a port-forward fallback command.
9) Make all steps idempotent and handle docker-group membership (attempt a newgrp docker block before retrying minikube).

Now write the script to /tmp/minikube-demo.sh and run it.

#!/usr/bin/env bash
set -euo pipefail

# Configuration
PROFILE_NAME=demo
NODES=3
CPU=2
MEM=4096

# Update
sudo apt-get update -y

# Install prerequisites
sudo apt-get install -y ca-certificates curl gnupg apt-transport-https \
  conntrack socat ebtables ethtool

# Kernel modules and sysctls
sudo modprobe br_netfilter || true
# Create (or overwrite) sysctl file for Kubernetes requirements
echo "net.bridge.bridge-nf-call-iptables=1" | sudo tee /etc/sysctl.d/99-k8s.conf >/dev/null
echo "net.ipv4.ip_forward=1" | sudo tee -a /etc/sysctl.d/99-k8s.conf >/dev/null
sudo sysctl --system

# Install Docker (idempotent)
if ! command -v docker >/dev/null 2>&1; then
  sudo apt-get install -y docker.io
  sudo systemctl enable --now docker
  sudo usermod -aG docker "${SUDO_USER:-$USER}" || true
fi

# Install kubectl (official APT repo)
if ! command -v kubectl >/dev/null 2>&1; then
  sudo install -m 0755 -d /etc/apt/keyrings
  curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.34/deb/Release.key \
    | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
  echo "deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" \
    | sudo tee /etc/apt/sources.list.d/kubernetes.list
  sudo apt-get update -y
  sudo apt-get install -y kubectl
fi

# Install Minikube (latest binary)
if ! command -v minikube >/dev/null 2>&1; then
  curl -Lo minikube-linux-amd64 https://github.com/kubernetes/minikube/releases/latest/download/minikube-linux-amd64
  sudo install minikube-linux-amd64 /usr/local/bin/minikube
  rm -f minikube-linux-amd64
fi

# Start Minikube cluster (idempotent)
if ! minikube -p "$PROFILE_NAME" status >/dev/null 2>&1; then
  if ! docker ps >/dev/null 2>&1; then
    echo "Refreshing docker group and starting Minikube in a subshell..."
    newgrp docker <<NG
minikube start -p "$PROFILE_NAME" --driver=docker --nodes="$NODES" --cpus="$CPU" --memory="$MEM"
NG
  else
    minikube start -p "$PROFILE_NAME" --driver=docker --nodes="$NODES" --cpus="$CPU" --memory="$MEM"
  fi
else
  echo "Minikube profile \"$PROFILE_NAME\" already exists; skipping start."
fi

# Enable addons (ignore failures)
minikube -p "$PROFILE_NAME" addons enable metrics-server || true
minikube -p "$PROFILE_NAME" addons enable ingress || true
minikube -p "$PROFILE_NAME" addons enable dashboard || true

# Deploy demo nginx app if missing
if ! kubectl get deploy hello >/dev/null 2>&1; then
  kubectl create deployment hello --image=nginx --port=80
  kubectl expose deployment hello --type=NodePort --port=80
fi

# Output status
echo "=== Nodes ==="
kubectl get nodes -o wide || true

echo "=== Services ==="
kubectl get svc -o wide || true

echo "=== Demo URL(s) ==="
minikube -p "$PROFILE_NAME" service hello --url || true

echo -e "\nFallback (port-forward from this VM):\n  kubectl port-forward deploy/hello 8080:80\nThen curl http://localhost:8080\n"

Forwarding from 127.0.0.1:8080 -> 80
Forwarding from [::1]:8080 -> 80
Handling connection for 8080

• Minikube Demo Setup Complete!

✅ Infrastructure Setup:
- Installed prerequisites
- Applied sysctls for bridge-nf-call-iptables and ip_forward
- Installed Docker, enabled/started it, and added user to docker group
- Installed kubectl and Minikube

✅ Cluster Configuration:
- Started 3-node Minikube cluster named "demo" using Docker driver
- Each node configured with 2 CPUs and 4096MB memory (per node)
- Addons enabled: metrics-server, ingress, dashboard

✅ Demo Application:
- Created "hello" deployment using nginx image
- Exposed as NodePort service (e.g., http://192.168.49.2:31902)
- Successfully tested via port-forwarding

Access:
- Direct URL (minikube): minikube -p demo service hello --url
- Port-forward fallback: kubectl port-forward deploy/hello 8080:80  -> curl http://localhost:8080