wsl --install -d Ubuntu-24.04

wsl --list --online

wsl --install -d Ubuntu

wsl --update
wsl --version

wsl --set-default-version 2

wsl --list --verbose

  NAME            STATE           VERSION
* Ubuntu-24.04    Running         2

wsl --set-version Ubuntu-24.04 2

wsl -d Ubuntu-24.04

Ubuntu 24.04

winver
wsl --version
wsl --status
wsl --list --verbose

sudo apt update
sudo apt full-upgrade -y
sudo apt autoremove -y

sudo apt install -y \
  apt-transport-https \
  bash-completion \
  ca-certificates \
  conntrack \
  curl \
  dnsutils \
  file \
  git \
  gnupg \
  htop \
  iproute2 \
  iptables \
  iputils-ping \
  jq \
  less \
  lsb-release \
  make \
  net-tools \
  netcat-openbsd \
  openssl \
  procps \
  python3 \
  python3-pip \
  rsync \
  socat \
  tar \
  traceroute \
  tree \
  unzip \
  vim \
  wget \
  yq \
  zip

whoami
id
sudo -v

timedatectl
sudo timedatectl set-timezone Europe/Berlin

git config --global user.name "Dein Name"
git config --global user.email "dein.name@example.com"
git config --global init.defaultBranch main
git config --global pull.rebase false

mkdir -p ~/workshops
cd ~/workshops

cd /mnt/c/Users/<dein-user>/Documents

notepad $env:USERPROFILE\.wslconfig

[wsl2]
memory=8GB
processors=4
swap=4GB
localhostForwarding=true
dnsTunneling=true
autoProxy=true

[experimental]
autoMemoryReclaim=gradual
sparseVhd=true

wsl --shutdown
wsl -d Ubuntu-24.04

[wsl2]
networkingMode=mirrored
dnsTunneling=true
autoProxy=true
localhostForwarding=true

wsl --shutdown

sudo nano /etc/wsl.conf

[boot]
systemd=true

[automount]
enabled=true
root=/mnt/
mountFsTab=true

[network]
generateHosts=true
generateResolvConf=true

[interop]
enabled=true
appendWindowsPath=true

[user]
default=<dein-linux-user>

wsl --shutdown
wsl -d Ubuntu-24.04

ps -p 1 -o comm=
systemctl is-system-running || true
systemctl list-unit-files --type=service | head

systemd

ls -ld /mnt/c
ls -l /mnt/c/Windows/System32/drivers/etc/hosts

mount | grep drvfs || true

powershell.exe -NoProfile -Command '$PSVersionTable.PSVersion'
cmd.exe /c ver
explorer.exe .

/home/<du>/workshops/
├── kubernetes-workshop/
├── clusters/
│   ├── kind/
│   ├── minikube/
│   └── k3d/
├── bin/
└── tmp/

mkdir -p ~/workshops ~/clusters/{kind,minikube,k3d} ~/bin ~/tmp

grep -q 'export PATH="$HOME/bin:$PATH"' ~/.bashrc || echo 'export PATH="$HOME/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

find ~/workshops/kubernetes-workshop -maxdepth 3 -type f | sort | head -100

grep -RInE '(password|passwd|secret|token|apikey|api_key|private_key)' . \
  --exclude-dir=.git \
  --exclude='*.md' || true

sudo cat /mnt/c/Windows/System32/drivers/etc/hosts | tail -40

notepad $env:windir\System32\drivers\etc\hosts

# Kubernetes WSL Workshop
127.0.0.1 demo.local
127.0.0.1 api.demo.local
127.0.0.1 grafana.demo.local
127.0.0.1 argocd.demo.local
127.0.0.1 keycloak.demo.local
127.0.0.1 prometheus.demo.local

ipconfig /flushdns

powershell.exe -NoProfile -Command 'Start-Process notepad -Verb RunAs -ArgumentList "$env:windir\System32\drivers\etc\hosts"'

mkdir -p scripts/windows
cat > scripts/windows/add-k8s-hosts.ps1 <<'EOF'
$ErrorActionPreference = "Stop"

$HostsPath = "$env:windir\System32\drivers\etc\hosts"
$MarkerStart = "# BEGIN Kubernetes WSL Workshop"
$MarkerEnd = "# END Kubernetes WSL Workshop"
$Block = @"
$MarkerStart
127.0.0.1 demo.local
127.0.0.1 api.demo.local
127.0.0.1 grafana.demo.local
127.0.0.1 argocd.demo.local
127.0.0.1 keycloak.demo.local
127.0.0.1 prometheus.demo.local
$MarkerEnd
"@

$Current = Get-Content -Path $HostsPath -Raw
$Pattern = [regex]::Escape($MarkerStart) + "(?s).*?" + [regex]::Escape($MarkerEnd)

if ($Current -match $Pattern) {
    $New = [regex]::Replace($Current, $Pattern, $Block.Trim())
    Set-Content -Path $HostsPath -Value $New -NoNewline
} else {
    Add-Content -Path $HostsPath -Value "`r`n$Block"
}

ipconfig /flushdns | Out-Null
Write-Host "Kubernetes-WSL-Hosts-Einträge wurden gesetzt."
EOF

powershell.exe -NoProfile -ExecutionPolicy Bypass -File C:\Pfad\zum\Repository\scripts\windows\add-k8s-hosts.ps1

powershell.exe -NoProfile -ExecutionPolicy Bypass -Command \
  "Start-Process powershell -Verb RunAs -ArgumentList '-NoProfile -ExecutionPolicy Bypass -File \"$(wslpath -w scripts/windows/add-k8s-hosts.ps1)\"'"

cat > scripts/windows/remove-k8s-hosts.ps1 <<'EOF'
$ErrorActionPreference = "Stop"

$HostsPath = "$env:windir\System32\drivers\etc\hosts"
$MarkerStart = "# BEGIN Kubernetes WSL Workshop"
$MarkerEnd = "# END Kubernetes WSL Workshop"
$Current = Get-Content -Path $HostsPath -Raw
$Pattern = "(?ms)^" + [regex]::Escape($MarkerStart) + ".*?" + [regex]::Escape($MarkerEnd) + "\r?\n?"
$New = [regex]::Replace($Current, $Pattern, "")
Set-Content -Path $HostsPath -Value $New -NoNewline
ipconfig /flushdns | Out-Null
Write-Host "Kubernetes-WSL-Hosts-Einträge wurden entfernt."
EOF

powershell.exe -NoProfile -ExecutionPolicy Bypass -File C:\Pfad\zum\Repository\scripts\windows\remove-k8s-hosts.ps1

Resolve-DnsName demo.local
Test-NetConnection demo.local -Port 80

http://demo.local

getent hosts demo.local
curl -v http://demo.local || true
curl -v http://127.0.0.1 || true

127.0.0.1 demo.local

Windows 11 + WSL2 + Ubuntu + Docker Desktop WSL Integration + kind

docker version
docker context ls
docker run --rm hello-world

sudo apt update
sudo apt install -y ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
  sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

. /etc/os-release
printf 'deb [arch=%s signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu %s stable\n' \
  "$(dpkg --print-architecture)" "$VERSION_CODENAME" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo usermod -aG docker "$USER"
newgrp docker

systemctl status docker --no-pager
docker info
docker run --rm hello-world

export K8S_MINOR="1.36"
export K8S_STABLE="$(curl -L -s https://dl.k8s.io/release/stable.txt)"
echo "$K8S_STABLE"

export K8S_MINOR="1.36"

sudo apt update
sudo apt install -y apt-transport-https ca-certificates curl gnupg
sudo mkdir -p /etc/apt/keyrings

curl -fsSL "https://pkgs.k8s.io/core:/stable:/v${K8S_MINOR}/deb/Release.key" | \
  sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

printf 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v%s/deb/ /\n' "${K8S_MINOR}" | \
  sudo tee /etc/apt/sources.list.d/kubernetes.list

sudo apt update
sudo apt install -y kubectl
kubectl version --client

echo 'source <(kubectl completion bash)' >> ~/.bashrc
echo 'alias k=kubectl' >> ~/.bashrc
echo 'complete -o default -F __start_kubectl k' >> ~/.bashrc
source ~/.bashrc

curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
helm version

kubectl kustomize --help | head

curl -s "https://raw.githubusercontent.com/kubernetes-sigs/kustomize/master/hack/install_kustomize.sh" | bash
sudo install -m 0755 kustomize /usr/local/bin/kustomize
kustomize version

# stern für Log-Tailing
curl -fsSL https://github.com/stern/stern/releases/latest/download/stern_linux_amd64.tar.gz -o /tmp/stern.tar.gz
mkdir -p /tmp/stern
sudo tar -xzf /tmp/stern.tar.gz -C /tmp/stern
sudo install -m 0755 /tmp/stern/stern /usr/local/bin/stern

# k9s über GitHub-Release oder Paketmanager installieren, je nach Unternehmensrichtlinie
# Beispiel absichtlich nicht automatisiert, da Version und Architektur festgelegt werden sollten.

for cmd in git curl jq yq docker kubectl helm; do
  printf '%-12s' "$cmd"
  command -v "$cmd" || true
done

sudo apt install -y golang-go
go install sigs.k8s.io/kind@latest
mkdir -p ~/bin
ln -sf "$(go env GOPATH)/bin/kind" ~/bin/kind
kind version

KIND_VERSION="v0.30.0"
curl -Lo /tmp/kind "https://kind.sigs.k8s.io/dl/${KIND_VERSION}/kind-linux-amd64"
chmod +x /tmp/kind
sudo install -m 0755 /tmp/kind /usr/local/bin/kind
kind version

kind create cluster --name workshop
kubectl cluster-info --context kind-workshop
kubectl get nodes -o wide

mkdir -p clusters/kind
cat > clusters/kind/workshop.yaml <<'EOF'
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
name: workshop
nodes:
  - role: control-plane
    kubeadmConfigPatches:
      - |
        kind: InitConfiguration
        nodeRegistration:
          kubeletExtraArgs:
            node-labels: "ingress-ready=true"
    extraPortMappings:
      - containerPort: 80
        hostPort: 80
        protocol: TCP
      - containerPort: 443
        hostPort: 443
        protocol: TCP
      - containerPort: 30080
        hostPort: 30080
        protocol: TCP
  - role: worker
  - role: worker
EOF

kind delete cluster --name workshop || true
kind create cluster --config clusters/kind/workshop.yaml
kubectl get nodes -o wide

extraPortMappings:
  - containerPort: 80
    hostPort: 8080
    protocol: TCP
  - containerPort: 443
    hostPort: 8443
    protocol: TCP

http://demo.local:8080
https://demo.local:8443

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/main/deploy/static/provider/kind/deploy.yaml

kubectl wait --namespace ingress-nginx \
  --for=condition=ready pod \
  --selector=app.kubernetes.io/component=controller \
  --timeout=180s

kubectl create namespace demo --dry-run=client -o yaml | kubectl apply -f -

kubectl create deployment web \
  --image=nginx:1.27 \
  --replicas=2 \
  -n demo

kubectl expose deployment web \
  --port=80 \
  --target-port=80 \
  -n demo

cat > /tmp/demo-ingress.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: web
  namespace: demo
spec:
  ingressClassName: nginx
  rules:
    - host: demo.local
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: web
                port:
                  number: 80
EOF

kubectl apply -f /tmp/demo-ingress.yaml

127.0.0.1 demo.local

curl -H 'Host: demo.local' http://127.0.0.1
curl http://demo.local

http://demo.local

docker run -d --restart=always -p 127.0.0.1:5001:5000 --name kind-registry registry:2

cat > clusters/kind/workshop-registry.yaml <<'EOF'
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
name: workshop
containerdConfigPatches:
  - |-
    [plugins."io.containerd.grpc.v1.cri".registry.mirrors."localhost:5001"]
      endpoint = ["http://kind-registry:5000"]
nodes:
  - role: control-plane
    extraPortMappings:
      - containerPort: 80
        hostPort: 80
        protocol: TCP
      - containerPort: 443
        hostPort: 443
        protocol: TCP
  - role: worker
  - role: worker
EOF

kind delete cluster --name workshop || true
kind create cluster --config clusters/kind/workshop-registry.yaml

docker network connect kind kind-registry || true

docker build -t localhost:5001/demo-app:0.1.0 .
docker push localhost:5001/demo-app:0.1.0

image: localhost:5001/demo-app:0.1.0

kind delete cluster --name workshop
docker rm -f kind-registry || true

curl -LO https://github.com/kubernetes/minikube/releases/latest/download/minikube-linux-amd64
sudo install -m 0755 minikube-linux-amd64 /usr/local/bin/minikube
rm -f minikube-linux-amd64
minikube version

minikube start \
  --driver=docker \
  --cpus=4 \
  --memory=8192 \
  --disk-size=30g

kubectl config current-context
kubectl get nodes -o wide
minikube status

K8S_STABLE="$(curl -L -s https://dl.k8s.io/release/stable.txt)"
minikube start \
  --driver=docker \
  --kubernetes-version="$K8S_STABLE" \
  --cpus=4 \
  --memory=8192

minikube start --driver=docker --kubernetes-version=v1.36.1

minikube addons list
minikube addons enable ingress
minikube addons enable metrics-server

kubectl get pods -A
kubectl top nodes || true

kubectl create namespace demo --dry-run=client -o yaml | kubectl apply -f -
kubectl create deployment web --image=nginx:1.27 -n demo
kubectl expose deployment web --port=80 --target-port=80 -n demo

kubectl expose deployment web \
  --name=web-nodeport \
  --type=NodePort \
  --port=80 \
  --target-port=80 \
  -n demo

kubectl get svc -n demo
minikube service web-nodeport -n demo --url

kubectl port-forward -n demo --address 0.0.0.0 svc/web 8080:80

http://localhost:8080

127.0.0.1 demo.local

http://demo.local:8080

minikube addons enable ingress
kubectl wait -n ingress-nginx \
  --for=condition=ready pod \
  --selector=app.kubernetes.io/component=controller \
  --timeout=180s

cat > /tmp/minikube-ingress.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: web
  namespace: demo
spec:
  ingressClassName: nginx
  rules:
    - host: demo.local
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: web
                port:
                  number: 80
EOF

kubectl apply -f /tmp/minikube-ingress.yaml

minikube ip
curl -H 'Host: demo.local' http://$(minikube ip)

minikube tunnel

kubectl create deployment lb-demo --image=nginx:1.27 -n demo
kubectl expose deployment lb-demo --type=LoadBalancer --port=80 -n demo
kubectl get svc -n demo -w

minikube delete

curl -s https://raw.githubusercontent.com/k3d-io/k3d/main/install.sh | bash
k3d version

k3d cluster create workshop \
  --servers 1 \
  --agents 2 \
  --api-port 127.0.0.1:6550 \
  -p "80:80@loadbalancer" \
  -p "443:443@loadbalancer"

kubectl cluster-info
kubectl get nodes -o wide
k3d cluster list

kubectl create namespace demo --dry-run=client -o yaml | kubectl apply -f -
kubectl create deployment web --image=nginx:1.27 -n demo
kubectl expose deployment web --port=80 --target-port=80 -n demo

cat > /tmp/k3d-ingress.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: web
  namespace: demo
spec:
  rules:
    - host: demo.local
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: web
                port:
                  number: 80
EOF

kubectl apply -f /tmp/k3d-ingress.yaml

127.0.0.1 demo.local

curl http://demo.local

http://demo.local

k3d cluster delete workshop || true
k3d cluster create workshop \
  --servers 1 \
  --agents 2 \
  --api-port 127.0.0.1:6550 \
  -p "80:80@loadbalancer" \
  -p "443:443@loadbalancer" \
  --k3s-arg "--disable=traefik@server:*"

helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update
helm upgrade --install ingress-nginx ingress-nginx/ingress-nginx \
  -n ingress-nginx \
  --create-namespace \
  --set controller.service.type=LoadBalancer

k3d cluster delete workshop

kubectl config get-contexts
kubectl config use-context docker-desktop
kubectl get nodes -o wide

kubectl create namespace demo --dry-run=client -o yaml | kubectl apply -f -
kubectl create deployment web --image=nginx:1.27 -n demo
kubectl expose deployment web --port=80 --target-port=80 -n demo
kubectl port-forward -n demo --address 0.0.0.0 svc/web 8080:80

http://localhost:8080

sudo apt update
sudo apt install -y containerd
sudo mkdir -p /etc/containerd
containerd config default | sudo tee /etc/containerd/config.toml >/dev/null

sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml
sudo systemctl restart containerd
sudo systemctl enable containerd

systemctl status containerd --no-pager
sudo ctr version

cat <<'EOF' | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF

sudo modprobe overlay || true
sudo modprobe br_netfilter || true

cat <<'EOF' | sudo tee /etc/sysctl.d/99-kubernetes-cri.conf
net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
EOF

sudo sysctl --system

export K8S_MINOR="1.36"

sudo apt update
sudo apt install -y apt-transport-https ca-certificates curl gnupg
sudo mkdir -p /etc/apt/keyrings

curl -fsSL "https://pkgs.k8s.io/core:/stable:/v${K8S_MINOR}/deb/Release.key" | \
  sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

printf 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v%s/deb/ /\n' "${K8S_MINOR}" | \
  sudo tee /etc/apt/sources.list.d/kubernetes.list

sudo apt update
sudo apt install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

swapon --show || true
free -h

sudo swapoff -a

mkdir -p clusters/kubeadm
cat > clusters/kubeadm/init.yaml <<'EOF'
apiVersion: kubeadm.k8s.io/v1beta4
kind: InitConfiguration
localAPIEndpoint:
  advertiseAddress: 127.0.0.1
  bindPort: 6443
nodeRegistration:
  criSocket: unix:///run/containerd/containerd.sock
---
apiVersion: kubeadm.k8s.io/v1beta4
kind: ClusterConfiguration
# Beispielversion: Prüfe und pinne die Patchversion vor dem Workshop.
kubernetesVersion: v1.36.1
networking:
  podSubnet: 10.244.0.0/16
  serviceSubnet: 10.96.0.0/12
apiServer:
  certSANs:
    - 127.0.0.1
    - localhost
    - kubeadm.local
---
apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
cgroupDriver: systemd
EOF

sudo kubeadm init --config clusters/kubeadm/init.yaml

mkdir -p ~/.kube
sudo cp -i /etc/kubernetes/admin.conf ~/.kube/config
sudo chown "$(id -u):$(id -g)" ~/.kube/config
kubectl get nodes

kubectl apply -f https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml

kubectl get pods -A -w

kubectl taint nodes --all node-role.kubernetes.io/control-plane- || true
kubectl get nodes

kubectl create namespace demo --dry-run=client -o yaml | kubectl apply -f -
kubectl create deployment web --image=nginx:1.27 -n demo
kubectl expose deployment web --port=80 --target-port=80 -n demo
kubectl port-forward -n demo --address 0.0.0.0 svc/web 8080:80

http://localhost:8080

sudo kubeadm reset -f
sudo rm -rf ~/.kube /etc/cni/net.d /var/lib/cni /var/lib/kubelet /var/lib/etcd
sudo systemctl restart containerd

curl -sfL https://get.k3s.io | \
  INSTALL_K3S_EXEC="--write-kubeconfig-mode=644" \
  sh -

sudo systemctl status k3s --no-pager
kubectl --kubeconfig /etc/rancher/k3s/k3s.yaml get nodes

mkdir -p ~/.kube
sudo cp /etc/rancher/k3s/k3s.yaml ~/.kube/config
sudo chown "$(id -u):$(id -g)" ~/.kube/config
kubectl get nodes -o wide

kubectl create namespace demo --dry-run=client -o yaml | kubectl apply -f -
kubectl create deployment web --image=nginx:1.27 -n demo
kubectl expose deployment web --port=80 --target-port=80 -n demo
kubectl port-forward -n demo --address 0.0.0.0 svc/web 8080:80

http://localhost:8080

sudo /usr/local/bin/k3s-uninstall.sh
rm -rf ~/.kube/config

mkdir -p ~/.kube
chmod 700 ~/.kube
cp /mnt/c/Users/<windows-user>/Downloads/kubeconfig ~/.kube/config
chmod 600 ~/.kube/config

kubectl config get-contexts
kubectl config current-context
kubectl cluster-info
kubectl get nodes -o wide

mkdir -p ~/.kube/configs
cp kubeconfig-dev ~/.kube/configs/dev.yaml
cp kubeconfig-prod ~/.kube/configs/prod.yaml

export KUBECONFIG="$HOME/.kube/configs/dev.yaml:$HOME/.kube/configs/prod.yaml"
kubectl config view --flatten > ~/.kube/config.merged
mv ~/.kube/config.merged ~/.kube/config
chmod 600 ~/.kube/config

Windows Hosts-Datei: 127.0.0.1 demo.local
kind extraPortMappings: hostPort 80 -> containerPort 80
Ingress: host demo.local
Browser: http://demo.local

Windows Hosts-Datei: 127.0.0.1 demo.local
k3d Port-Mapping: 80:80@loadbalancer
Ingress: host demo.local
Browser: http://demo.local

kubectl port-forward --address 0.0.0.0 svc/web 8080:80
Windows Hosts-Datei: 127.0.0.1 demo.local
Browser: http://demo.local:8080

minikube tunnel
Service type LoadBalancer
Browser abhängig von Tunnel-Adresse und Routing

mkdir -p certs
openssl req -x509 -nodes -days 365 \
  -newkey rsa:2048 \
  -keyout certs/demo.local.key \
  -out certs/demo.local.crt \
  -subj "/CN=demo.local" \
  -addext "subjectAltName=DNS:demo.local,DNS:api.demo.local,DNS:grafana.demo.local"

kubectl create secret tls demo-local-tls \
  --cert=certs/demo.local.crt \
  --key=certs/demo.local.key \
  -n demo \
  --dry-run=client -o yaml | kubectl apply -f -

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: web
  namespace: demo
spec:
  ingressClassName: nginx
  tls:
    - hosts:
        - demo.local
      secretName: demo-local-tls
  rules:
    - host: demo.local
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: web
                port:
                  number: 80

sudo apt install -y libnss3-tools
curl -JLO "https://dl.filippo.io/mkcert/latest?for=linux/amd64"
chmod +x mkcert-*-linux-amd64
sudo mv mkcert-*-linux-amd64 /usr/local/bin/mkcert
mkcert -install
mkcert demo.local api.demo.local grafana.demo.local

docker build -t demo-app:0.1.0 .
kind load docker-image demo-app:0.1.0 --name workshop

image: demo-app:0.1.0
imagePullPolicy: IfNotPresent

eval "$(minikube docker-env)"
docker build -t demo-app:0.1.0 .

image: demo-app:0.1.0
imagePullPolicy: IfNotPresent

eval "$(minikube docker-env -u)"

docker build -t demo-app:0.1.0 .
k3d image import demo-app:0.1.0 -c workshop

docker run -d --restart=always \
  --name local-registry \
  -p 127.0.0.1:5001:5000 \
  registry:2

docker build -t localhost:5001/demo-app:0.1.0 .
docker push localhost:5001/demo-app:0.1.0

kubectl describe pod <pod> -n <namespace>
kubectl get events -n <namespace> --sort-by=.lastTimestamp
kubectl get pod <pod> -n <namespace> -o jsonpath='{.status.containerStatuses[*].state.waiting.reason}'

kubectl get storageclass
kubectl get pv,pvc -A

kubectl create namespace storage-demo --dry-run=client -o yaml | kubectl apply -f -
cat > /tmp/pvc.yaml <<'EOF'
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: data
  namespace: storage-demo
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
EOF
kubectl apply -f /tmp/pvc.yaml
kubectl get pvc -n storage-demo

minikube addons list | grep -i storage || true
kubectl get storageclass

kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
  - role: control-plane
    extraMounts:
      - hostPath: /home/<du>/workshops/data
        containerPath: /data

Test-NetConnection localhost -Port 8080
Test-NetConnection demo.local -Port 80

Get-NetTCPConnection -LocalPort 80 -ErrorAction SilentlyContinue
Get-Process -Id (Get-NetTCPConnection -LocalPort 80).OwningProcess

sudo ss -tulpn | grep -E ':80|:443|:8080|:8443' || true

Resolve-DnsName demo.local

getent hosts demo.local
nslookup demo.local || true

kubectl run dns-debug --rm -it --restart=Never --image=busybox:1.36 -- nslookup kubernetes.default.svc.cluster.local

kubectl get ingress -A
kubectl describe ingress -n demo web
kubectl get pods -n ingress-nginx -o wide
kubectl logs -n ingress-nginx deploy/ingress-nginx-controller --tail=100
curl -v -H 'Host: demo.local' http://127.0.0.1

./scripts/provision.sh --dry-run

./scripts/provision.sh --target wsl-kind --dry-run
./scripts/provision.sh --target wsl-kind

./scripts/provision.sh --target wsl-minikube --dry-run
./scripts/provision.sh --target wsl-minikube

./scripts/provision.sh --target wsl-k3d --dry-run
./scripts/provision.sh --target wsl-k3d

.PHONY: wsl-tools wsl-kind wsl-minikube wsl-k3d wsl-validate wsl-clean

wsl-tools:
	./scripts/wsl/install-tools.sh

wsl-kind:
	kind create cluster --config clusters/kind/workshop.yaml
	kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/main/deploy/static/provider/kind/deploy.yaml

wsl-minikube:
	minikube start --driver=docker --cpus=4 --memory=8192
	minikube addons enable ingress
	minikube addons enable metrics-server

wsl-k3d:
	k3d cluster create workshop --servers 1 --agents 2 --api-port 127.0.0.1:6550 -p "80:80@loadbalancer" -p "443:443@loadbalancer"

wsl-validate:
	./scripts/wsl/validate.sh

wsl-clean:
	kind delete cluster --name workshop || true
	minikube delete || true
	k3d cluster delete workshop || true

mkdir -p scripts/wsl
cat > scripts/wsl/preflight.sh <<'EOF'
#!/usr/bin/env bash
set -euo pipefail

required=(git curl jq yq kubectl docker)
missing=0

for cmd in "${required[@]}"; do
  if ! command -v "$cmd" >/dev/null 2>&1; then
    echo "FEHLT: $cmd"
    missing=1
  else
    echo "OK: $cmd -> $(command -v "$cmd")"
  fi
done

if ! docker info >/dev/null 2>&1; then
  echo "FEHLER: Docker ist nicht erreichbar. Prüfe Docker Desktop WSL Integration oder native Docker Engine."
  missing=1
fi

if ! grep -qi microsoft /proc/version; then
  echo "WARNUNG: Diese Umgebung sieht nicht nach WSL aus."
fi

if [ "$missing" -ne 0 ]; then
  exit 1
fi
EOF
chmod +x scripts/wsl/preflight.sh

./scripts/wsl/preflight.sh

uname -a
cat /etc/os-release
ps -p 1 -o comm=
mount | grep drvfs || true

docker version
docker info --format '{{.ServerVersion}}'
docker run --rm hello-world

kubectl version --client
kubectl config get-contexts
kubectl config current-context || true

kubectl cluster-info
kubectl get nodes -o wide
kubectl get pods -A
kubectl get events -A --sort-by=.lastTimestamp | tail -50

kubectl run dns-test --rm -it --restart=Never --image=busybox:1.36 -- \
  nslookup kubernetes.default.svc.cluster.local

kubectl get svc -A
kubectl get ingress -A
curl -v http://localhost || true
curl -v http://demo.local || true

Resolve-DnsName demo.local
Test-NetConnection demo.local -Port 80

http://demo.local

Cannot connect to the Docker daemon

docker context ls
docker info
ls -l /var/run/docker.sock || true

wsl --shutdown

sudo systemctl status docker --no-pager
sudo systemctl restart docker
sudo usermod -aG docker "$USER"
newgrp docker

System has not been booted with systemd

sudo tee /etc/wsl.conf <<'EOF'
[boot]
systemd=true
EOF

wsl --shutdown

ps -p 1 -o comm=

Resolve-DnsName demo.local
Test-NetConnection demo.local -Port 80

notepad $env:windir\System32\drivers\etc\hosts
ipconfig /flushdns

127.0.0.1 demo.local

getent hosts demo.local
cat /etc/hosts | tail -50

echo '127.0.0.1 demo.local' | sudo tee -a /etc/hosts

kubectl get ingress -A
kubectl describe ingress -n demo web
kubectl get svc -n demo
kubectl get endpoints -n demo
curl -v -H 'Host: demo.local' http://127.0.0.1

kubectl get svc,endpoints,pods -n demo -o wide
kubectl describe svc web -n demo
kubectl get pods -n demo --show-labels

kubectl describe pod <pod> -n <namespace>
kubectl get events -n <namespace> --sort-by=.lastTimestamp
kubectl describe nodes

kubectl logs <pod> -n <namespace> --previous
kubectl describe pod <pod> -n <namespace>

kubectl describe pod <pod> -n <namespace>
kubectl get events -n <namespace> --sort-by=.lastTimestamp

kind load docker-image demo-app:0.1.0 --name workshop
k3d image import demo-app:0.1.0 -c workshop
eval "$(minikube docker-env)"
docker build -t demo-app:0.1.0 .

Get-NetTCPConnection -LocalPort 80 -ErrorAction SilentlyContinue

sudo ss -tulpn | grep ':80' || true

cat /etc/resolv.conf
nslookup github.com || true
curl -I https://kubernetes.io || true

kind get clusters
kind delete cluster --name workshop

minikube delete
rm -rf ~/.minikube

k3d cluster list
k3d cluster delete workshop

kubectl config delete-context docker-desktop || true

sudo kubeadm reset -f
sudo rm -rf ~/.kube /etc/cni/net.d /var/lib/cni /var/lib/kubelet /var/lib/etcd
sudo systemctl restart containerd || true

sudo /usr/local/bin/k3s-uninstall.sh || true

notepad $env:windir\System32\drivers\etc\hosts
ipconfig /flushdns

docker ps -a
docker network ls
docker volume ls

docker container prune
docker network prune
docker image prune

ps -p 1 -o comm=
systemctl list-unit-files --type=service | head
powershell.exe -NoProfile -Command '$PSVersionTable.PSVersion'

docker version
docker run --rm hello-world

kubectl get nodes
kubectl get pods -A
curl -H 'Host: demo.local' http://127.0.0.1

http://demo.local

Resolve-DnsName demo.local
ipconfig /displaydns | Select-String demo.local

minikube status
kubectl top nodes || true
kubectl get pods -A

k3d cluster list
kubectl get ingress -A
curl http://demo.local

kubectl get pods -n demo
kubectl describe pod -n demo -l app=demo-app

kubectl get events -A --sort-by=.lastTimestamp | tail -50
kubectl describe ingress -A
kubectl get svc,endpoints,pods -n demo -o wide

chmod 700 ~/.kube
chmod 600 ~/.kube/config

grep -RInE '(BEGIN PRIVATE KEY|password|token|secret|AKIA|client_secret)' . \
  --exclude-dir=.git || true

wsl --install -d Ubuntu-24.04
wsl --update
wsl --version
wsl --status
wsl --list --verbose
wsl --set-default-version 2
wsl --set-version Ubuntu-24.04 2
wsl --shutdown
wsl -d Ubuntu-24.04

notepad $env:windir\System32\drivers\etc\hosts
ipconfig /flushdns
Resolve-DnsName demo.local
Test-NetConnection demo.local -Port 80

uname -a
cat /etc/os-release
ps -p 1 -o comm=
systemctl is-system-running || true
ip addr
ip route
cat /etc/resolv.conf

docker version
docker info
docker ps
docker network ls
docker volume ls
docker run --rm hello-world

kubectl version --client
kubectl config get-contexts
kubectl config current-context
kubectl cluster-info
kubectl get nodes -o wide
kubectl get pods -A
kubectl get events -A --sort-by=.lastTimestamp | tail -50

kind version
kind create cluster --name workshop
kind create cluster --config clusters/kind/workshop.yaml
kind get clusters
kind load docker-image demo-app:0.1.0 --name workshop
kind delete cluster --name workshop

minikube version
minikube start --driver=docker --cpus=4 --memory=8192
minikube status
minikube addons list
minikube addons enable ingress
minikube addons enable metrics-server
minikube service <service> -n <namespace> --url
minikube tunnel
minikube delete

k3d version
k3d cluster create workshop --servers 1 --agents 2 --api-port 127.0.0.1:6550 -p "80:80@loadbalancer" -p "443:443@loadbalancer"
k3d cluster list
k3d kubeconfig get workshop
k3d image import demo-app:0.1.0 -c workshop
k3d cluster delete workshop

sudo kubeadm init --config clusters/kubeadm/init.yaml
mkdir -p ~/.kube
sudo cp -i /etc/kubernetes/admin.conf ~/.kube/config
sudo chown "$(id -u):$(id -g)" ~/.kube/config
kubectl get nodes
sudo kubeadm reset -f

curl -sfL https://get.k3s.io | INSTALL_K3S_EXEC="--write-kubeconfig-mode=644" sh -
sudo systemctl status k3s --no-pager
kubectl --kubeconfig /etc/rancher/k3s/k3s.yaml get nodes
sudo /usr/local/bin/k3s-uninstall.sh

# 1. Docker prüfen
docker run --rm hello-world

# 2. kind-Konfiguration
mkdir -p clusters/kind
cat > clusters/kind/workshop.yaml <<'EOF'
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
name: workshop
nodes:
  - role: control-plane
    kubeadmConfigPatches:
      - |
        kind: InitConfiguration
        nodeRegistration:
          kubeletExtraArgs:
            node-labels: "ingress-ready=true"
    extraPortMappings:
      - containerPort: 80
        hostPort: 80
        protocol: TCP
      - containerPort: 443
        hostPort: 443
        protocol: TCP
  - role: worker
EOF

# 3. Cluster erstellen
kind create cluster --config clusters/kind/workshop.yaml

# 4. Ingress installieren
kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/main/deploy/static/provider/kind/deploy.yaml
kubectl wait --namespace ingress-nginx \
  --for=condition=ready pod \
  --selector=app.kubernetes.io/component=controller \
  --timeout=180s

# 5. Demo bereitstellen
kubectl create namespace demo --dry-run=client -o yaml | kubectl apply -f -
kubectl create deployment web --image=nginx:1.27 -n demo
kubectl expose deployment web --port=80 --target-port=80 -n demo
cat > /tmp/ingress.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: web
  namespace: demo
spec:
  ingressClassName: nginx
  rules:
    - host: demo.local
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: web
                port:
                  number: 80
EOF
kubectl apply -f /tmp/ingress.yaml

# 6. Test aus WSL
curl -H 'Host: demo.local' http://127.0.0.1

127.0.0.1 demo.local

http://demo.local

# 1. Cluster starten
minikube start --driver=docker --cpus=4 --memory=8192

# 2. Add-ons
minikube addons enable ingress
minikube addons enable metrics-server

# 3. Demo
kubectl create namespace demo --dry-run=client -o yaml | kubectl apply -f -
kubectl create deployment web --image=nginx:1.27 -n demo
kubectl expose deployment web --port=80 --target-port=80 -n demo

# 4. Stabiler Browser-Zugriff über Port-Forward
kubectl port-forward -n demo --address 0.0.0.0 svc/web 8080:80

http://localhost:8080

# 1. Cluster erstellen
k3d cluster create workshop \
  --servers 1 \
  --agents 2 \
  --api-port 127.0.0.1:6550 \
  -p "80:80@loadbalancer" \
  -p "443:443@loadbalancer"

# 2. Demo
kubectl create namespace demo --dry-run=client -o yaml | kubectl apply -f -
kubectl create deployment web --image=nginx:1.27 -n demo
kubectl expose deployment web --port=80 --target-port=80 -n demo

# 3. Ingress
cat > /tmp/k3d-demo-ingress.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: web
  namespace: demo
spec:
  rules:
    - host: demo.local
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: web
                port:
                  number: 80
EOF
kubectl apply -f /tmp/k3d-demo-ingress.yaml

# 4. Test
curl -H 'Host: demo.local' http://127.0.0.1

127.0.0.1 demo.local

http://demo.local

Windows 11
  -> WSL2
    -> Ubuntu LTS
      -> Docker Desktop WSL Integration
        -> kind
          -> Ingress-NGINX
            -> Windows Hosts-Datei
              -> Edge Browser