Lab 22: Gateway API auf Minikube¶

Dieses Lab zeigt die Nutzung der neuen Kubernetes Gateway API. Im Gegensatz zum Ingress Controller ist diese API nicht standardmäßig in Minikube aktiviert.

Wir nutzen NGINX Gateway Fabric als Implementierung.

1. Installation der CRDs und des Controllers¶

Bevor du die YAML-Dateien anwendest, müssen wir die Gateway API CRDs (Custom Resource Definitions) und eine Implementierung installieren.

Gateway API CRDs installieren:

kubectl kustomize "https://github.com/kubernetes-sigs/gateway-api/config/crd/experimental?ref=v1.0.0" | kubectl apply -f -

NGINX Gateway Fabric installieren: Am einfachsten geht das via Helm (stelle sicher, dass Helm installiert ist):
```
helm install ngf oci://ghcr.io/nginxinc/charts/nginx-gateway-fabric --create-namespace -n nginx-gateway
```
Warte kurz, bis der Pod im Namespace nginx-gateway läuft.

2. Anwendung starten¶

01-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-gateway-demo
  labels:
    app: nginx-gateway
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx-gateway
  template:
    metadata:
      labels:
        app: nginx-gateway
    spec:
      containers:
        - name: nginx
          image: nginx:1.25
          ports:
            - containerPort: 80
          readinessProbe:
            httpGet:
              path: /
              port: 80
            initialDelaySeconds: 5
            periodSeconds: 10
          livenessProbe:
            httpGet:
              path: /
              port: 80
            initialDelaySeconds: 10
            periodSeconds: 20
          lifecycle:
            postStart:
              exec:
                command: ["/bin/sh", "-c", "echo 'Hello from Gateway API' > /usr/share/nginx/html/index.html"]
          volumeMounts:
            - name: html
              mountPath: /usr/share/nginx/html
          resources:
            requests:
              cpu: "100m"
              memory: "128Mi"
            limits:
              cpu: "200m"
              memory: "256Mi"
      volumes:
        - name: html
          emptyDir: {}

02-service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: nginx-gateway-svc
spec:
  selector:
    app: nginx-gateway
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: ClusterIP

03-gateway.yaml:

apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: my-gateway
spec:
  gatewayClassName: nginx
  listeners:
  - name: http
    protocol: HTTP
    port: 80

04-httproute.yaml:

apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: my-route
spec:
  parentRefs:
  - name: my-gateway
  hostnames:
  - "gateway.example.com"
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /
    backendRefs:
    - name: nginx-gateway-svc
      port: 80

Wende nun unsere Ressourcen an:

kubectl apply -f .

Dies erstellt:

Deployment & Service (die App)
Gateway (der LoadBalancer/Einstiegspunkt)
HTTPRoute (die Routing-Regel)

3. Zugriff testen¶

Das Gateway provisioniert einen Service vom Typ LoadBalancer. Um diesen auf Minikube zu erreichen, nutzen wir wieder den Tunnel.

Tunnel starten (falls nicht schon läuft):
```
minikube tunnel
```
IP des Gateways finden: Schau dir das Gateway-Objekt an, um die IP zu finden (sollte bei Tunnelnutzung 127.0.0.1 oder eine Minikube-IP sein):
```
kubectl get gateway my-gateway
```
Request senden: Wir nutzen curl mit dem erwarteten Hostnamen:
```
curl --resolve gateway.example.com:80:127.0.0.1 http://gateway.example.com
```
(Ersetze 127.0.0.1 durch die IP aus Schritt 2, falls abweichend)

Du solltest "Hello from Gateway API" sehen.