Hinweis:

Dieses Tutorial erfordert Zugriff auf Oracle Cloud. Informationen zum Registrieren eines kostenlosen Accounts finden Sie unter Erste Schritte mit Oracle Cloud Infrastructure Free Tier.
Es verwendet Beispielwerte für Oracle Cloud Infrastructure-Zugangsdaten, -Mandanten und -Compartments. Wenn Sie Ihre Übung abgeschlossen haben, ersetzen Sie diese Werte durch spezifische Werte für Ihre Cloud-Umgebung.

Sichere Kubernetes-Webservices mit Nginx Ingress Controller, OAuth2 Proxy und Oracle-Identitätsdomains

Einführung

Das Sichern von gehosteten Kubernetes-Webservices sollte einfach sein. Unabhängig davon, ob Ihre Anwendung keine integrierte Unterstützung für die Integration eines externen Identitätsproviders (IdP) bietet oder ob Sie eine Single Sign-On-(SSO-)Lösung benötigen, um die Verwaltung zu vereinfachen und den Bedarf an individuellen Authentifizierungsmechanismen pro Service zu reduzieren, bietet OAuth2 Proxy die Flexibilität, jede Anwendung mit fast jedem Identitätsprovider (IdP) zu verbinden.

OAuth2 Proxy fungiert als Reverse Proxy, der vor Ihren Kubernetes-Services sitzt. Er fängt Traffic ab, leitet Benutzer zur Anmeldung an einen externen Autorisierungsserver (wie Okta oder GitHub) um und validiert Zugriffstoken, bevor Anforderungen an Backend-Services weitergeleitet werden.

Zielsetzung

Stellen Sie eine einfache Webanwendung für Kubernetes bereit, stellen Sie sie mit dem Nginx-Ingress-Controller bereit, und konfigurieren Sie den OAuth2-Proxy so, dass Oracle-Identitätsdomains als IdP verwendet werden.

Voraussetzungen

Zugriff auf einen Oracle Cloud Infrastructure-(OCI-)Mandanten.
Ein Oracle Cloud Infrastructure Container Engine for Kubernetes-(OKE-)Cluster, das für die Verwendung eines öffentlichen Subnetzes für Load Balancer konfiguriert ist.
(Optional) Zugriff zum Aktualisieren von Datensätzen für eine DNS-(Domain Name System-)Domain.

Aufgabe 1: OKE-Cluster erstellen

Melden Sie sich bei der OCI-Konsole an, navigieren Sie zu Oracle Container Engine for Kubernetes, und klicken Sie auf Erstellen.
Klicken Sie im Assistenten Cluster erstellen auf Schnellerstellung.
Geben Sie die folgenden Informationen ein, und klicken Sie auf Weiter.
- Name: Geben Sie den Clusternamen ein.
- Kubernetes-Version: Wählen Sie die zu verwendende Version aus.
- Kubernetes-API-Endpunkte: Wählen Sie Öffentlicher Endpunkt aus.
- Knotentyp: Wählen Sie Verwaltet aus.
- Kubernetes-Worker-Knoten: Wählen Sie Private Worker aus.
- Knotenanzahl: 1.
Prüfen Sie den Vorgang, und klicken Sie auf Cluster erstellen. Warten Sie, bis das Cluster verfügbar ist.
Aktualisieren Sie die Sicherheitsliste, die mit dem Servicesubnetz verknüpft ist.
1. Klicken Sie auf das Servicesubnetz.
2. Klicken Sie auf Sicherheitsliste, und fügen Sie die folgenden Regeln hinzu.
  - Ingress:
  - Egress:
Aktualisieren Sie die mit dem Worker-Knotensubnetz verknüpfte Sicherheitsliste, um Verbindungen von den Load Balancern zuzulassen.
1. Klicken Sie auf den VCN-Namen.
2. Wählen Sie unter Ressourcen die Option Sicherheitslisten aus, und klicken Sie auf die Knotensicherheitsliste.
3. Fügen Sie die folgende Ingress-Regel zur Knotensicherheitsliste hinzu.
4. Klicken Sie auf Ingress-Regeln hinzufügen.

Aufgabe 2: Nginx Ingress Controller einrichten

Sobald das Cluster verfügbar ist, können Sie mit OCI Cloud Shell auf das Cluster zugreifen. Klicken Sie auf Auf Cluster zugreifen, kopieren Sie den folgenden Befehl, und führen Sie ihn in OCI Cloud Shell aus.
Führen Sie den Befehl kubectl get node aus, um die Liste der verfügbaren Knoten abzurufen.
Fügen Sie das Nginx Ingress Controller-Helm-Repository hinzu. Weitere Informationen finden Sie unter Überblick über Ingress NGINX Controller und helm.
```
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update
```

Erstellen Sie die Datei values-override.yaml.

controller:
  allowSnippetAnnotations: true
  service:
    annotations:
      oci.oraclecloud.com/load-balancer-type: "lb"
      service.beta.kubernetes.io/oci-load-balancer-backend-protocol: "TCP"
      service.beta.kubernetes.io/oci-load-balancer-shape: "flexible"
      service.beta.kubernetes.io/oci-load-balancer-shape-flex-min: "10"
      service.beta.kubernetes.io/oci-load-balancer-shape-flex-max: "10"

Stellen Sie den Nginx Ingress Controller bereit.

helm install ingress-nginx ingress-nginx/ingress-nginx -f values-override.yaml

Speichern Sie die folgende yaml-Datei mit dem Namen application.yaml.

---
# Create ClusterIP service
apiVersion: v1
kind: Service
metadata:
  name: httpbin
  labels:
    app: httpbin
spec:
  ports:
  - port: 5000
    targetPort: 5000
  selector:
    app: httpbin
---
# Deployment of a sample web application
apiVersion: apps/v1
kind: Deployment
metadata:
  name: httpbin
spec:
  replicas: 2
  selector:
    matchLabels:
      app: httpbin
      version: v1
  template:
    metadata:
      labels:
        app: httpbin
        version: v1
    spec:
      containers:
      - image: mendhak/http-https-echo
        imagePullPolicy: IfNotPresent
        name: httpbin
        ports:
        - containerPort: 5000
        env:
        - name: HTTP_PORT
          value: "5000"

Erstellen Sie die Anwendungsressourcen.
```
kubectl apply -f application.yaml
```
Erstellen Sie einen DNS-Datensatz für die öffentliche IP-Adresse, die mit dem Load Balancer verknüpft ist.
- Rufen Sie die öffentliche IP-Adresse des Load Balancers ab.
```
$ kubectl get svc ingress-nginx-controller
NAME                       TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)                      AGE
ingress-nginx-controller   LoadBalancer   10.96.152.30   158.180.61.74   80:31957/TCP,443:30838/TCP   32s
```
- Erstellen Sie den DNS-Datensatz. Wenn Sie keinen DNS-Server haben, verlassen wir uns auf den freien Platzhalter-DNS-Service nip.io.
In diesem Fall lautet der FQDN 158-180-61-74.nip.io.

Speichern Sie die folgende yaml-Datei mit dem Namen ingress.yaml.

Hinweis: Achten Sie darauf, die Hosteinträge mit Ihrem FQDN zu aktualisieren.

---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: httpbin-ingress-nginx
spec:
  ingressClassName: nginx
  tls:
  - hosts:
      - "<YOUR-FQDN>"
  rules:
    - host: "<YOUR-FQDN>"
      http:
        paths:
          - pathType: Prefix
            path: "/"
            backend:
              service:
                name: httpbin
                port:
                  number: 5000

Führen Sie den folgenden Befehl aus, um die Ingress-Ressource zu erstellen.
```
kubectl apply -f ingress.yaml
```

Testen Sie die Verbindung zum Service.

$ curl -k https://<YOUR-FQDN> 
{
  "path": "/",
  "headers": {
    "host": "158-180-61-74.nip.io",
    "x-request-id": "b0320217391a922acecbfe10758b3ffe",
    "x-real-ip": "10.0.10.167",
    "x-forwarded-for": "10.0.10.167",
    "x-forwarded-host": "158-180-61-74.nip.io",
    "x-forwarded-port": "443",
    "x-forwarded-proto": "https",
    "x-forwarded-scheme": "https",
    "x-scheme": "https",
    "user-agent": "curl/7.87.0",
    "accept": "*/*"
  },
  "method": "GET",
  "body": "",
  "fresh": false,
  "hostname": "158-180-61-74.nip.io",
  "ip": "10.0.10.167",
  "ips": [
    "10.0.10.167"
  ],
  "protocol": "https",
  "query": {},
  "subdomains": [
    "158-180-61-74"
  ],
  "xhr": false,
  "os": {
    "hostname": "httpbin-644874bcdb-ll4mb"
  },
  "connection": {}
}

Aufgabe 3: Vertrauliche Anwendung in Oracle-Identitätsdomains einrichten

Navigieren Sie in der OCI-Konsole zu Oracle-Identitätsdomains, und klicken Sie auf die Domain OracleIdentityCloudService.
Wählen Sie im linken Menü die Option Integrierte Anwendungen, und klicken Sie auf Anwendung hinzufügen.
Wählen Sie Vertikale Anwendung aus, und klicken Sie auf Workflow starten.
Geben Sie unter Name und Beschreibung einen Namen für die Anwendung ein, und klicken Sie auf Weiter.
Konfigurieren Sie die oAuth-Parameter der Anwendung.
1. Wählen Sie im Abschnitt Autorisierung die Option Autorisierungscode aus.
2. Geben Sie die folgenden URLs ein, und klicken Sie auf Weiter.
  - Umleitungs-URL: https://<YOUR-FQDN>/oauth2/callback.
  - Umleitungs-URL nach der Abmeldung: https://<YOUR-FQDN>.
  - Abmelde-URL: https://<YOUR-FQDN>/oauth2/sign_out.
Wählen Sie unter Web Tier Policy die Option Überspringen und später ausführen aus, und klicken Sie auf Fertigstellen.
Klicken Sie auf Aktivieren, um die Anwendung zu aktivieren.
Navigieren Sie im linken Menü zu Gruppen, und verknüpfen Sie die Benutzergruppen, die mit dieser Anwendung authentifiziert werden können.
Notieren Sie sich die Client-ID und das Client Secret.
Klicken Sie auf die Domain OracleIdentityCloudService, und blenden Sie die Domain-URL ein.

Beispiel: Die Identitätsdomain-URL lautet https://idcs-01234567890abcdef.identity.oraclecloud.com (die Portnummer wird durch Striping getrennt).

Aufgabe 4: Proxy OAuth2 bereitstellen

Wir verwenden den OAuth2-Proxy, um die Komplexität von OAuth2 oder OpenID Connect (OIDC) zu verarbeiten und sicherzustellen, dass alle an die Anwendungen weitergeleiteten Anforderungen authentifiziert werden.

Speichern Sie die folgende yaml-Datei mit dem Namen oauth2-proxy.yaml, und ersetzen Sie die Platzhalter durch die entsprechenden Werte.

Hinweis:

<Identity Domain URL>: https://idcs-01234567890abcdef.identity.oraclecloud.com/

<Identity Domain FQDN>: idcs-01234567890abcdef.identity.oraclecloud.com

---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    k8s-app: oauth2-proxy
  name: oauth2-proxy
spec:
  replicas: 1
  selector:
    matchLabels:
      k8s-app: oauth2-proxy
  template:
    metadata:
      labels:
        k8s-app: oauth2-proxy
    spec:
      containers:
      - args:
        - --provider=oidc
        - --provider-display-name="Oracle Identity Domains"
        - --oidc-issuer-url=<Identity Domain URL>
        - --redirect-url=https://<YOUR-FQDN>/oauth2/callback
        - --upstream=file:///dev/null
        - --http-address=0.0.0.0:4180
        - --email-domain=*
        - --set-xauthrequest=true
        - --session-cookie-minimal=true
        - --whitelist-domain=<Identity Domain FQDN>
        env:
        - name: OAUTH2_PROXY_CLIENT_ID
          value: "<APPLICATION_CLIENT_ID>"
        - name: OAUTH2_PROXY_CLIENT_SECRET
          value: "<APPLICATION_CLIENT_SECRET>"
        # docker run -ti --rm python:3-alpine python -c 'import secrets,base64; print(base64.b64encode(base64.b64encode(secrets.token_bytes(16))));'     
        - name: OAUTH2_PROXY_COOKIE_SECRET
          value: "<OUTPUT_OF_THE_ABOVE_DOCKER_COMMAND>"
        image: quay.io/oauth2-proxy/oauth2-proxy:latest
        imagePullPolicy: Always
        name: oauth2-proxy
        ports:
        - containerPort: 4180
          protocol: TCP
---
apiVersion: v1
kind: Service
metadata:
  labels:
    k8s-app: oauth2-proxy
  name: oauth2-proxy
spec:
  ports:
  - name: http
    port: 4180
    protocol: TCP
    targetPort: 4180
  selector:
    k8s-app: oauth2-proxy
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: oauth2-proxy
  annotations:
    nginx.ingress.kubernetes.io/configuration-snippet: |
      set $xheader "";
      if ( $request_uri = "/oauth2/sign_out" ){
        set $xheader "https://<Identity Domain FQDN>/oauth2/v1/userlogout;
      }
      proxy_set_header X-Auth-Request-Redirect ${xheader};
spec:
  ingressClassName: nginx
  rules:
  - host: <YOUR-FQDN>
    http:
      paths:
      - path: /oauth2
        pathType: Prefix
        backend:
          service:
            name: oauth2-proxy
            port:
              number: 4180
  tls:
  - hosts:
    - <YOUR-FQDN>

Stellen Sie den OAuth2-Proxy für OKE bereit.
```
kubectl apply -f oauth2-proxy.yaml
```
Prüfen Sie, ob der Pod ausgeführt wird.
```
kubectl get pods -l k8s-app=oauth2-proxy
```

Konfigurieren Sie Nginx so, dass der OAuth2-Proxy für die Anforderungsauthentifizierung verwendet wird.

Aktualisieren Sie die Datei ingress.yaml mit den Authentifizierungsannotationen.

---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: httpbin-ingress-nginx
  annotations:
    nginx.ingress.kubernetes.io/auth-url: "https://$host/oauth2/auth"
    nginx.ingress.kubernetes.io/auth-signin: "https://$host/oauth2/start?rd=$escaped_request_uri"
    nginx.ingress.kubernetes.io/auth-response-headers: "x-auth-request-user, x-auth-request-email"
spec:
  ingressClassName: nginx
  tls:
  - hosts:
      - "<YOUR-FQDN>"
  rules:
    - host: "<YOUR-FQDN>"
      http:
        paths:
          - pathType: Prefix
            path: "/"
            backend:
              service:
                name: httpbin
                port:
                  number: 5000

Versuchen Sie, eine Verbindung mit Ihrer Anwendung herzustellen. Sie sollten zur Oracle-Authentifizierungsseite umgeleitet werden. Sobald die Authentifizierung erfolgreich war, sollten Sie zu Ihrer Anwendung umgeleitet werden.

Es gibt zwei Header, die den authentifizierten Benutzer identifizieren.
```
"x-auth-request-user": "xxxx@oracle.com"
"x-auth-request-email": "xxxx@oracle.com"
```
Um sich von der Anwendung abzumelden, gehen Sie auf Ihrer Seite zu /oauth2/sign_out.
```
https://<YOUR-FQDN>/oauth2/sign_out
```
Bekanntes Problem: Die Umleitung nach der Abmeldung funktioniert nicht. Dieses Problem wird hier verfolgt: Fügen Sie der Abmeldeprovider-URL für den OIDC-Provider einen id_token_hint-Parameter hinzu.

Aufgabe 5: Ressourcen bereinigen

Führen Sie den folgenden Befehl aus, um alle bereitgestellten Kubernetes-Ressourcen zu löschen.

kubectl delete -f oauth2-proxy.yaml -f ingress.yaml -f application.yaml
helm uninstall ingress-nginx

Löschen Sie die Anwendung aus Oracle-Identitätsdomains.
Löschen Sie das OKE-Cluster.
Löschen Sie das für das OKE-Cluster erstellte VCN.
Hinweis:
- Sie müssen warten, bis das Löschen des OKE-Clusters und Knotenpools beendet ist.
- Der VCN-Name enthält den Namen des OKE-Clusters: OKE-VCN-quick-<OKE-cluster-name>-<random-string>.

Danksagungen

Autor - Andrei Ilas (Principal Cloud Architect)

Weitere Lernressourcen

Lernen Sie andere Übungen auf docs.oracle.com/learn kennen, oder greifen Sie auf weitere kostenlose Lerninhalte im Oracle Learning YouTube Channel zu. Außerdem können Sie education.oracle.com/learning-explorer besuchen, um Oracle Learning Explorer zu werden.

Die Produktdokumentation finden Sie im Oracle Help Center.

Titel und Copyright-Informationen

Secure Kubernetes Web Services using Nginx Ingress Controller, OAuth2 Proxy, and Oracle Identity Domains

F96450-01

April 2024

Oracle und/oder verbundene Unternehmen.