Beispiel: Nginx-Ingress-Controller für ein Cluster einrichten

Ingress-Controllerkomponenten

Der Ingress-Controller umfasst:

• Ein Ingress-Controller-Deployment mit dem Namen ingress-nginx-controller. Das Deployment stellt ein Image bereit, das die Binärdatei für den Ingress-Controller und Nginx enthält. Die Binärdatei ändert und lädt die Konfigurationsdatei /etc/nginx/nginx.conf neu, wenn ein Ingress in Kubernetes erstellt wird. Nginx-Upstreams verweisen auf Services, die mit angegebenen Selektoren übereinstimmen.
• Ein Ingress-Controllerservice mit dem Namen ingress-nginx-controller. Der Service zeigt das Ingress-Controller-Deployment als Service des Typs LoadBalancer an. Da Kubernetes Engine einen Oracle Cloud Infrastructure-Integrations-/Cloud-Provider verwendet, wird dynamisch ein Load Balancer erstellt, in dem die korrekten Knoten als Backend-Set konfiguriert sind.

Backend-Komponenten

Das hello-world-Backend umfasst:

• Ein Backend Deployment mit dem Namen docker-hello-world. Das Deployment verarbeitet Standardrouten für Health Checks und 404 Antworten. Dies geschieht durch die Verwendung eines hello-world-Bestandsimage, das die minimal erforderlichen Routen für ein Standard-Backend bereitstellt.
• Ein Backend-Service mit dem Namen docker-hello-world-svc. Der Service stellt das Backend Deployment zur Nutzung durch das Ingress-Controller-Deployment bereit.

Zugriffsregeln für den Ingress-Controller erstellen

1. Falls noch nicht geschehen, führen Sie die Schritte zum Einrichten der kubeconfig-Konfigurationsdatei des Clusters aus, und legen Sie (gegebenenfalls) die Umgebungsvariable KUBECONFIG so fest, dass sie auf die Datei verweist. Beachten Sie, dass Sie Ihre eigene kubeconfig-Datei einrichten müssen. Sie können nicht mit einer kubeconfig-Datei, die von einem anderen Benutzer eingerichtet wurde, auf ein Cluster zugreifen. Siehe Clusterzugriff einrichten.
2. Wenn Ihr Oracle Cloud Infrastructure-Benutzer ein Mandantenadministrator ist, überspringen Sie den nächsten Schritt, und gehen Sie direkt zu Ingress-Controller und zugehörige Ressourcen bereitstellen.

3. Wenn Ihr Oracle Cloud Infrastructure-Benutzer kein Mandantenadministrator ist, erteilen Sie im Terminalfenster dem Benutzer die Kubernetes-RBAC-clusterrole "cluster-admin" im Cluster, indem Sie Folgendes eingeben:

   kubectl create clusterrolebinding <my-cluster-admin-binding> --clusterrole=cluster-admin --user=<user-OCID>

   Hierbei gilt:

   • <my-cluster-admin-binding> ist eine Zeichenfolge Ihrer Wahl, die als Name für das Binding zwischen dem Benutzer und der Kubernetes-RBAC-clusterrole "cluster-admin" verwendet werden soll. Beispiel: jdoe_clst_adm
   • <user-OCID> ist die OCID des Benutzers (aus der Konsole abgerufen). Beispiel: ocid1.user.oc1..aaaaa...zutq (zur besseren Lesbarkeit abgekürzt).

   Beispiel:

   kubectl create clusterrolebinding jdoe_clst_adm --clusterrole=cluster-admin --user=ocid1.user.oc1..aaaaa...zutq

Ingress Controller und zugehörige Ressourcen bereitstellen

Das Deployment des Ingress-Controllers und der zugehörigen Ressourcen (einschließlich der Kubernetes-RBAC-Rollen und -Bindings und des Ingress-Controllerservice ingress-nginx-controller vom Typ LoadBalancer) hängt davon ab, ob Sie das Deployment in einem Cluster mit verwalteten/selbstverwalteten Knoten oder in einem Cluster mit virtuellen Knoten ausführen:

• Verwaltete Knoten und selbstverwaltete Knoten

  Um den Nginx-Ingress-Controller bereitzustellen, führen Sie den folgenden Befehl aus:

  kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v<vnum>/deploy/static/provider/cloud/deploy.yaml

  Dabei ist <vnum> die Versionsnummer der neuesten Version des Ingress-Controller-Deployment-Skripts ingress-nginx-controller. Beispiel: Zum Zeitpunkt des Schreibens hat die neueste Version des Skripts die Versionsnummer 1.1.3. Der auszuführende Befehl lautet:

  kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.1.3/deploy/static/provider/cloud/deploy.yaml

  Informationen zur Versionsnummer der neuesten Version des Skripts finden Sie in der Dokumentation zu kubernetes/ingress-nginx auf GitHub.

• Virtuelle Knoten

  Auf virtuellen Knoten müssen Sie das Deployment-Manifest des Ingress-Controllers ändern und die Sicherheitskontexte fsgroup, allowprivilegeEscalation und capabilities auskommentieren. Ein Beispiel für ein solches geändertes Deployment-Manifest finden Sie unter https://github.com/oracle-devrel/oci-oke-virtual-nodes/tree/main/ingress-nginx.

  Um den Nginx-Ingress-Controller basierend auf diesem geänderten Manifest bereitzustellen, führen Sie den folgenden Befehl aus:

  kubectl apply -f https://raw.githubusercontent.com/oracle-devrel/oci-oke-virtual-nodes/main/ingress-nginx/deploy.yaml

Prüfen, ob der Ingress-Controller-Service ingress-nginx-controller als Load Balancer-Service ausgeführt wird

1. Zeigen Sie die Liste der ausgeführten Services an, indem Sie Folgendes eingeben:

   kubectl get svc -n ingress-nginx

   Die Ausgabe des obigen Befehls zeigt die ausgeführten Services an:

   
   NAME                       TYPE           CLUSTER-IP     EXTERNAL-IP    PORT(S)                       AGE
   ingress-nginx-controller   LoadBalancer   10.96.229.38   <pending>      80:30756/TCP,443:30118/TCP    1h
   

   Die EXTERNAL-IP für den Ingress-Controller-Service ingress-nginx-controller wird so lange als <pending> angezeigt, bis der Load Balancer vollständig in Oracle Cloud Infrastructure erstellt wurde.

2. Wiederholen Sie den Befehl kubectl get svc, bis eine EXTERNAL-IP für den Ingress-Controller-Service ingress-nginx-controller angezeigt wird:

   kubectl get svc -n ingress-nginx
   

   Die Ausgabe des obigen Befehls zeigt die EXTERNAL-IP für den Ingress-Controllerservice ingress-nginx-controller an:

   
   NAME                       TYPE           CLUSTER-IP     EXTERNAL-IP       PORT(S)                       AGE
   ingress-nginx-controller   LoadBalancer   10.96.229.38   129.146.214.219   80:30756/TCP,443:30118/TCP    1h

TLS-Secret erstellen

Ein TLS-Secret wird für die SSL-Beendigung des Ingress-Controllers verwendet.

1. Geben Sie einen neuen Schlüssel in einer Datei aus. Beispiel: Geben Sie Folgendes ein:

   openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout tls.key -out tls.crt -subj "/CN=nginxsvc/O=nginxsvc"

   Um das Secret für dieses Beispiel zu generieren, wird ein selbstsigniertes Zertifikat verwendet. Obwohl dies zu Testzwecken in Ordnung ist, verwenden Sie für die Produktion ein von einer Certificate Authority signiertes Zertifikat.

   Hinweis
   
   Unter Windows müssen Sie möglicherweise "/CN=nginxsvc/O=nginxsvc" durch "//CN=nginxsvc\O=nginxsvc" ersetzen. Beispiel: Dies ist erforderlich, wenn Sie den Befehl openssl aus einer Git Bash-Shell ausführen.

2. Erstellen Sie das TLS-Secret, indem Sie Folgendes eingeben:

   kubectl create secret tls tls-secret --key tls.key --cert tls.crt

Docker-hello-world-Servicedefinition erstellen

1. Erstellen Sie die Datei hello-world-ingress.yaml mit dem folgenden Code. Dieser Code verwendet ein öffentlich verfügbares hello-world-Image von Docker Hub. Sie können es durch ein anderes Image Ihrer Wahl ersetzen, das auf ähnliche Weise ausgeführt werden kann.

   
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: docker-hello-world
     labels:
       app: docker-hello-world
   spec:
     selector:
       matchLabels:
         app: docker-hello-world
     replicas: 3
     template:
       metadata:
         labels:
           app: docker-hello-world
       spec:
         containers:
         - name: docker-hello-world
           image: scottsbaldwin/docker-hello-world:latest
           ports:
           - containerPort: 80
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: docker-hello-world-svc
   spec:
     selector:
       app: docker-hello-world
     ports:
       - port: 8088
         targetPort: 80
     type: ClusterIP
   

   Beachten Sie, dass der Typ des docker-hello-world-Service ClusterIP und nicht LoadBalancer lautet, weil dieser Service den Ingress-Controller-Service ingress-nginx-controller als Proxy verwendet. Der docker-hello-world-Service benötigt keinen direkten öffentlichen Zugriff darauf. Stattdessen wird der öffentliche Zugriff vom Load Balancer an den Ingress-Controller und vom Ingress-Controller an den Upstreamservice weitergeleitet.

2. Erstellen Sie das neue hello-world-Deployment und den Service auf Knoten im Cluster, indem Sie den folgenden Befehl ausführen:

   kubectl create -f hello-world-ingress.yaml

Ingress-Ressource erstellen

1. Erstellen Sie die Datei ingress.yaml, und füllen Sie sie mit dem folgenden Code auf:

   
   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: hello-world-ing
     annotations:
       kubernetes.io/ingress.class: "nginx"
   spec:
     tls:
     - secretName: tls-secret
     rules:
     - http:
         paths:
           - path: /
             pathType: Prefix
             backend:
               service:
                 name: docker-hello-world-svc
                 port:
                   number: 8088
   

   Beachten Sie, dass das obige Beispiel YAML mit Clustern funktioniert, auf denen Kubernetes-Version 1.19.x und höher ausgeführt wird.

2. Erstellen Sie die Ressource, indem Sie Folgendes eingeben:

   kubectl create -f ingress.yaml

Externe IP-Adresse des Load Balancers abrufen

Um sicherzustellen, dass der ingress-nginx-controller-Service als LoadBalancer-Service ausgeführt wird, erhalten Sie seine externe IP-Adresse, indem Sie Folgendes eingeben:

kubectl get svc --all-namespaces

Die Ausgabe des obigen Befehls zeigt die ausgeführten Services an:

NAMESPACE       NAME                          TYPE           CLUSTER-IP      EXTERNAL-IP      PORT(S)                      AGE
default         docker-hello-world-svc      ClusterIP      10.96.83.247    <none>           8088/TCP                     16s
default         kubernetes                  ClusterIP      10.96.0.1       <none>           443/TCP                      1h
ingress-nginx   ingress-nginx-controller    LoadBalancer   10.96.229.38    129.146.214.219  80:30756/TCP,443:30118/TCP   5m			
kube-system     kube-dns                    ClusterIP      10.96.5.5       <none>           53/UDP,53/TCP                1h

cURL-Anforderungen an den Load Balancer senden

1. Verwenden Sie die externe IP-Adresse des ingress-nginx-controller-Service (z.B. 129.146.214.219), um eine HTTP-Anforderung zu lockern, indem Sie Folgendes eingeben:

   curl -I http://129.146.214.219
   

   Beispielausgabe des obigen Befehls:

   HTTP/1.1 301 Moved Permanently
   Via: 1.1 10.68.69.10 (McAfee Web Gateway 7.6.2.10.0.23236)
   Date: Thu, 07 Sep 2017 15:20:16 GMT
   Server: nginx/1.13.2
   Location: https://129.146.214.219/
   Content-Type: text/html
   Content-Length: 185
   Proxy-Connection: Keep-Alive
   Strict-Transport-Security: max-age=15724800; includeSubDomains;
   

   Die Ausgabe zeigt eine 301-Umleitung und einen Location-Header an, was darauf hinweist, dass HTTP-Traffic an HTTPS umgeleitet wird.

2. Senden Sie entweder eine cURL-Anforderung an die HTTPS-URL, oder fügen Sie die Option -L hinzu, um dem Location-Header automatisch zu folgen. Die Option -k weist cURL an, die SSL-Zertifikate nicht zu verifizieren. Beispiel: Geben Sie Folgendes ein:

   curl -ikL http://129.146.214.219

   Beispielausgabe des obigen Befehls:

   HTTP/1.1 301 Moved Permanently
   Via: 1.1 10.68.69.10 (McAfee Web Gateway 7.6.2.10.0.23236)
   Date: Thu, 07 Sep 2017 15:22:29 GMT
   Server: nginx/1.13.2
   Location: https://129.146.214.219/
   Content-Type: text/html
   Content-Length: 185
   Proxy-Connection: Keep-Alive
   Strict-Transport-Security: max-age=15724800; includeSubDomains;
   
   HTTP/1.0 200 Connection established
   
   HTTP/1.1 200 OK
   Server: nginx/1.13.2
   Date: Thu, 07 Sep 2017 15:22:30 GMT
   Content-Type: text/html
   Content-Length: 71
   Connection: keep-alive
   Last-Modified: Thu, 07 Sep 2017 15:17:24 GMT
   ETag: "59b16304-47"
   Accept-Ranges: bytes
   Strict-Transport-Security: max-age=15724800; includeSubDomains;
   
   <h1>Hello webhook world from: docker-hello-world-1732906117-0ztkm</h1>
   

   In der letzten Zeile der Ausgabe wird die HTML angezeigt, die vom Pod mit dem Hostnamen docker-hello-world-1732906117-0ztkm zurückgesendet wird.

3. Führen Sie die cURL-Anforderung mehrmals aus, um die Änderung des Hostnamen in der HTML-Ausgabe zu sehen und somit sicherzustellen, dass Load Balancing stattfindet:

   $ curl -k https://129.146.214.219
   
   <h1>Hello webhook world from: docker-hello-world-1732906117-6115l</h1>
   
   $ curl -k https://129.146.214.219
   
   <h1>Hello webhook world from: docker-hello-world-1732906117-7r89v</h1>
   
   $ curl -k https://129.146.214.219
   
   <h1>Hello webhook world from: docker-hello-world-1732906117-0ztkm</h1>

Nginx.conf prüfen

Das Deployment des Ingress-Controllers ingress-nginx-controller bearbeitet die Datei nginx.conf im Pod, in dem sie ausgeführt wird.

1. Suchen Sie den Namen des Pods, auf dem das Deployment des Inress-Controllers ingress-nginx-controller ausgeführt wird, indem Sie Folgendes eingeben:

   kubectl get po -n ingress-nginx
   

   Die Ausgabe des obigen Befehls zeigt den Namen des Pods an, auf dem das Deployment des Ingress-Controllers ingress-nginx-controller ausgeführt wird:

   
   NAME                                       READY     STATUS    RESTARTS   AGE
   ingress-nginx-controller-110676328-h86xg   1/1       Running   0          1h
   

2. Verwenden Sie den Namen des Pods, auf dem das Deployment des Ingress-Controllers ingress-nginx-controller ausgeführt wird, und zeigen Sie den Inhalt von nginx.conf an, indem Sie den folgenden kubectl exec-Befehl an:

   kubectl exec -n ingress-nginx -it ingress-nginx-controller-110676328-h86xg -- cat /etc/nginx/nginx.conf
   

3. Suchen Sie in der Ausgabe nach proxy_pass. Diese Zeichenfolge ist einmal für das Standard-Backend und einmal in etwa wie folgt vorhanden:

   proxy_pass http://upstream_balancer;
   

   Dadurch wird dargestellt, dass Nginx als Proxy Anforderungen an einen Upstream mit dem Namen upstream_balancer weiterleitet.

4. Suchen Sie die Upstreamdefinition in der Ausgabe. Sie sieht in etwa wie folgt aus:

   upstream upstream_balancer {
                   server 0.0.0.1:1234; # placeholder
   
                   balancer_by_lua_block {
                           tcp_udp_balancer.balance()
                   }
           }
   
   

   Der Upstream fungiert als Proxy in Richtung Lua.

Entfernen des Beispiel-Ingress-Controllers

1. Führen Sie den folgenden Befehl aus, um den zuvor erstellten Ingress-Beispielcontroller zu entfernen:

   kubectl delete -f <deployment-script-location>

   Dabei ist <deployment-script-location> der Speicherort des Deployment-Skripts, das Sie zuvor zum Erstellen des Ingress-Beispielcontrollers verwendet haben.

   Beispiel:

   kubectl delete -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.1.3/deploy/static/provider/cloud/deploy.yaml