## Inhaltsverzeichnis
- [Grundkonzepte](#grundkonzepte)
- [Schritt 1: Welche Endpoints gibt es?](#schritt-1-welche-endpoints-gibt-es)
- [Schritt 2: Endpoint-Konfiguration prüfen](#schritt-2-endpoint-konfiguration-prüfen)
- [Schritt 3: Endpoint erreichbar machen](#schritt-3-endpoint-erreichbar-machen)
- [Troubleshooting](#troubleshooting)

---

## Grundkonzepte

### Was ist ein Endpoint?
Ein **Endpoint** ist eine URL, über die Sie auf eine Anwendung in Kubernetes zugreifen können (z.B. `https://jupyterhub.example.com` oder `http://localhost:8080`).

### Wichtige Kubernetes-Komponenten

#### 1. Pod
- Ein **Pod** ist die kleinste Einheit in Kubernetes
- Enthält einen oder mehrere Container (z.B. Ihre Anwendung)
- Hat eine interne IP-Adresse im Cluster
- Befehl: `kubectl get pods -n <namespace>`

#### 2. Service
- Ein **Service** ist eine stabile Zugangsadresse zu einem oder mehreren Pods
- Macht Pods innerhalb des Clusters erreichbar
- Typen:
  - `ClusterIP`: Nur innerhalb des Clusters erreichbar
  - `NodePort`: Von außen über Port am Node erreichbar
  - `LoadBalancer`: Erstellt einen externen Load Balancer (z.B. bei AWS)
- Befehl: `kubectl get svc -n <namespace>`

#### 3. Ingress
- Ein **Ingress** ist die "Haustür" zu Ihren Services von außerhalb des Clusters
- Ermöglicht HTTP/HTTPS-Zugriff über Domainnamen (z.B. `app.example.com`)
- Benötigt einen Ingress Controller (z.B. [[Nginx]])
- Befehl: `kubectl get ingress -n <namespace>`

#### 4. Namespace
- Ein **Namespace** ist wie ein Ordner in Kubernetes
- Trennt verschiedene Anwendungen oder Teams
- Beispiele: `openmetadata`, `jupyterhub`, `default`

---

## Schritt 1: Welche Endpoints gibt es?

### 1.1 Alle Namespaces auflisten

```bash
kubectl get namespaces
```

**Erklärung:** Zeigt alle Namespaces in Ihrem Cluster. Hier finden Sie, wo Ihre Anwendungen laufen.

**Beispiel-Output:**
```
NAME                STATUS   AGE
default             Active   30d
jupyterhub          Active   20d
openmetadata        Active   5d
argocd              Active   25d
```

### 1.2 Anwendungen in einem Namespace finden

```bash
# Pods (laufende Anwendungen)
kubectl get pods -n openmetadata

# Services (Zugriffspunkte)
kubectl get svc -n openmetadata

# Ingress (externe Zugänge)
kubectl get ingress -n openmetadata
```

**Wichtig:** Ersetzen Sie `openmetadata` mit Ihrem Namespace!

**Beispiel-Output:**
```bash
# Pods
NAME                            READY   STATUS    RESTARTS   AGE
openmetadata-559bf987f6-gxkdk   1/1     Running   0          4d20h

# Services
NAME           TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)             AGE
openmetadata   ClusterIP   172.20.25.201   <none>        8585/TCP,8586/TCP   4d20h

# Ingress
NAME           CLASS   HOSTS                           ADDRESS                  PORTS     AGE
openmetadata   nginx   openmetadata.dma.aai-dfine.de   xxx.elb.amazonaws.com   80, 443   4d20h
```

### 1.3 Alle Ingress-Endpoints im Cluster

```bash
kubectl get ingress --all-namespaces
```

**Erklärung:** Zeigt ALLE konfigurierten externen Zugänge über alle Namespaces hinweg.

---

## Schritt 2: Endpoint-Konfiguration prüfen

### 2.1 Detaillierte Ingress-Informationen

```bash
kubectl describe ingress <ingress-name> -n <namespace>
```

**Beispiel:**
```bash
kubectl describe ingress openmetadata -n openmetadata
```

**Was Sie hier sehen:**
- **Hosts:** Der Domainname (z.B. `openmetadata.dma.aai-dfine.de`)
- **TLS:** Ob HTTPS konfiguriert ist und welches Zertifikat verwendet wird
- **Backends:** Zu welchem Service und Port der Ingress weiterleitet
- **Address:** Der tatsächliche Load Balancer

**Beispiel-Output:**
```
Name:             openmetadata
Namespace:        openmetadata
Address:          aa83990c7ad3548c4b0e28680b0952ba-1924426268.eu-central-1.elb.amazonaws.com
Ingress Class:    nginx
TLS:
  aai-dfine-certificate-tls terminates openmetadata.dma.aai-dfine.de
Rules:
  Host                           Path  Backends
  ----                           ----  --------
  openmetadata.dma.aai-dfine.de  /     openmetadata:8585 (10.10.1.86:8585)
```

### 2.2 Pod-Status überprüfen

```bash
kubectl get pods -n <namespace>
```

**Status-Bedeutungen:**
- `Running`: ✅ Pod läuft normal
- `Pending`: ⏳ Pod startet gerade
- `CrashLoopBackOff`: ❌ Pod startet immer wieder neu (Fehler!)
- `Error`: ❌ Pod hat einen Fehler

### 2.3 Service-Details

```bash
kubectl get svc <service-name> -n <namespace> -o wide
```

**Zeigt:** ClusterIP, Ports, Selectors (welche Pods werden angesprochen)

---

## Schritt 3: Endpoint erreichbar machen

Es gibt **drei Methoden**, um auf einen Kubernetes-Endpoint zuzugreifen:

### Methode 1: Port-Forwarding (Empfohlen für Tests) ⭐

**Wann nutzen?**
- Schneller Zugriff für Tests
- DNS ist nicht konfiguriert
- Lokale Entwicklung

**Vorteile:**
- ✅ Keine Cluster-Änderungen
- ✅ Sicher (nur für Sie erreichbar)
- ✅ Sofort verfügbar
- ✅ Keine DNS-Konfiguration nötig

**Nachteile:**
- ❌ Terminal muss offen bleiben
- ❌ Nur von Ihrem PC erreichbar

**Befehl:**
```bash
kubectl port-forward -n <namespace> svc/<service-name> <lokaler-port>:<service-port>
```

**Beispiel für OpenMetadata:**
```bash
kubectl port-forward -n openmetadata svc/openmetadata 8585:8585
```

**Was passiert:**
1. Kubernetes erstellt einen Tunnel von Ihrem PC zum Service
2. Sie können nun auf `http://localhost:8585` zugreifen
3. Der Tunnel leitet alle Anfragen an den Service im Cluster weiter

**Zugriff:**
```
http://localhost:8585
```

**Beenden:** `Ctrl + C` im Terminal

**Tipp:** Im Hintergrund laufen lassen:
```bash
# Windows PowerShell
Start-Process kubectl -ArgumentList "port-forward -n openmetadata svc/openmetadata 8585:8585" -WindowStyle Hidden
```

---

### Methode 2: Über Ingress mit DNS (Produktiv-Umgebung)

**Wann nutzen?**
- Produktiv-Zugriff
- Mehrere Nutzer
- HTTPS/TLS erforderlich

**Voraussetzungen:**
1. ✅ Ingress ist konfiguriert (siehe Schritt 2.1)
2. ✅ DNS-Eintrag existiert
3. ✅ TLS-Zertifikat ist vorhanden

#### 2.1 DNS-Auflösung testen

```bash
# Windows PowerShell
nslookup openmetadata.dma.aai-dfine.de

# Alternative
Resolve-DnsName openmetadata.dma.aai-dfine.de
```

**Wenn DNS funktioniert:**
```
Server:  dns.google
Address:  8.8.8.8

Name:    openmetadata.dma.aai-dfine.de
Address:  54.xxx.xxx.xxx
```

**Wenn DNS NICHT funktioniert:**
```
*** dns.google kann openmetadata.dma.aai-dfine.de nicht finden: Non-existent domain
```

#### 2.2 Problem: DNS funktioniert nicht

**Lösung A: Lokale Hosts-Datei (temporär für Tests)**

1. **Load Balancer IP/Hostname finden:**
```bash
kubectl get ingress <ingress-name> -n <namespace>
```

Notieren Sie die `ADDRESS` (z.B. `xxx.elb.amazonaws.com`)

2. **Load Balancer IP auflösen:**
```bash
nslookup xxx.elb.amazonaws.com
```

3. **Windows Hosts-Datei bearbeiten:**
   - Datei öffnen als Administrator: `C:\Windows\System32\drivers\etc\hosts`
   - Zeile hinzufügen:
   ```
   <IP-Adresse>    openmetadata.dma.aai-dfine.de
   ```
   - Speichern

4. **Im Browser öffnen:**
   ```
   https://openmetadata.dma.aai-dfine.de
   ```

**Lösung B: DNS-Eintrag erstellen lassen (dauerhaft)**

Jemand mit AWS Route53-Zugriff muss einen DNS-Eintrag erstellen:
- **Typ:** CNAME oder A-Record
- **Name:** `openmetadata.dma.aai-dfine.de`
- **Ziel:** Load Balancer Hostname/IP

---

### Methode 3: Direkt zum Load Balancer (ohne DNS)

**Wenn vorhanden:**

1. **Load Balancer URL finden:**
```bash
kubectl get ingress <ingress-name> -n <namespace>
```

2. **Direkt mit curl testen:**
```bash
curl -H "Host: openmetadata.dma.aai-dfine.de" http://<load-balancer-url>
```

**Hinweis:** Funktioniert nicht immer im Browser (Host-Header erforderlich)

---

## Troubleshooting

### Problem: "Hmmm... can't reach this page" / ERR_NAME_NOT_RESOLVED

**Ursache:** DNS-Name kann nicht aufgelöst werden

**Lösung:**
1. DNS testen: `nslookup <hostname>`
2. Falls DNS fehlt → **Port-Forwarding** verwenden (Methode 1)
3. Oder: Hosts-Datei editieren (Methode 2, Lösung A)

---

### Problem: Port-Forwarding schlägt fehl

**Fehlermeldung:** `Unable to listen on port 8585`

**Ursache:** Port ist bereits belegt

**Lösung:**
```bash
# Anderen lokalen Port verwenden
kubectl port-forward -n openmetadata svc/openmetadata 9999:8585

# Dann öffnen: http://localhost:9999
```

---

### Problem: Pod läuft nicht (Status: CrashLoopBackOff)

**Logs anschauen:**
```bash
kubectl logs <pod-name> -n <namespace>

# Letzte 100 Zeilen
kubectl logs <pod-name> -n <namespace> --tail=100

# Vorheriger Container (wenn Pod neu gestartet wurde)
kubectl logs <pod-name> -n <namespace> --previous
```

---

### Problem: 502 Bad Gateway / 503 Service Unavailable

**Ursache:** Service erreicht den Pod nicht

**Prüfen:**
```bash
# 1. Läuft der Pod?
kubectl get pods -n <namespace>

# 2. Sind Endpoints vorhanden?
kubectl get endpoints <service-name> -n <namespace>

# 3. Service-Details
kubectl describe svc <service-name> -n <namespace>
```

---

### Problem: Authentifizierung erforderlich

**Wenn Login-Seite erscheint:**

**Standard-Credentials suchen:**
```bash
# Secrets auflisten
kubectl get secrets -n <namespace>

# Secret anschauen (Werte sind base64-kodiert)
kubectl get secret <secret-name> -n <namespace> -o yaml

# Secret dekodieren
kubectl get secret <secret-name> -n <namespace> -o jsonpath='{.data.password}' | base64 -d
```

**Beispiel OpenMetadata:**
- Standard-User: `admin`
- Standard-Password: `admin`

---

## Nützliche Befehle - Cheat Sheet

### Übersicht verschaffen
```bash
# Alle Namespaces
kubectl get namespaces

# Alles in einem Namespace
kubectl get all -n <namespace>

# Alle Ingress-Endpoints
kubectl get ingress --all-namespaces
```

### Status prüfen
```bash
# Pods mit mehr Details
kubectl get pods -n <namespace> -o wide

# Pod-Logs live verfolgen
kubectl logs -f <pod-name> -n <namespace>

# In Pod einloggen (für Debugging)
kubectl exec -it <pod-name> -n <namespace> -- /bin/bash
```

### Konfiguration anschauen
```bash
# YAML eines Ingress
kubectl get ingress <name> -n <namespace> -o yaml

# Service-Details
kubectl describe svc <name> -n <namespace>

# ConfigMap auslesen
kubectl get configmap <name> -n <namespace> -o yaml
```

### Port-Forwarding
```bash
# Standard
kubectl port-forward -n <namespace> svc/<service-name> <local-port>:<service-port>

# Zu einem Pod (falls Service nicht existiert)
kubectl port-forward -n <namespace> <pod-name> <local-port>:<container-port>

# Alle Interfaces binden (auch im Netzwerk erreichbar)
kubectl port-forward --address 0.0.0.0 -n <namespace> svc/<service> 8585:8585
```

---

## Best Practices

### Für Tests und Entwicklung
✅ **Port-Forwarding** verwenden
- Schnell, sicher, keine Änderungen am Cluster

### Für Produktiv-Zugriff
✅ **Ingress mit DNS** verwenden
- Korrekte DNS-Einträge erstellen lassen
- TLS/HTTPS konfigurieren
- Basic Auth oder OAuth für Authentifizierung

### Sicherheit
⚠️ **Nie direkt auf Pods zugreifen** in Produktion
⚠️ **Immer über Services** routen
⚠️ **Port-Forwarding nicht dauerhaft** laufen lassen

---

## Glossar

| Begriff | Erklärung |
|---------|-----------|
| **Cluster** | Die gesamte Kubernetes-Umgebung mit allen Maschinen |
| **Node** | Eine einzelne Maschine (VM) im Cluster |
| **Pod** | Kleinste Einheit, enthält Container mit Ihrer App |
| **Service** | Stabiler Zugriffspunkt zu einem oder mehreren Pods |
| **Ingress** | HTTP/HTTPS-Zugang von außen, wie ein Router |
| **Namespace** | Logische Trennung/Ordner für Anwendungen |
| **ConfigMap** | Konfigurationsdaten (nicht-sensitiv) |
| **Secret** | Sensible Daten (Passwörter, Tokens) - base64-kodiert |
| **Load Balancer** | Verteilt Traffic auf mehrere Pods (z.B. AWS ELB) |
| **TLS/SSL** | Verschlüsselung für HTTPS |
| **Port-Forward** | Tunnel von lokalem PC zu Kubernetes-Service |

---

## Zusammenfassung

### Quick Start: Auf Anwendung zugreifen

1. **Namespace finden:**
   ```bash
   kubectl get namespaces
   ```

2. **Ingress prüfen:**
   ```bash
   kubectl get ingress -n <namespace>
   ```

3. **Port-Forwarding starten:**
   ```bash
   kubectl port-forward -n <namespace> svc/<service-name> 8585:8585
   ```

4. **Im Browser öffnen:**
   ```
   http://localhost:8585
   ```

Das war's! 🎉

---

## Weitere Ressourcen

- [Offizielle Kubernetes Dokumentation](https://kubernetes.io/docs/)
- [kubectl Cheat Sheet](https://kubernetes.io/docs/reference/kubectl/cheatsheet/)
- [Kubernetes Port-Forwarding](https://kubernetes.io/docs/tasks/access-application-cluster/port-forward-access-application-cluster/)

---

*Erstellt am: {{ date:2026-02-10 }}*
*Workspace: `gitops`*