Hinweis:

• Dieses Tutorial erfordert Zugriff auf Oracle Cloud. Informationen zur Registrierung für einen kostenlosen Account finden Sie unter Erste Schritte mit Oracle Cloud Infrastructure Free Tier.
• Es verwendet Beispielwerte für Oracle Cloud Infrastructure-Zugangsdaten, -Mandanten und -Compartments. Ersetzen Sie diese Werte nach Abschluss der Übung durch Werte, die für Ihre Cloud-Umgebung spezifisch sind.

Nutzen Sie SSH-Tunneling mit der Oracle Cloud Infrastructure Kubernetes Engine für eine sichere Anwendungsentwicklung

Einführung

Als ich SSH-Tunneling mit OKE bekam, der mit Ali Mukadams Hilfe arbeitete, nannte ich es "Magie".

Er antwortete mir mit der folgenden Nachricht:

"Du nennst es Magie, andere nennen es Wissenschaft. Wo ich bin, sind sie ein und dasselbe."

Das ursprüngliche Zitat stammt aus einem Thor-Film:

"Ihre Vorfahren nannten es Magie, aber Sie nennen es Wissenschaft. Ich komme aus einem Land, in dem sie eins und dasselbe sind."

Was ist diese Magie?

Bei der modernen Anwendungsentwicklung ist die Sicherung von Verbindungen zwischen lokalen und cloudbasierten Ressourcen unerlässlich, insbesondere bei der Arbeit mit der Oracle Cloud Infrastructure Kubernetes Engine (OCI Kubernetes Engine oder OKE). SSH-Tunneling bietet eine einfache, aber leistungsstarke Möglichkeit, eine sichere Verbindung zu OKE-Clustern herzustellen, sodass Entwickler Ressourcen verwalten und mit ihnen interagieren können, ohne sie dem öffentlichen Internet zugänglich zu machen. In diesem Tutorial wird erläutert, wie Sie SSH-Tunneling mit OKE einrichten und wie Entwickler diesen Ansatz in ihren Workflow integrieren können, um die Sicherheit und Effizienz zu verbessern. Von der anfänglichen Konfiguration bis zu Best Practices decken wir alles ab, was Sie benötigen, um SSH-Tunneling effektiv in Ihren OKE-basierten Anwendungen zu nutzen.

Die folgende Abbildung zeigt den vollständigen Verkehrswert von SSH-Tunneling für zwei verschiedene Anwendungen.

Ziele

• Nutzen Sie SSH-Tunneling mit OKE für eine sichere Anwendungsentwicklung.

Aufgabe 1: Kubernetes-Cluster auf OKE bereitstellen (mit einer Bastion- und Operatorinstanz)

Stellen Sie sicher, dass ein bereitgestelltes Kubernetes-Cluster auf OKE vorhanden ist.

• Um ein Kubernetes-Cluster auf OKE bereitzustellen, verwenden Sie eine der folgenden Methoden:

  • Kubernetes-Cluster mit Terraform mit Oracle Cloud Infrastructure Kubernetes Engine bereitstellen: Stellen Sie ein einzelnes Kubernetes-Cluster auf OKE mit Terraform bereit.

  • Mit Terraform mehrere Kubernetes-Cluster über verschiedene OCI-Regionen mit OKE bereitstellen und ein vollständiges Mesh-Netzwerk mit RPC erstellen: Stellen Sie mehrere Kubernetes-Cluster auf mehreren Regionen in OKE mit Terraform bereit.

  • Aufgabe 1: Neues Kubernetes-Cluster erstellen und Komponenten prüfen: Stellen Sie ein Kubernetes-Cluster auf OKE im Modus Schnellerstellung bereit.

  • Aufgabe 1: Kubernetes-Cluster mit OKE bereitstellen: Stellen Sie ein Kubernetes-Cluster auf OKE im Modus Benutzerdefinierte Erstellung bereit.

  In diesem Tutorial verwenden wir Kubernetes-Cluster mit Terraform mit Oracle Cloud Infrastructure Kubernetes Engine bereitstellen als Kubernetes-Basiscluster auf OKE, um zu erklären, wie wir mit einem SSH-Tunnel auf eine containerbasierte Anwendung zugreifen können, die auf OKE mit localhost bereitgestellt wird.

  Lassen Sie uns die OCI OKE-Umgebung schnell prüfen, um die Bühne zu schaffen.

• Virtuelles Cloud-Netzwerk (VCN)

  Melden Sie sich bei der OCI-Konsole an, und navigieren Sie zu Networking und Virtuelle Cloud-Netzwerke.

  • Prüfen Sie das VCN mit dem Namen oke.

  • Klicken Sie auf das oke-VCN.

  

• Subnetze

  Gehen Sie zur VCN-Detailseite.

  1. Klicken Sie auf Subnetze.
  2. Prüfen Sie die bereitgestellten Subnetze.

  

• Gateways

  Gehen Sie zur VCN-Detailseite.

  1. Klicken Sie auf Internetgateways.
  2. Prüfen Sie das erstellte Internetgateway.

  

  1. Klicken Sie auf NAT-Gateways.
  2. Prüfen Sie das erstellte NAT-Gateway.

  

  1. Klicken Sie auf Servicegateways.
  2. Prüfen Sie das erstellte Servicegateway.

  

  1. Klicken Sie auf Sicherheitslisten.
  2. Prüfen Sie die erstellten Sicherheitslisten.

  

• Knotenpools

  Navigieren Sie zu Entwicklerservices und Container und Artefakte.

  1. Klicken Sie auf Kubernetes-Cluster (OKE).
  2. Klicken Sie auf das oke-Cluster.

  

  1. Klicken Sie auf Knotenpools.
  2. Prüfen Sie die Knotenpools.

  

• Instanzen

  Navigieren Sie zu Compute und Instanzen.

  1. Klicken Sie auf Instanzen.
  2. Prüfen Sie die Deployments der Kubernetes-Worker-Knoten.
  3. Prüfen Sie das Deployment des Bastionhosts.
  4. Prüfen Sie das Deployment des Kubernetes-Operators.

  

• Die folgende Abbildung zeigt einen vollständigen Überblick darüber, was unser Ausgangspunkt für den restlichen Inhalt dieses Tutorials sein wird.

  

• Die folgende Abbildung zeigt eine vereinfachte Ansicht der vorherigen Abbildung. Wir werden diese Zahl im Rest dieses Tutorials verwenden.

  

Aufgabe 2: NGINX-Webserver auf dem Kubernetes-Cluster bereitstellen

Der Betreiber ist nicht direkt über das Internet erreichbar und wir müssen durch den Bastion Host gehen.

• In diesem Tutorial verwenden wir ein SSH-Skript, das von Ali Mukadam bereitgestellt wird, um mit einem einzigen SSH-Befehl eine Verbindung zum Operator herzustellen. Dieses Skript und diese Methode für die Verbindung finden Sie hier: Aufgabe 4: Verbindung mit Bastion und Operator prüfen. Sie benötigen dieses Skript später in diesem Tutorial, also stellen Sie sicher, dass Sie es verwenden.

  • Richten Sie eine SSH-Session für den Kubernetes-Operator ein.

  • Prüfen Sie die aktiven Worker-Knoten mit dem Befehl kubectl get nodes.

  • Prüfen Sie alle aktiven Worker-Knoten.

  

• Um eine NGINX-Beispielanwendung zu erstellen, die in einem Container ausgeführt wird, erstellen Sie eine YAML-Datei mit dem Namen modified2_nginx_ext_lb.yaml mit dem folgenden Code für den Operator.

  Die YAML-Datei enthält den Code zum Erstellen der NGINX-Webserveranwendung mit 3 Replikaten. Außerdem wird ein Service vom Typ Load Balancer erstellt.

  modified2_nginx_ext_lb.yaml:

  apiVersion: apps/v1
  kind: Deployment
  metadata:
    name: my-nginx
    labels:
      app: nginx
  spec:
    replicas: 3
    selector:
      matchLabels:
        app: nginx
    template:
      metadata:
        labels:
    app: nginx
      spec:
        containers:
        - name: nginx
          image: nginx:latest
          ports:
    - containerPort: 80
  ---
  apiVersion: v1
  kind: Service
  metadata:
    name: my-nginx-svc
    labels:
      app: nginx
    annotations:
      oci.oraclecloud.com/load-balancer-type: "lb"
      service.beta.kubernetes.io/oci-load-balancer-internal: "true"
      service.beta.kubernetes.io/oci-load-balancer-subnet1: "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaaguwakvc6jxxxxxxxxxxxxxxxxxxxu7rixvdf5urvpxldhya"
      service.beta.kubernetes.io/oci-load-balancer-shape: "flexible"
      service.beta.kubernetes.io/oci-load-balancer-shape-flex-min: "50"
      service.beta.kubernetes.io/oci-load-balancer-shape-flex-max: "100"
  spec:
    type: LoadBalancer
    ports:
    - port: 80
    selector:
      app: nginx
  

• Wir möchten diese Anwendung intern zugänglich machen und den Service des Typs Load Balancer erstellen, der an das private Load-Balancer-Subnetz angehängt ist.

  Um den Service des Typs "Load Balancer" einem privaten Load-Balancer-Subnetz zuzuweisen, benötigen Sie die Subnetz-OCID des privaten Load-Balancer-Subnetzes. Sie müssen den folgenden Code im Abschnitt Annotationen hinzufügen.

  annotations:
    oci.oraclecloud.com/load-balancer-type: "lb"
    service.beta.kubernetes.io/oci-load-balancer-internal: "true"
    service.beta.kubernetes.io/oci-load-balancer-subnet1: "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaaguwakvcxxxxxxxxxxxxxxxxxxxxxxxxxxxxixvdf5urvpxldhya"
    service.beta.kubernetes.io/oci-load-balancer-shape: "flexible"
    service.beta.kubernetes.io/oci-load-balancer-shape-flex-min: "50"
    service.beta.kubernetes.io/oci-load-balancer-shape-flex-max: "100"
  

• Um die Subnetz-OCID des privaten Load-Balancer-Subnetzes abzurufen, klicken Sie auf das interne Load-Balancer-Subnetz.

  

  Klicken Sie auf Anzeigen und Kopieren, um die OCID des vollständigen privaten Load-Balancer-Subnetzes anzuzeigen. Verwenden Sie diese OCID im Abschnitt Annotationen.

  

• Um die NGINX-Anwendung und den Service vom Typ Load Balancer bereitzustellen, führen Sie die folgenden Befehle aus:

  1. So erstellen Sie die YAML-Datei für den Operator:

     nano modified2_nginx_ext_lb.yaml
     

  2. So stellen Sie die NGINX-Anwendung mit dem Service des Typs "Load Balancer" bereit.

     kubectl apply -f modified2_nginx_ext_lb.yaml
     

     Um zu prüfen, ob die NGINX-Anwendung erfolgreich bereitgestellt wurde (nicht im Image angezeigt).

     kubectl get pods
     

  3. Um zu prüfen, ob der Service des Typs "Load Balancer" erfolgreich bereitgestellt wurde.

     kubectl get svc
     

  4. Beachten Sie, dass der Service des Typs "Load Balancer" erfolgreich bereitgestellt wurde.

  

• Im internen Load-Balancer-Subnetz wird angezeigt, dass der CIDR-Block für dieses Subnetz 10.0.2.0/27 lautet. Der neue Service des Load Balancers hat die IP-Adresse 10.0.2.3.

  

• Um das Load Balancer-Objekt in der OCI-Konsole zu prüfen, navigieren Sie zu Networking, Load Balancer, und klicken Sie auf Load Balancer.

  

• Die folgende Abbildung veranschaulicht die bisherige Bereitstellung. Beachten Sie, dass der Load Balancer hinzugefügt wird.

  

Neuen Pod/Anwendung testen

• Ansatz 1: Von einem temporären Pod

  Um zu testen, ob die neu bereitgestellte NGINX-Anwendung mit dem Service des Typs Load Balancer funktioniert, können Sie einen internen Konnektivitätstest mit einem temporären Pod ausführen.

  Es gibt mehrere Möglichkeiten, die Konnektivität zur Anwendung zu testen. Eine Möglichkeit besteht darin, einen Browser zu öffnen und zu testen, ob Sie auf die Webseite zugreifen können. Wenn jedoch kein Browser verfügbar ist, können wir einen weiteren Schnelltest durchführen, indem wir einen temporären Pod bereitstellen.

  Informationen zum Erstellen eines temporären Pods und zur Verwendung dieses Pods für Konnektivitätstests finden Sie unter Aufgabe 3: Beispielwebanwendung und -service bereitstellen.

  • Führen Sie den folgenden Befehl aus:

    1. IP-Adresse des internen Load-Balancer-Service abrufen.

       kubectl get svc
       

    2. So stellen Sie einen Beispiel-Pod bereit, um die Webanwendungskonnektivität zu testen:

       kubectl run --rm -i -t --image=alpine test-$RANDOM -- sh
       

    3. So testen Sie die Konnektivität zum Webserver mit wget.

       wget -qO- http://<ip-of-internal-lb-service>
       

    4. Beachten Sie den HTML-Code, den der Webserver zurückgibt, und bestätigen Sie, dass der Webserver und die Konnektivität mit dem internen Load Balancing-Service funktionieren.

    

  • Führen Sie den folgenden Befehl aus, um den temporären Pod zu beenden.

    exit
    

    Beachten Sie, dass der Pod sofort nach dem Schließen der Befehlszeilenschnittstelle gelöscht wird.

  • Die folgende Abbildung veranschaulicht die bisherige Bereitstellung. Beachten Sie, dass der vorübergehend bereitgestellte Pod eine Verbindung zum Service des Typs "Load Balancer-IP" herstellt, um die Konnektivität zu testen.

    

• Ansatz 2: Von Ihrem lokalen Computer

  • Führen Sie den folgenden Befehl aus, um die Konnektivität zur NGINX-Testanwendung mit dem Service vom Typ Load Balancer von unserem lokalen Laptop aus zu testen.

    iwhooge@iwhooge-mac ~ % wget -qO- <ip-of-internal-lb-service>
    

    Wie Sie feststellen werden, funktioniert dies derzeit nicht, da der Service des Typs Load Balancer über eine interne IP-Adresse verfügt und diese nur innerhalb der Kubernetes-Umgebung erreichbar ist.

  • Führen Sie den folgenden Befehl aus, um mit der lokalen IP-Adresse mit einem benutzerdefinierten Port 8080 auf die NGINX-Anwendung zuzugreifen.

    iwhooge@iwhooge-mac ~ % wget -qO- 127.0.0.1:8080
    iwhooge@iwhooge-mac ~ %
    

    Im Moment funktioniert das nicht, aber wir verwenden den gleichen Befehl später in diesem Tutorial, nachdem wir den SSH-Tunnel eingerichtet haben.

• Die folgende Abbildung veranschaulicht die bisherige Bereitstellung. Beachten Sie, dass die getunnelte Verbindung zur lokalen IP-Adresse nicht funktioniert.

  

Aufgabe 3: SSH-Konfigurationsskript mit Localhost-Einträgen erstellen

Damit der SSH-Tunnel funktionieren kann, müssen Sie den folgenden Eintrag in der SSH-Konfigurationsdatei im Ordner /Users/iwhooge/.ssh hinzufügen.

• Führen Sie den Befehl nano /Users/iwhooge/.ssh/config aus, um die Konfigurationsdatei zu bearbeiten.

• Fügen Sie die folgende Zeile im Abschnitt Host operator47 hinzu.

  LocalForward 8080 127.0.0.1:8080
  

• Die Ausgabe der SSH-Konfigurationsdatei.

  iwhooge@iwhooge-mac .ssh % pwd
  /Users/iwhooge/.ssh
  
  iwhooge@iwhooge-mac .ssh % more config
  Host bastion47
      HostName 129.xxx.xxx.xxx
      user opc
      IdentityFile ~/.ssh/id_rsa
      UserKnownHostsFile /dev/null
      StrictHostKeyChecking=no
      TCPKeepAlive=yes
      ServerAliveInterval=50
  
  Host operator47
      HostName 10.0.0.11
      user opc
      IdentityFile ~/.ssh/id_rsa
      ProxyJump bastion47
      UserKnownHostsFile /dev/null
      StrictHostKeyChecking=no
      TCPKeepAlive=yes
      ServerAliveInterval=50
      LocalForward 8080 127.0.0.1:8080
  iwhooge@iwhooge-mac .ssh %
  

• Beachten Sie, dass der Befehl LocalForward zur SSH-Konfigurationsdatei hinzugefügt wird.

  

Aufgabe 4: SSH-Tunnel einrichten und mit Localhost eine Verbindung zum NGINX-Webserver herstellen

• Wenn Sie mit SSH mit dem Operator verbunden sind, trennen Sie diese Session.

  1. Melden Sie sich mit dem Skript erneut beim Operator an.

     iwhooge@iwhooge-mac ~ % ssh operator47
     

  2. Führen Sie den folgenden Befehl aus, um die IP-Adresse des internen Load-Balancer-Service abzurufen.

     [opc@o-sqrtga ~]$ kubectl get svc
     

  3. Führen Sie den folgenden Befehl im Operator (SSH-Fenster) aus, um den SSH-Tunnel einzurichten und den gesamten Traffic, der an localhost 8080 geleitet wird, an den Service des Typs Load Balancer 80 weiterzuleiten. Der Service des Typs "Load Balancer" leitet den Traffic dann schließlich an die NGINX-Anwendung weiter.

     [opc@o-sqrtga ~]$ k port-forward svc/my-nginx-svc 8080:80
     

     Beachten Sie die Weiterleitungsmeldungen im SSH-Fenster, dass der localhost-Port 8080 an Port 80 weitergeleitet wird.

     Forwarding from 127.0.0.1:8080 -> 80
     Forwarding from [::1]:8080 -> 80
     

  

• Testen Sie die Konnektivität von Ihrem lokalen Computer aus, und prüfen Sie, ob die Konnektivität mit einer lokalen IP-Adresse (127.0.0.1) mit Port 8080 funktioniert, und prüfen Sie, ob Sie dadurch eine Verbindung zur NGINX-Anwendung innerhalb der OKE-Umgebung herstellen können.

• Öffnen Sie ein neues Terminal, und führen Sie den folgenden Befehl aus, um die Konnektivität zu testen.

  iwhooge@iwhooge-mac ~ % wget -qO- 127.0.0.1:8080
  

• Beachten Sie, dass Sie die folgende Ausgabe im Terminal Ihres lokalen Computers erhalten, sodass dieser funktioniert.

  iwhooge@iwhooge-mac ~ % wget -qO- 127.0.0.1:8080
  <!DOCTYPE html>
  <html>
  <head>
  <title>Welcome to nginx!</title>
  <style>
  html { color-scheme: light dark; }
  body { width: 35em; margin: 0 auto;
  font-family: Tahoma, Verdana, Arial, sans-serif; }
  </style>
  </head>
  <body>
  <h1>Welcome to nginx!</h1>
  <p>If you see this page, the nginx web server is successfully installed and
  working. Further configuration is required.</p>
  
  <p>For online documentation and support please refer to
  <a href="http://nginx.org/">nginx.org</a>.<br/>
  Commercial support is available at
  <a href="http://nginx.com/">nginx.com</a>.</p>
  
  <p><em>Thank you for using nginx.</em></p>
  </body>
  </html>
  iwhooge@iwhooge-mac ~ %
  

• Beachten Sie im SSH-Fenster des Operators, dass sich die Ausgabe geändert hat und eine neue Zeile mit dem Befehl Handling connection for 8080 hinzugefügt wurde.

  

• Ein Schnelltest mit einem Webbrowser zeigt die folgende Ausgabe an.

  

• Die folgende Abbildung veranschaulicht die bisherige Bereitstellung. Beachten Sie, dass die Tunnelverbindung zur lokalen IP-Adresse funktioniert.

  

Aufgabe 5: MySQL Database Service auf dem Kubernetes-Cluster bereitstellen

Sie können die NGINX-Anwendung über den SSH-Tunnel erreichen. Fügen Sie jetzt einen MySQL-Datenbankservice hinzu, der in der OKE-Umgebung ausgeführt wird.

• Um einen MySQL-Datenbankservice in einer Kubernetes-Umgebung einzurichten, müssen Sie Folgendes erstellen:

  • Ein Geheimnis für den Passwortschutz.
  • Ein Persistent Volume und ein Persistent Volume Claim für Datenbankspeicher.
  • Der MYSQL-Datenbankservice mit einem Service des Typs "Load Balancer".

• Führen Sie die folgenden Befehle aus, um:

  1. Erstellen Sie das Kennwort für den Datenbankservice MySQL.

     nano mysql-secret.yaml
     

     Kopieren Sie den folgenden YAML-Code in mysql-secret.yaml.

     apiVersion: v1
     kind: Secret
     metadata:
       name: mysql-secret
     type: kubernetes.io/basic-auth
     stringData:
       password: Or@cle1
     

  2. Wenden Sie den YAML-Code an.

     kubectl apply -f mysql-secret.yaml
     

  3. Erstellen Sie den Speicher für den Datenbankservice MySQL.

     nano mysql-storage.yaml
     

     Kopieren Sie den folgenden YAML-Code in mysql-storage.yaml.

     apiVersion: v1
     kind: PersistentVolume
     metadata:
       name: mysql-pv-volume
       labels:
         type: local
     spec:
       storageClassName: manual
       capacity:
         storage: 20Gi
       accessModes:
         - ReadWriteOnce
       hostPath:
         path: "/mnt/data"
     ---
     apiVersion: v1
     kind: PersistentVolumeClaim
     metadata:
       name: mysql-pv-claim
     spec:
       storageClassName: manual
       accessModes:
         - ReadWriteOnce
       resources:
         requests:
           storage: 20Gi
     

  4. Wenden Sie den YAML-Code an.

     kubectl apply -f mysql-storage.yaml
     

  5. Erstellen Sie den Datenbankservice MySQL und den Service vom Typ Load Balancer.

     nano mysql-deployment.yaml
     

     Kopieren Sie den folgenden YAML-Code in mysql-deployment.yaml.

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: mysql
     spec:
       selector:
         matchLabels:
           app: mysql
       strategy:
         type: Recreate
       template:
         metadata:
           labels:
             app: mysql
         spec:
           containers:
           - image: mysql:latest
             name: mysql
             env:
             - name: MYSQL_ROOT_PASSWORD
               valueFrom:
                 secretKeyRef:
                   name: mysql-secret
                   key: password
             ports:
             - containerPort: 3306
               name: mysql
             volumeMounts:
             - name: mysql-persistent-storage
               mountPath: /var/lib/mysql
           volumes:
           - name: mysql-persistent-storage
             persistentVolumeClaim:
               claimName: mysql-pv-claim
     ---
     apiVersion: v1
     kind: Service
     metadata:
       name: my-mysql-svc
       labels:
         app: mysql
       annotations:
         oci.oraclecloud.com/load-balancer-type: "lb"
         service.beta.kubernetes.io/oci-load-balancer-internal: "true"
         service.beta.kubernetes.io/oci-load-balancer-subnet1: "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaaguwakvc6xxxxxxxxxxxxxxxxxxxxxx2rseu7rixvdf5urvpxldhya"
         service.beta.kubernetes.io/oci-load-balancer-shape: "flexible"
         service.beta.kubernetes.io/oci-load-balancer-shape-flex-min: "50"
         service.beta.kubernetes.io/oci-load-balancer-shape-flex-max: "100"
     spec:
       type: LoadBalancer
       ports:
       - port: 3306
       selector:
         app: mysql
     

  6. Wenden Sie den YAML-Code an.

     kubectl apply -f mysql-deployment.yaml
     

  7. Prüfen Sie, ob der Datenbankservice MySQL erfolgreich bereitgestellt wurde.

     kubectl get pod
     

  8. Beachten Sie, dass der Datenbankservice MySQL erfolgreich bereitgestellt wurde.

  9. Prüfen Sie, ob der Service des Typs "Load Balancer" erfolgreich bereitgestellt wurde.

     kubectl get svc
     

  10. Beachten Sie, dass der Service des Typs "Load Balancer" erfolgreich bereitgestellt wurde.

  

• Um das Load Balancer-Objekt in der OCI-Konsole zu prüfen, navigieren Sie zu Networking, Load Balancer, und klicken Sie auf den Load Balancer.

  

• Um auf die Terminalkonsole des MySQL-Datenbankservice zuzugreifen, können Sie den Befehl kubectl exec und den SSH-Tunnelbefehl localhost verwenden.

  1. Führen Sie den folgenden Befehl aus, um über den Operator auf die Terminalkonsole zuzugreifen.

     kubectl exec --stdin --tty mysql-74f8bf98c5-bl8vv -- /bin/bash
     

  2. Führen Sie den folgenden Befehl aus, um auf die Datenbankservicekonsole MySQL zuzugreifen.

     mysql -p
     

  3. Geben Sie das Kennwort ein, das Sie in der Datei mysql-secret.yaml angegeben haben, und notieren Sie sich die Willkommensmeldung des Datenbankservice MySQL.

  4. Führen Sie die folgende SQL-Abfrage aus, um eine Liste aller MySQL-Datenbanken im Datenbankservice anzuzeigen.

     SHOW DATABASES;
     

  

  Greifen Sie jetzt über die Kubernetes-Umgebung auf die Managementkonsole des Datenbankservice MySQL zu.

• Die folgende Abbildung veranschaulicht die bisherige Bereitstellung. Beachten Sie, dass der MySQL-Service mit dem Service vom Typ Load Balancer bereitgestellt wird.

  

Aufgabe 6: Zusätzliche Localhost-Einträge im SSH-Konfigurationsskript hinzufügen

Fügen Sie zusätzliche localhost-Einträge im SSH-Konfigurationsskript hinzu, um auf den neuen MySQL-Datenbankservice zuzugreifen.

• Damit der SSH-Tunnel für den MySQL-Datenbankservice funktioniert, müssen Sie den folgenden Eintrag in der SSH-Konfigurationsdatei im Ordner /Users/iwhooge/.ssh hinzufügen.

• Führen Sie den Befehl nano /Users/iwhooge/.ssh/config aus, um die Konfigurationsdatei zu bearbeiten.

• Fügen Sie die folgende Zeile im Abschnitt Host operator47 hinzu.

  LocalForward 8306 127.0.0.1:8306
  

• Ausgabe der SSH-Konfigurationsdatei.

  Host bastion47
      HostName 129.xxx.xxx.xxx
      user opc
      IdentityFile ~/.ssh/id_rsa
      UserKnownHostsFile /dev/null
      StrictHostKeyChecking=no
      TCPKeepAlive=yes
      ServerAliveInterval=50
  Host operator47
      HostName 10.0.0.11
      user opc
      IdentityFile ~/.ssh/id_rsa
      ProxyJump bastion47
      UserKnownHostsFile /dev/null
      StrictHostKeyChecking=no
      TCPKeepAlive=yes
      ServerAliveInterval=50
      LocalForward 8080 127.0.0.1:8080
      LocalForward 8306 127.0.0.1:8306
  

• Beachten Sie, dass der Befehl LocalForward zur SSH-Konfigurationsdatei hinzugefügt wird.

  

Aufgabe 7: SSH-Tunnel einrichten und mit Localhost eine Verbindung zur MySQL Database herstellen

• Um die Verbindung zum Datenbankservice MySQL vom lokalen Computer aus zu testen, müssen Sie MySQL Workbench herunterladen und auf dem lokalen Computer installieren.

  1. Öffnen Sie mit dem Skript erneut ein neues Terminal für den Operator. Lassen Sie das andere Terminal geöffnet.

     iwhooge@iwhooge-mac ~ % ssh operator47
     

  2. Führen Sie den folgenden Befehl im SSH-Fenster des Operators aus, um den SSH-Tunnel einzurichten und den gesamten Traffic, der an localhost 8306 geleitet wird, an den Service des Typs Load Balancer 3306 weiterzuleiten. Der Service des Typs "Load Balancer" leitet den Traffic dann schließlich an den Datenbankservice MySQL weiter.

     [opc@o-sqrtga ~]$ k port-forward svc/my-mysql-svc 8306:3306
     

  3. Beachten Sie die Weiterleitungsmeldungen im SSH-Fenster, dass der localhost-Port 8306 an Port 3306 weitergeleitet wird.

     Forwarding from 127.0.0.1:8306 -> 3306
     Forwarding from [::1]:8306 -> 3306
     

  

• Die MySQL Workbench-Anwendung wird installiert, die SSH-Session und der Tunnel werden eingerichtet. Öffnen Sie die MySQL Workbench-Anwendung auf Ihrem lokalen Computer.

• Klicken Sie auf +, um eine neue MySQL-Verbindung hinzuzufügen.

  

• Geben Sie unter Neue Verbindung einrichten die folgenden Informationen ein.

  1. Verbindungsname: Geben Sie einen Namen ein.
  2. Hostname: Geben Sie die IP-Adresse ein, die 127.0.0.1 lauten soll (localhost, da wir den Traffic optimieren).
  3. Port: Geben Sie den Port als 8306 ein, den Port, den wir für die lokale Tunnelweiterleitung für den MySQL-Datenbankservice verwenden.
  4. Klicken Sie auf Verbindung testen.

  

  1. Kennwort: Geben Sie das Kennwort ein, das Sie in der Datei mysql-secret.yaml angegeben haben.
  2. Klicken Sie auf OK.

  

• Klicken Sie auf Trotzdem fortfahren, um die Verbindungswarnung zu ignorieren. Diese Warnung wird ausgegeben, da die MySQL Workbench-Anwendungsversion und die bereitgestellte MySQL-Datenbankserviceversion möglicherweise nicht kompatibel sind.

  

  1. Beachten Sie die Meldung zur erfolgreichen Verbindung.
  2. Klicken Sie auf OK.
  3. Klicken Sie auf OK, um die MySQL-Verbindung zu speichern.

  

• Klicken Sie auf die gespeicherte MySQL-Verbindung, um die Session zu öffnen.

  

• Beachten Sie die Meldung Please stand by....

  

• Klicken Sie auf Trotzdem fortfahren, um die Verbindungswarnung zu ignorieren.

  

  1. Führen Sie die folgende SQL-Abfrage aus, um eine Liste aller MySQL-Datenbanken innerhalb des Datenbankservice festzulegen.

     SHOW DATABASES;
     

  2. Klicken Sie auf das Blitzsymbol.

  3. Beachten Sie die Ausgabe aller MySQL-Datenbanken im Datenbankservice MySQL.

  

• Beachten Sie im SSH-Fenster des Operators, dass sich die Ausgabe geändert hat und eine neue Zeile mit dem Befehl Handling connection for 8306 hinzugefügt wurde.

• Es gibt mehrere Einträge, da wir mehrere Verbindungen hergestellt haben, jeweils eine für die:

  • Testen.
  • Tatsächliche Verbindung.
  • SQL-Abfrage.
  • Test haben wir früher gemacht (zusätzlich).

  

• Jetzt können Sie mehrere SSH-Sessions zum Operator öffnen und mehrere Tunnelbefehle für verschiedene Anwendungen gleichzeitig ausführen. Beachten Sie die folgenden Fenster.

  1. Das SSH-Terminal mit dem Tunnelbefehl für den Datenbankservice MySQL.
  2. Die Verbindung mit der MYSQL Workbench-Anwendung vom lokalen Rechner zum Datenbankservice MySQL mit der localhost-IP-Adresse 127.0.0.1.
  3. Das SSH-Terminal mit dem Tunnelbefehl für die NGINX-Anwendung.
  4. Die Verbindung mit dem Safari-Internetbrowser vom lokalen Computer zur NGINX-Anwendung mit der localhost-IP-Adresse 127.0.0.1.

  

• Die folgende Abbildung veranschaulicht die bisherige Bereitstellung. Beachten Sie, dass die Tunnelverbindung zur lokalen IP-Adresse für die NGINX-Anwendung und den Datenbankservice MySQL gleichzeitig mit mehreren SSH-Sessions und SSH-Tunneln funktioniert.

  

Aufgabe 8: Alle Anwendungen und Services bereinigen

• Führen Sie die folgenden Befehle aus, um die bereitgestellte NGINX-Anwendung und den zugehörigen Service zu bereinigen.

  kubectl get pods
  kubectl delete service my-nginx-svc -n default
  kubectl get pods
  kubectl get svc
  kubectl delete deployment my-nginx --namespace default
  kubectl get svc
  

• Führen Sie die folgenden Befehle aus, um den bereitgestellten MySQL-Datenbankservice sowie den zugehörigen Service, Speicher und das zugehörige Kennwort zu bereinigen.

  kubectl delete deployment,svc mysql
  kubectl delete pvc mysql-pv-claim
  kubectl delete pv mysql-pv-volume
  kubectl delete secret mysql-secret
  

• Die folgende Abbildung veranschaulicht die Bereitstellung, die wir bisher durchgeführt haben, wo Sie wieder eine saubere Umgebung haben und von vorne beginnen können.

  

Nächste Schritte

Die Sicherung des Zugriffs auf OKE-Cluster ist ein wichtiger Schritt in der modernen Anwendungsentwicklung, und SSH-Tunneling bietet eine robuste und einfache Lösung. Durch die Implementierung der Schritte in diesem Tutorial können Entwickler ihre Ressourcen schützen, ihre Workflows optimieren und die Kontrolle über sensible Verbindungen für mehrere Anwendungen behalten. Die Integration von SSH-Tunneling in Ihr OKE-Setup erhöht nicht nur die Sicherheit, sondern minimiert auch die Risiken, die mit der Offenlegung von Ressourcen für das öffentliche Internet verbunden sind. Mit diesen Übungen können Sie Ihre OKE-Cluster sicher nutzen und sich auf die Erstellung skalierbarer, sicherer und effizienter Anwendungen konzentrieren.

Danksagungen

• Autor - Iwan Hoogendoorn (OCI Network Specialist)

Weitere Lernressourcen

Sehen Sie sich andere Übungen zu docs.oracle.com/learn an, oder greifen Sie im Oracle Learning YouTube-Channel auf weitere kostenlose Lerninhalte zu. Besuchen Sie außerdem education.oracle.com/learning-explorer, um Oracle Learning Explorer zu werden.

Die Produktdokumentation finden Sie im Oracle Help Center.

---

Titel und Copyright-Informationen

Leverage SSH Tunneling with Oracle Cloud Infrastructure Kubernetes Engine for Secure Application Development

G21947-02

December 2024

Copyright ©2024,

Oracle und/oder verbundene Unternehmen.