Mit Istio als eigenständigem Programm arbeiten

OKE-Cluster erstellen

Erstellen Sie ein OKE-Cluster.

1. Wenn dies noch nicht geschehen ist, erstellen Sie ein OKE-Cluster in Ihrem OCI-Mandanten. Mehrere Optionen sind verfügbar, um ein OKE-Cluster zu erstellen. Die einfachste Option ist der Assistent Schnellerstellung in der Webkonsole.
2. Um auf das OKE-Cluster auf dem lokalen Rechner zuzugreifen, installieren Sie kubectl und oci-cli.
3. Greifen Sie über die Befehlszeile mit kubectl auf das OKE-Cluster zu, indem Sie die Datei kubeconfig einrichten und sicherstellen, dass kubectl auf das Cluster zugreifen kann.

Istio von der Befehlszeile herunterladen

Führen Sie diese Schritte aus, um Istio von der Befehlszeile herunterzuladen.

1. Laden Sie Istio herunter, indem Sie den folgenden Befehl ausführen:

   curl -L https://istio.io/downloadIstio | sh -

2. Wechseln Sie in das Istio-Paketverzeichnis. Beispiel: Das Paket istio-1.11.2:

   cd istio-1.11.2

3. Fügen Sie das Clienttool istioctl zur PATH für Ihre Workstation hinzu.

   export PATH=$PWD/bin:$PATH

4. Prüfen Sie, ob das Cluster die Istio-Installationsanforderungen erfüllt, indem Sie die Vorabprüfung ausführen:

   istioctl x precheck

Istio mit istioctl installieren

istioctl install

Bookinfo-Anwendung ausführen

Das Istio-Projekt stellt die Bookinfo-Anwendung bereit, um Istio-Funktionen zu demonstrieren. Die Anwendung zeigt Informationen zu einem Buch an, ähnlich einem einzelnen Katalogeintrag eines Online-Buchladens. Jede Buchseite enthält eine Beschreibung des Buches, Details zum Buch (ISBN, Anzahl der Seiten) und ein paar Buchbewertungen. Weitere Informationen zur Bookinfo-Anwendung finden Sie hier in der Bookinfo-Dokumentation.

Wie Sie aus dem Diagramm sehen können, besteht die Bookinfo-Anwendung aus vier Microservices.

• Produktseitenservice: Ruft die Services Details und Prüfungen auf, um eine Produktseite zu erstellen.
• Detailservice: Gibt Buchinformationen zurück.
• Service prüfen: Gibt Buchprüfungen zurück und ruft den Service Bewertungen auf.
• Bewertungsservice: Gibt Einstufungsdaten für eine Buchprüfung zurück.

Führen Sie die folgenden Schritte aus, um die Bookinfo-Anwendung zu installieren und auszuführen.

1. Beschriften Sie den Namespace, der die Anwendung hostet, mit istio-injection=enabled.

   kubectl label namespace default istio-injection=enabled

2. Stellen Sie die Bookinfo-Beispielanwendung bereit.

   kubectl apply -f samples/bookinfo/platform/kube/bookinfo.yaml

3. Stellen Sie sicher, dass alle Services und Pods ausgeführt werden.

   kubectl get services
   kubectl get pods

4. Vergewissern Sie sich, dass die Anwendung ausgeführt wird, indem Sie einen curl-Befehl von einem Pod senden.

   kubectl exec "$(kubectl get pod -l app=ratings -o jsonpath='{.items[0].metadata.name}')" -c ratings -- curl -sS productpage:9080/productpage | grep -o "<title>.*</title>"

5. Machen Sie die Anwendung von außerhalb des Clusters zugänglich.

   kubectl apply -f samples/bookinfo/networking/bookinfo-gateway.yaml

6. Prüfen Sie, ob die Anwendung das Gateway verwendet. Bestimmen Sie INGRESS_HOST und INGRESS_PORT mit dieser Anleitung.

   curl -s "http://${INGRESS_HOST}:${INGRESS_PORT}/productpage" | grep -o "<title>.*</title>"

Öffnen Sie außerdem die URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage in einem Browser, um die Bookinfo-Webseite anzuzeigen. Aktualisieren Sie die Seite mehrmals, um verschiedene Versionen von Bewertungen auf der Produktseite anzuzeigen.

Istio-Integrationsanwendungen hinzufügen

Istio lässt sich gut in mehrere beliebte Kubernetes-Anwendungen integrieren.

Prometheus

Istio bietet eine grundlegende Beispielinstallation, um Prometheus schnell zum Laufen zu bringen.

kubectl apply -f samples/addons/prometheus.yaml

Alternativ können Sie prometheus installieren und konfigurieren, um Istio-Metriken zu scrappen.

Informationen zur Überwachung im Produktionsmaßstab mit Prometheus finden Sie unter Prometheus für die Überwachung im Produktionsmaßstab verwenden.

Grafana-Sprache

Istio bietet eine grundlegende Beispielinstallation, um Grafana schnell einsatzbereit zu machen. Alle Istio-Dashboards sind in der Installation enthalten.

kubectl apply -f samples/addons/grafana.yaml

Alternativ können Sie Grafana separat installieren. Darüber hinaus können die vorkonfigurierten Dashboards von Istio importiert werden.

Jaeger

Istio bietet eine grundlegende Beispielinstallation, um Jaeger schnell zum Laufen zu bringen.

kubectl apply -f samples/addons/jaeger.yaml

Alternativ können Sie Jaeger separat installieren und Istio konfigurieren, um Traces an das Jaeger-Deployment zu senden.

Zipkin

Istio bietet eine grundlegende Beispielinstallation, um Zipkin schnell zum Laufen zu bringen.

kubectl apply -f samples/addons/extras/zipkin.yaml

Alternativ können Sie Zipkin separat installieren und Istio konfigurieren, um Traces an das Zipkin-Deployment zu senden.

Kiali

Istio bietet eine grundlegende Beispielinstallation, um Kiali schnell zum Laufen zu bringen:

kubectl apply -f samples/addons/kiali.yaml
            

Alternativ können Sie Kiali separat installieren und konfigurieren.

Metriken aus Prometheus für Bookinfo-Anwendung abfragen

Mit Prometheus und Istio werden die Bookinfo-Leistungsdaten auf verschiedene Weise analysiert.

Stellen Sie zunächst sicher, dass Prometheus installiert ist.

kubectl -n istio-system get svc prometheus

Starten Sie die Prometheus-Benutzeroberfläche mit dem folgenden Befehl:

istioctl dashboard prometheus

Wählen Sie im Header rechts von Prometheus die Option Graph aus. Um einige Daten anzuzeigen, generieren Sie Traffic für die Produktseite mit einem Browser oder curl. Der Traffic spiegelt sich im Prometheus Dashboard wider.

• Zum Anzeigen der Ergebnisse befolgen Sie die Anweisungen hier.
• Weitere Informationen zum Abfragen von Prometheus finden Sie in der Istio-Abfragedokumentation.

Metriken für die Bookinfo-Anwendung mit Grafana visualisieren

Die Kombination von Prometheus mit Grafana bietet einige schöne Performance-Dashboards für Anwendungen. Um die Dashboards zu verwenden, müssen Sie zunächst prüfen, ob Prometheus und Grafana installiert sind.

kubectl -n istio-system get svc prometheus
kubectl -n istio-system get svc grafana

Starten Sie das Istio Grafana-Dashboard.

istioctl dashboard grafana

Grafana-Dashboards verwalten

Das Istio-Service-Mesh bietet sechs Grafana-Dashboards. Hier werden die Istio Service Mesh Grafana Dashboard Snapshots erfasst.

Istio Mesh-Dashboard

Istio-Service-Dashboard

Istio-Arbeitsauslastungs-Dashboard

Istio Performance-Dashboard

Dashboard für Istio-Steuerungsbereich

Weitere Informationen zum Erstellen, Konfigurieren und Bearbeiten von Dashboards finden Sie in der Grafana-Dokumentation.

Verteiltes Tracing mit Jaeger ausführen

Verwenden Sie das Jaeger Open Source Framework, um Anwendungs-Tracing mit Istio durchzuführen.

1. Aktivieren und konfigurieren Sie das Tracing mit istioctl:

   istioctl install --set meshConfig.enableTracing=true

2. Wenn die Bookinfo-Anwendung bereitgestellt ist, öffnen Sie die Jaeger-UI mit istioctl.

   istioctl dashboard jaeger

3. Um Traces zu generieren, senden Sie Anforderungen an die Produktseite.

   for i in $(seq 1 100); do curl -s -o /dev/null "http://$INGRESS_HOST:$INGRESS_PORT/productpage"; done

Sie sehen, dass sich die Spuren im Jaeger-Dashboard widerspiegeln.

Jaeger-Dashboard

Jaeger Application Trace

Verteiltes Tracing mit zipkin ausführen

Verwenden Sie das Zipkin Open Source Framework, um das Anwendungs-Tracing mit Istio durchzuführen.

1. Aktivieren und konfigurieren Sie das Tracing mit istioctl.

   istioctl install --set meshConfig.enableTracing=true

2. Wenn die Bookinfo-Anwendung bereitgestellt ist, öffnen Sie die zipkin-Benutzeroberfläche mit istioctl.

   istioctl dashboard zipkin

3. Um Traces zu generieren, senden Sie Anforderungen an die Produktseite.

   for i in $(seq 1 100); do curl -s -o /dev/null "http://$INGRESS_HOST:$INGRESS_PORT/productpage"; done

Sie sehen, dass die Spuren im Zipkin-Dashboard reflektiert werden.

Beispiel-Zipkin-Dashboard

Verteiltes Tracing mit OCI Application Performance Monitoring ausführen

OCI Application Performance Monitoring (APM) lässt sich mit Open-Source-Tracing-Systemtools wie Jaeger und Zipkin integrieren. Mit APM können Sie Tracedaten in OCI hochladen. Für die Integration mit OCI APM erstellen Sie eine APM-Domain, indem Sie die hier genannten Anweisungen befolgen. Eine APM-Domain ist eine OCI-Ressource, die die von APM überwachten Systeme enthält.

Zeigen Sie nach dem Erstellen der Domain die Domaindetails an, und holen Sie den Datenuploadendpunkt, den Private Key und den Public Key, um die APM-Collector-URL zu erstellen. Die APM-Collector-URL ist erforderlich, wenn Open-Source-Tracer für die Kommunikation mit dem APM-Service konfiguriert werden. Das Collector-URL-Format erfordert eine URL, die mit dem Datenuploadendpunkt als Basis-URL erstellt wird, und generiert den Pfad basierend auf Auswahlmöglichkeiten, einschließlich Werten aus unserem privaten oder öffentlichen Schlüssel. Das Format ist hier dokumentiert. Schließen Sie die URL mit dem erstellten URL-Pfad an die Istio-Konfiguration an.

Istio konfigurieren, um Traces an APM zu senden

1. Aktivieren Sie das Tracing mit istioctl.

   istioctl install --set meshConfig.defaultConfig.tracing.zipkin.address=aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com:443

   Hinweis
   
   Die Endpunktadresse von aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com ist ein Beispiel und kein tatsächlicher Endpunkt.
2. Konfigurieren Sie Envoy so, dass die Zipkin-Traces an APM gesendet werden. Ersetzen Sie den Code in samples/custom-bootstrap/custom-bootstrap.yaml durch den folgenden Codeblock.

   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: istio-custom-bootstrap-config
     namespace: default
   data:
     custom_bootstrap.json: |
       {
           "tracing": {
               "http": {
                   "name": "envoy.tracers.zipkin",
                   "typed_config": {
                       "@type": "type.googleapis.com/envoy.config.trace.v3.ZipkinConfig",
                       "collector_cluster": "aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com", // [Replace this with data upload endpoint of your apm domain]
                       "collector_endpoint": "/20200101/observations/private-span?dataFormat=zipkin&dataFormatVersion=2&dataKey=2C6YOLQSUZ5Q7IGN", // [Replace with the private datakey of your apm domain. You can also use public datakey but change the observation type to public-span]
                       "collectorEndpointVersion": "HTTP_JSON",
                       "trace_id_128bit": true,
                       "shared_span_context": false
                   }
               }
           },
           "static_resources": {
               "clusters": [{
                   "name": "aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com", // [Replace this with data upload endpoint of your apm domain:443]
                   "type": "STRICT_DNS",
                   "lb_policy": "ROUND_ROBIN",
                   "load_assignment": {
                       "cluster_name": "aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com", // [Replace this with data upload endpoint of your apm domain]
                       "endpoints": [{
                           "lb_endpoints": [{
                               "endpoint": {
                                   "address": {
                                       "socket_address": {
                                           "address": "aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com", // [Replace this with data upload endpoint of your apm domain]
                                           "port_value": 443
                                       }
                                   }
                               }
                           }]
                       }]
                   },
                   "transport_socket": {
                       "name": "envoy.transport_sockets.tls",
                       "typed_config": {
                           "@type": "type.googleapis.com/envoy.extensions.transport_sockets.tls.v3.UpstreamTlsContext",
                           "sni": "aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com" // [Replace this with data upload endpoint of your apm domain]
                       }
                   }
               }]
           }
       }
   EOF

3. Wenden Sie die benutzerdefinierte Konfiguration an.

   kubectl apply -f samples/custom-bootstrap/custom-bootstrap.yaml

4. Damit alle unsere Services in Bookinfo diese benutzerdefinierte Bootstrap-Konfiguration verwenden können, fügen Sie eine Annotation sidecar.istio.io/bootstrapOverride mit dem Namen ConfigMap als Wert hinzu. Im folgenden Beispiel wird eine Anmerkung für die Produktseite unter samples/bookinfo/platform/kube/bookinfo.yaml hinzugefügt. Fügen Sie anderen Services eine ähnliche Anmerkung hinzu.

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: productpage-v1
     labels:
       app: productpage
       version: v1
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: productpage
         version: v1
     template:
       metadata:
         labels:
           app: productpage
           version: v1
         annotations:
           sidecar.istio.io/bootstrapOverride: "istio-custom-bootstrap-config" #[Name of custom configmap]
       spec:
         serviceAccountName: bookinfo-productpage
         containers:
           - name: productpage
             image: docker.io/istio/examples-bookinfo-productpage-v1:1.16.2
             imagePullPolicy: IfNotPresent
             ports:
               - containerPort: 9080
             volumeMounts:
               - name: tmp
                 mountPath: /tmp
             securityContext:
               runAsUser: 1000
         volumes:
           - name: tmp
             emptyDir: {}
   ---

5. Wenden Sie das YAML an. Alle neu gestarteten Pods senden Traces an APM.

   kubectl apply -f samples/bookinfo/platform/kube/bookinfo.yaml

6. Um zu ermöglichen, dass ein Ingress-Gateway Traces sendet, erstellen Sie eine configmap mit dem Namen custom-bootstrap.yaml im Istio-System-Namespace:

   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: istio-custom-bootstrap-config
     namespace: istio-system
   data:
     custom_bootstrap.json: |
       {
           "tracing": {
               "http": {
                   "name": "envoy.tracers.zipkin",
                   "typed_config": {
                       "@type": "type.googleapis.com/envoy.config.trace.v3.ZipkinConfig",
                       "collector_cluster": "aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com", // [Replace this with data upload endpoint of your apm domain]
                       "collector_endpoint": "/20200101/observations/private-span?dataFormat=zipkin&dataFormatVersion=2&dataKey=2C6YOLQSUZ5Q7IGN", // [Replace with the private datakey of your apm domain. You can also use public datakey but change the observation type to public-span]
                       "collectorEndpointVersion": "HTTP_JSON",
                       "trace_id_128bit": true,
                       "shared_span_context": false
                   }
               }
           },
           "static_resources": {
               "clusters": [{
                   "name": "aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com", // [Replace this with data upload endpoint of your apm domain:443]
                   "type": "STRICT_DNS",
                   "lb_policy": "ROUND_ROBIN",
                   "load_assignment": {
                       "cluster_name": "aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com", // [Replace this with data upload endpoint of your apm domain]
                       "endpoints": [{
                           "lb_endpoints": [{
                               "endpoint": {
                                   "address": {
                                       "socket_address": {
                                           "address": "aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com", // [Replace this with data upload endpoint of your apm domain]
                                           "port_value": 443
                                       }
                                   }
                               }
                           }]
                       }]
                   },
                   "transport_socket": {
                       "name": "envoy.transport_sockets.tls",
                       "typed_config": {
                           "@type": "type.googleapis.com/envoy.extensions.transport_sockets.tls.v3.UpstreamTlsContext",
                           "sni": "aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com" // [Replace this with data upload endpoint of your apm domain]
                       }
                   }
               }]
           }
       }
   EOF

7. Erstellen Sie einen Patch mit dem Namen gateway-patch.yaml für das Ingress-Gateway, um die benutzerdefinierte Bootstrap-Konfiguration zu verwenden:

   spec:
     template:
       spec:
         containers:
         - name: istio-proxy
           env:
           - name: ISTIO_BOOTSTRAP_OVERRIDE
             value: /etc/istio/custom-bootstrap/custom_bootstrap.json
           volumeMounts:
           - mountPath: /etc/istio/custom-bootstrap
             name: custom-bootstrap-volume
             readOnly: true
         volumes:
         - configMap:
             name: istio-custom-bootstrap-config
             defaultMode: 420
             optional: false
           name: custom-bootstrap-volume

8. Spielen Sie den vorherigen Patch für das Ingress-Gateway ein:

   kubectl --namespace istio-system patch deployment istio-ingressgateway --patch "$(cat gateway-patch.yaml)"

9. Um Traces zu generieren, senden Sie Anforderungen an die Produktseite.

   for i in $(seq 1 100); do curl -s -o /dev/null "http://$INGRESS_HOST:$INGRESS_PORT/productpage"; done

Die Traces werden im APM-Dashboard angezeigt, indem Sie die Schritte hier ausführen.

Zipkin-Trace-Explorer

Zipkin Trace

Zipkin Spans

Um die Spans anzuzeigen, wählen Sie in der APM-Liste "Home" aus.

Zipkin-App-Dashboard

APM bietet Funktionen zum Erstellen von Dashboards und zum Erkunden der im Laufe der Zeit generierten Spans. Dashboards können wie folgt erstellt werden: Hier.

Zipkin-Metrik-Explorer

Mit APM können Sie den Zustand, die Kapazität und die Performance Ihrer Anwendungen mit Metriken, Alarmen und Benachrichtigungen überwachen. Führen Sie die Schritte hier aus, um Metriken zu konfigurieren.

Logs mit OCI Logging beobachten

OCI Logging ist eine zentrale Komponente zum Analysieren und Durchsuchen von Logdateieinträgen für Mandanten in OCI. Kubernetes-Containerlogs von OKE-Worker-Knoten können als benutzerdefinierte Logs in OCI Logging veröffentlicht werden. Befolgen Sie die hier beschriebenen Schritte, um OCI Logging für die Aufnahme von Containerlogs zu konfigurieren.

1. Aktivieren Sie die Anmeldung des Gesandten bei Istio mit istioctl.

   istioctl install --set meshConfig.accessLogFile=/dev/stdout

2. Rufen Sie die Bookinfo-Produktseite mit einem Browser oder einer Locke auf. Die generierten Zugriffslogs können mit dem Befehl kubectl angezeigt werden.

   kubectl logs -l app=productpage -c istio-proxy

Wenn OCI Logging für das Cluster konfiguriert ist, können diese Logs mit der Logsuchseite der OCI-Konsole abgefragt und analysiert werden.

OCI Logging-Suche

OCI Logging-Suche erweitert

Mesh mit Kiali visualisieren

Überprüfen Sie, ob Kiali installiert ist.

kubectl -n istio-system get svc kiali

Öffnen Sie die Kiali-Benutzeroberfläche im Browser.

istioctl dashboard kiali

Senden Sie etwas Traffic an die Produktseite.

for i in $(seq 1 100); do curl -s -o /dev/null "http://$INGRESS_HOST:$INGRESS_PORT/productpage"; done

Visualisieren Sie Ihr Mesh in Kiali, indem Sie Schritt 5 von hier aus befolgen.

Traffic verschieben

Istio ermöglicht es uns, den Datenverkehr schrittweise von einer Version eines Microservice zu einer anderen Version zu migrieren, indem wir die gewichtete Routing-Funktion von Istio verwenden. Im folgenden Beispiel wird gezeigt, wie Sie konfigurieren, dass 50% des Traffics an reviews:v1 und 50% an reviews:v3 gesendet werden. Danach schließen Sie die Migration ab, indem Sie 100% des Traffics an reviews:v3 senden.

1. Leiten Sie den gesamten Traffic an die v1-Version jedes Microservice weiter.

   kubectl apply -f samples/bookinfo/networking/virtual-service-all-v1.yaml

   Um die Bookinfo-Webseite anzuzeigen, öffnen Sie die URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage in einem Browser. Beachten Sie, dass der Teil der Bewertungen der Seite ohne Bewertungssterne angezeigt wird, unabhängig davon, wie oft Sie aktualisieren. Istio ist so konfiguriert, dass der gesamte Traffic für den Überprüfungsservice an reviews:v1 weitergeleitet wird, und diese Version des Service greift nicht auf den Star-Bewertungsservice zu.

2. Übertragen Sie 50% des Traffics mit dem folgenden Befehl von reviews:v1 nach reviews:v3, und warten Sie, bis die neuen Regeln propagiert werden.

   kubectl apply -f samples/bookinfo/networking/virtual-service-reviews-50-v3.yaml

   Aktualisieren Sie die /productpage-URL in Ihrem Browser, und sehen Sie die rot gefärbten Sterne, die etwa 50% der Zeit betragen. Die reviews:v3 greift auf den Star-Bewertungsservice zu, die Version reviews:v1 jedoch nicht.

3. Leiten Sie jetzt 100% des Traffics an reviews:v3 weiter.

   kubectl apply -f samples/bookinfo/networking/virtual-service-reviews-v3.yaml

4. Aktualisieren Sie die /productpage-URL in Ihrem Browser, und sehen Sie für jede Bewertung ständig rote Sterne.

Anforderungsrouting verwalten

kubectl apply -f samples/bookinfo/networking/virtual-service-all-v1.yaml

Um die Bookinfo-Webseite anzuzeigen, öffnen Sie die URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage in einem Browser. Beachten Sie, dass der Teil der Bewertungen der Seite ohne Bewertungssterne angezeigt wird, unabhängig davon, wie oft Sie aktualisieren. Istio ist so konfiguriert, dass der gesamte Traffic für den Prüfservice an die Version reviews:v1 weitergeleitet wird. Diese Version des Service greift nicht auf den Star-Bewertungsservice zu.

Routing basierend auf Benutzeridentität

So leiten Sie basierend auf der Benutzeridentität weiter:

1. Ändern Sie die Routenkonfiguration, sodass der gesamte Traffic von einem bestimmten Benutzer namens jason an reviews:v2 weitergeleitet wird. Istio hat kein spezielles, integriertes Verständnis der Benutzeridentität. In diesem Beispiel fügt der productpage-Service allen ausgehenden HTTP-Anforderungen einen benutzerdefinierten Endbenutzerheader zum Prüfservice hinzu.

   kubectl apply -f samples/bookinfo/networking/virtual-service-reviews-test-v2.yaml

2. Um die Bookinfo-Webseite anzuzeigen und sich als Benutzer jason anzumelden, öffnen Sie die URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage in einem Browser. Aktualisieren Sie den Browser, um zu sehen, dass neben jeder Bewertung die Sternebewertung angezeigt wird.

   

3. Öffnen Sie die URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage in einem Browser, um die Bookinfo-Webseite anzuzeigen, und melden Sie sich als anderer Benutzer als jason an. Aktualisieren Sie den Browser, um für jede Bewertung keine Sterne anzuzeigen.

   

Weiterleitung basierend auf URL-Neuschreiben

In diesem Beispiel werden HTTP-Anforderungen mit einem Pfad, der mit /products oder /bookinfoproductpage beginnt, in /productpage umgeschrieben. HTTP-Anforderungen werden an Pods gesendet, wobei productpage auf Port 9080 ausgeführt wird. Weitere Informationen zum Neuschreiben der Istio-URL finden Sie hier.

1. Wenden Sie das folgende YAML an:

   kubectl apply -f - <<EOF
   apiVersion: networking.istio.io/v1beta1
   kind: VirtualService
   metadata:
     name: bookinfo
   spec:
     hosts:
     - "*"
     gateways:
     - bookinfo-gateway
     http:
     - match:
       - uri:
           prefix: /products
       - uri:
           prefix: /bookinfoproductpage
       rewrite:
         uri: /productpage
       route:
       - destination:
           host: productpage
           port:
             number: 9080
   EOF

2. Um die Bookinfo-Webseite anzuzeigen, öffnen Sie die URL http://${INGRESS_HOST}:${INGRESS_PORT}/products und http://${INGRESS_HOST}:${INGRESS_PORT}/bookinfoproductpage in einem Browser. In beiden Fällen wird ein Umschreiben durchgeführt, bevor die Anforderung weitergeleitet wird.

   Rewrite/bookproductpage

   

   Rewrite/Produkte

   
3. Bereinigen Sie die yaml-Datei auf die ursprüngliche Version von Istio und wenden Sie sie an.

   kubectl apply -f samples/bookinfo/networking/bookinfo-gateway.yaml

4. Öffnen Sie die URL http://${INGRESS_HOST}:${INGRESS_PORT}/bookinfoproductpage oder http://${INGRESS_HOST}:${INGRESS_PORT}/products, um die Produktseite nicht anzuzeigen, da die YAML die Anforderung nicht umschreibt.

   Fehler 404/Produkte

   

   Fehler 404 /bookProduktseite

   

Netzwerkresilienz testen

Istio ermöglicht es Ihnen, Ihre Installation für Anforderungstimeouts, Fehlerinjektion und Leistungsschalter zu konfigurieren. Diese Einstellungen ermöglichen das Verwalten und Testen der Fehlertoleranz bereitgestellter Anwendungen.

Anforderungs-Timeouts festlegen

Ein Timeout ist die Zeit, die ein Envoy-Proxy auf Antworten von einem bestimmten Service wartet. Der Timeout stellt sicher, dass Services nicht unbegrenzt auf Antworten warten und sicherstellen, dass Anrufe innerhalb eines vorhersehbaren Zeitrahmens erfolgreich oder nicht erfolgreich verlaufen. Weitere Informationen zu Timeouts finden Sie hier.

Ein Timeout für HTTP-Anforderungen kann mit dem Timeoutfeld der Routingregel angegeben werden. Standardmäßig ist der Anforderungstimeout deaktiviert.

1. Initialisieren Sie das Routing der Anwendungsversion, indem Sie den folgenden Befehl ausführen:

   kubectl apply -f samples/bookinfo/networking/virtual-service-all-v1.yaml

2. Leiten Sie Anforderungen an den reviews:v2-Service weiter, eine Version, die den Bewertungsservice aufruft:

   kubectl apply -f - <<EOF
   apiVersion: networking.istio.io/v1beta1
   kind: VirtualService
   metadata:
     name: reviews
   spec:
     hosts:
       - reviews
     http:
     - route:
       - destination:
           host: reviews
           subset: v2
   EOF

3. Fügen Sie dem Bewertungsdienst eine Verzögerung von 2 Sekunden hinzu:

   kubectl apply -f - <<EOF
   apiVersion: networking.istio.io/v1beta1
   kind: VirtualService
   metadata:
     name: ratings
   spec:
     hosts:
     - ratings
     http:
     - fault:
         delay:
           percent: 100
           fixedDelay: 2s
       route:
       - destination:
           host: ratings
           subset: v1
   EOF

4. Um die Bookinfo-Webseite mit angezeigten Bewertungssternen anzuzeigen, öffnen Sie die URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage in einem Browser. Bei jeder Aktualisierung der Seite tritt eine Verzögerung von 2 Sekunden auf.
   
5. Fügen Sie einen Timeout für Anfragen für Anrufe beim Überprüfungsservice hinzu:

   kubectl apply -f - <<EOF
   apiVersion: networking.istio.io/v1beta1
   kind: VirtualService
   metadata:
     name: reviews
   spec:
     hosts:
     - reviews
     http:
     - route:
       - destination:
           host: reviews
           subset: v2
       timeout: 0.5s
   EOF

6. Um die Bookinfo-Webseite anzuzeigen, öffnen Sie die URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage in einem Browser. Beachten Sie, dass die Seite in etwa 1 Sekunde statt 2 zurückgegeben wird und die Bewertungen nicht verfügbar sind.
   

Der Grund dafür, dass die Antwort 1 Sekunde dauert, obwohl der Timeout mit einer halben Sekunde konfiguriert ist, liegt darin, dass ein hartcodierter Wiederholungsversuch im productpage-Service erfolgt. Der Service ruft den Timeoutprüfungsdienst zweimal auf, bevor er zurückkehrt.

Neben dem Überschreiben in Routingregeln kann der Timeout auch pro Anforderung überschrieben werden, wenn die Anwendung ausgehenden Anforderungen einen x-envoy-upstream-rq-timeout-ms-Header hinzufügt.

Fault-Injection verwalten

Fault Injection ist eine Testmethode, die Fehler in ein System einführt, um sicherzustellen, dass das System den Fehlerbedingungen standhält und sich von diesen erholt. Istio ermöglicht Fault-Injection auf der Anwendungsebene, wie HTTP-Fehlercodes. Istio injiziert zwei Arten von Faults, die beide mit einem virtuellen Service konfiguriert sind. Weitere Informationen zur Fault Injection finden Sie hier.

• Verzögerungen: Verzögerungen sind Timingfehler, die eine erhöhte Netzwerklatenz oder einen überlasteten Upstream-Service nachahmen.
• Abbrüche: Abbrüche sind Absturzfehler, die Fehler in Upstream-Services nachahmen. Bricht Manifest in Form von HTTP-Fehlercodes oder TCP-Verbindungsfehlern ab.

Um die Fault-Injection zu testen, führen Sie den folgenden Befehl aus, um das Routing der Anwendungsversion zu initialisieren:

kubectl apply -f samples/bookinfo/networking/virtual-service-all-v1.yaml
kubectl apply -f samples/bookinfo/networking/virtual-service-reviews-test-v2.yaml

HTTP-Verzögerungsfehler injizieren

So injizieren Sie einen Verzögerungsfehler:

• Erstellen Sie eine Fault-Injection-Regel, um Traffic vom Benutzer jason zu verzögern. Mit dem folgenden Befehl wird eine Verzögerung von 7 Sekunden zwischen reviews:v2 eingefügt und Microservices für Benutzer jason bewertet.

  kubectl apply -f samples/bookinfo/networking/virtual-service-ratings-test-delay.yaml

  Hinweis
  
  Der reviews:v2-Service hat einen hartcodierten Verbindungstimeout von 10 Sekunden für Aufrufe des Bewertungsservice. Mit einer Verzögerung von 7 Sekunden erwarten Sie, dass der End-to-End-Fluss ohne Fehler fortgesetzt wird.
• Um die Bookinfo-Webseite anzuzeigen, öffnen Sie die URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage in einem Browser.
  

  Die Bookinfo-Homepage wird in etwa sieben Sekunden ohne Fehler geladen. Im Abschnitt "Bewertungen" wird jedoch eine Fehlermeldung angezeigt: Leider sind Produktbewertungen für dieses Buch derzeit nicht verfügbar. Im Anwendungscode ist ein Fehler vorhanden. Der hartcodierte Timeout zwischen dem productpage und dem reviews-Service führt zu einer Verzögerung von 6 Sekunden, 3 Sekunden plus 1 Wiederholung. Infolgedessen wird der productpage-Aufruf zu reviews vorzeitig wegen Timeouts abgebrochen und löst nach 6 Sekunden einen Fehler aus.

  Um den Bug zu beheben, erhöhen Sie den Timeout für den productpage-Service auf reviews, oder verringern Sie den Timeout für reviews auf ratings auf weniger als 3 Sekunden.

• Beheben Sie den Bug, indem Sie dem ratings-Service für Benutzer jason eine Verzögerung von 2 Sekunden hinzufügen.

  kubectl apply -f - <<EOF
  apiVersion: networking.istio.io/v1beta1
  kind: VirtualService
  metadata:
    name: ratings
  spec:
    hosts:
    - ratings
    http:
    - match:
      - headers:
          end-user:
            exact: jason
      fault:
        delay:
          percentage:
            value: 100.0
          fixedDelay: 2s
      route:
      - destination:
          host: ratings
          subset: v1
    - route:
      - destination:
          host: ratings
          subset: v1
  EOF

• Nachdem der Fehler behoben wurde, öffnen Sie die URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage in einem Browser, um die Bookinfo-Webseite anzuzeigen. Melden Sie sich als jason mit angezeigten Bewertungssternen an.
  

HTTP-Abbruchfehler injizieren

Führen Sie die folgenden Schritte aus, um einen Abbruchfehler zu injizieren:

1. Erstellen Sie eine Fault-Injection-Regel, um eine HTTP-Abbruchantwort für den Benutzer jason zu senden:

   kubectl apply -f samples/bookinfo/networking/virtual-service-ratings-test-abort.yaml

2. Um die Bookinfo-Webseite anzuzeigen, öffnen Sie die URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage in einem Browser. Melden Sie sich als Benutzer jason an. Eine Meldung gibt an, dass der ratings-Service nicht verfügbar ist.
   

   Melden Sie sich von Benutzer jason ab, oder melden Sie sich bei einem anderen Benutzer an, um keine Fehlermeldung zu sehen.

   

Erstellen von Circuit Breakers

Circuit Breaking ermöglicht es uns, Anwendungen zu schreiben, die den Einfluss von Ausfällen, Latenzspitzen und anderen unerwünschten Auswirkungen von Netzwerkbesonderheiten begrenzen. Weitere Informationen zu Leistungsschaltern finden Sie hier.

1. Erstellen Sie eine Zielregel, um Circuit Breaking-Einstellungen beim Aufrufen des Produktservice anzuwenden. Die folgende Regel legt die maximale Anzahl von Verbindungen auf maximal eine Verbindung fest und enthält maximal eine ausstehende HTTP-Anforderung. Darüber hinaus konfigurieren die Regeln, dass Hosts alle 1 Sekunde gescannt werden. Jeder Host, der einmal mit einem 5XX-Fehlercode ausfällt, wird 3 Minuten lang ausgeworfen. Außerdem werden 100% der Hosts im Load Balancing Pool für den Upstream-Service ausgegeben.

   kubectl apply -f - <<EOF
   apiVersion: networking.istio.io/v1beta1
   kind: DestinationRule
   metadata:
     name: productpage
   spec:
     host: productpage
     trafficPolicy:
       connectionPool:
         tcp:
           maxConnections: 1
         http:
           http1MaxPendingRequests: 1
           maxRequestsPerConnection: 1
       outlierDetection:
         consecutive5xxErrors: 1
         interval: 1s
         baseEjectionTime: 3m
         maxEjectionPercent: 100
     subsets:
     - name: v1
       labels:
         version: v1
   EOF

2. Leiten Sie den gesamten Traffic an die v1-Version jedes Microservice weiter.

   kubectl apply -f samples/bookinfo/networking/virtual-service-all-v1.yaml

3. Erstellen Sie einen Client, um Traffic an den Produktservice zu senden. Mit Fortio können Sie die Anzahl der Verbindungen, Nebenläufigkeit und Verzögerungen für ausgehende HTTP-Aufrufe steuern. Wenn Sie die automatische Sidecar-Injection aktiviert haben, stellen Sie den fortio-Service bereit:

   kubectl apply -f samples/httpbin/sample-client/fortio-deploy.yaml

   Alternativ können Sie den Sidecar manuell injizieren, bevor Sie die Anwendung fortio bereitstellen.

   kubectl apply -f <(istioctl kube-inject -f samples/httpbin/sample-client/fortio-deploy.yaml)

4. Melden Sie sich beim Clientpod an, und rufen Sie mit dem Tool fortio productpage auf, und prüfen Sie mit den folgenden Befehlen, ob der Antwortstatuscode 200 lautet.

   export FORTIO_POD=$(kubectl get pods -l app=fortio -o 'jsonpath={.items[0].metadata.name}')
   kubectl exec "$FORTIO_POD" -c fortio -- /usr/bin/fortio curl http://productpage:9080
   

   Die folgende Ausgabe wird erzeugt:

   HTTP/1.1 200 OK
   content-type: text/html; charset=utf-8
   content-length: 1683
   server: envoy
   date: Tue, 07 Sep 2021 11:01:02 GMT
   x-envoy-upstream-service-time: 5

5. Rufen Sie den Service mit 2 gleichzeitigen Verbindungen (-c 2) auf, und senden Sie 20 Anforderungen (-n 20). Interessanterweise 16 Anfragen Passthrough und 4 scheitern.

   kubectl exec "$FORTIO_POD" -c fortio -- /usr/bin/fortio load -c 2 -qps 0 -n 20 -loglevel Warning http://productpage:9080

   Der Befehl erzeugt eine Ausgabe ähnlich der folgenden.

   11:03:43 I logger.go:127> Log level is now 3 Warning (was 2 Info)
   Fortio 1.11.3 running at 0 queries per second, 128->128 procs, for 20 calls: http://productpage:9080
   Starting at max qps with 2 thread(s) [gomax 128] for exactly 20 calls (10 per thread + 0)
   11:03:43 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:03:43 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:03:43 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:03:43 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   Ended after 51.340006ms : 20 calls. qps=389.56
   Aggregated Function Time : count 20 avg 0.0045031997 +/- 0.002036 min 0.000387421 max 0.007704444 sum 0.090063995
   # range, mid point, percentile, count
   >= 0.000387421 <= 0.001 , 0.000693711 , 15.00, 3
   > 0.003 <= 0.004 , 0.0035 , 20.00, 1
   > 0.004 <= 0.005 , 0.0045 , 65.00, 9
   > 0.005 <= 0.006 , 0.0055 , 75.00, 2
   > 0.006 <= 0.007 , 0.0065 , 95.00, 4
   > 0.007 <= 0.00770444 , 0.00735222 , 100.00, 1
   # target 50% 0.00466667
   # target 75% 0.006
   # target 90% 0.00675
   # target 99% 0.00756356
   # target 99.9% 0.00769036
   Sockets used: 5 (for perfect keepalive, would be 2)
   Jitter: false
   Code 200 : 16 (80.0 %)
   Code 503 : 4 (20.0 %)
   Response Header Sizes : count 20 avg 133.6 +/- 66.8 min 0 max 167 sum 2672
   Response Body/Total Sizes : count 20 avg 1528.2 +/- 643.6 min 241 max 1850 sum 30564
   All done 20 calls (plus 0 warmup) 4.503 ms avg, 389.6 qps

6. Erhöhen Sie die Anzahl gleichzeitiger Verbindungen auf 3.

   kubectl exec "$FORTIO_POD" -c fortio -- /usr/bin/fortio load -c 3 -qps 0 -n 30 -loglevel Warning http://productpage:9080

   Nur 26,7% der Anforderungen waren erfolgreich, und der Rest wird vom Circuit Breaking abgefangen.

   11:10:19 I logger.go:127> Log level is now 3 Warning (was 2 Info)
   Fortio 1.11.3 running at 0 queries per second, 128->128 procs, for 30 calls: http://productpage:9080
   Starting at max qps with 3 thread(s) [gomax 128] for exactly 30 calls (10 per thread + 0)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   Ended after 28.105508ms : 30 calls. qps=1067.4
   Aggregated Function Time : count 30 avg 0.0024256753 +/- 0.003264 min 0.000261072 max 0.010510116 sum 0.07277026
   # range, mid point, percentile, count
   >= 0.000261072 <= 0.001 , 0.000630536 , 66.67, 20
   > 0.001 <= 0.002 , 0.0015 , 73.33, 2
   > 0.005 <= 0.006 , 0.0055 , 76.67, 1
   > 0.006 <= 0.007 , 0.0065 , 83.33, 2
   > 0.007 <= 0.008 , 0.0075 , 93.33, 3
   > 0.009 <= 0.01 , 0.0095 , 96.67, 1
   > 0.01 <= 0.0105101 , 0.0102551 , 100.00, 1
   # target 50% 0.000805545
   # target 75% 0.0055
   # target 90% 0.00766667
   # target 99% 0.0103571
   # target 99.9% 0.0104948
   Sockets used: 25 (for perfect keepalive, would be 3)
   Jitter: false
   Code 200 : 8 (26.7 %)
   Code 503 : 22 (73.3 %)
   Response Header Sizes : count 30 avg 44.533333 +/- 73.85 min 0 max 167 sum 1336
   Response Body/Total Sizes : count 30 avg 670.06667 +/- 711.5 min 241 max 1850 sum 20102
   All done 30 calls (plus 0 warmup) 2.426 ms avg, 1067.4 qps

7. Fragen Sie die istio-proxy-Statistiken ab, um weitere Informationen zu erhalten.

   kubectl exec "$FORTIO_POD" -c istio-proxy -- pilot-agent request GET stats | grep productpage | grep pending

   Circuit Breaking Flags 32 Aufrufe, indem die Metrik upstream_rq_pending_overflow betrachtet wird.

   cluster.outbound|9080|v1|productpage.default.svc.cluster.local.circuit_breakers.default.remaining_pending: 1
   cluster.outbound|9080|v1|productpage.default.svc.cluster.local.circuit_breakers.default.rq_pending_open: 0
   cluster.outbound|9080|v1|productpage.default.svc.cluster.local.circuit_breakers.high.rq_pending_open: 0
   cluster.outbound|9080|v1|productpage.default.svc.cluster.local.upstream_rq_pending_active: 0
   cluster.outbound|9080|v1|productpage.default.svc.cluster.local.upstream_rq_pending_failure_eject: 0
   cluster.outbound|9080|v1|productpage.default.svc.cluster.local.upstream_rq_pending_overflow: 32
   cluster.outbound|9080|v1|productpage.default.svc.cluster.local.upstream_rq_pending_total: 39

8. Bereinigen Sie den Client.

   kubectl apply -f samples/bookinfo/networking/destination-rule-all.yaml
   kubectl delete deploy fortio-deploy
   kubectl delete svc fortio

Mirroring

Verkehrsspiegelung, auch Schattenbildung genannt, ermöglicht es Teams, Änderungen in die Produktion mit so wenig Risiko wie möglich zu bringen. Beim Mirroring wird eine Kopie des Live-Datenverkehrs an einen gespiegelten Service gesendet. Der gespiegelte Datenverkehr tritt außerhalb des kritischen Anforderungspfads für den primären Service auf.

1. Leiten Sie den gesamten Traffic an die v1-Version jedes Microservice weiter.

   kubectl apply -f samples/bookinfo/networking/virtual-service-all-v1.yaml

2. Ändern Sie die Routingregel, um den Traffic in reviews:v2 zu spiegeln.

   kubectl apply -f - <<EOF
   apiVersion: networking.istio.io/v1beta1
   kind: VirtualService
   metadata:
     name: reviews
   spec:
     hosts:
       - reviews
     http:
     - route:
       - destination:
           host: reviews
           subset: v1
         weight: 100
       mirror:
         host: reviews
         subset: v2
       mirrorPercentage:
         value: 100.0
   EOF

   Die vorherige Routingregel sendet 100% des Traffics an reviews:v1 und spiegelt 100% des gleichen Traffics an den reviews:v2-Service wider.

   Wenn Traffic gespiegelt wird, werden die Anforderungen mit den Host-/Autoritätsheadern, die an -shadow angehängt sind, an den gespiegelten Service gesendet. Bewertungen werden beispielsweise zu reviews-shadow.Mirrored-Anforderungen, die als "Feuer und Vergessen" gelten. Die gespiegelten Antworten werden verworfen.

   Anstatt alle Anforderungen zu spiegeln, ändern Sie das Wertfeld unter dem Feld mirrorPercentage, um einen Bruchteil des Datenverkehrs zu spiegeln. Wenn dieses Feld nicht vorhanden ist, wird der gesamte Datenverkehr gespiegelt.

3. Senden Sie Datenverkehr, indem Sie die URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage in einem Browser aktualisieren.
4. Logs des reviews:v1-Service. Hinweis: Der Service v1 ruft den Bewertungsservice nicht auf.
   
5. Logs des gespiegelten Service reviews:v2. Hinweis für den v2-Service. Der Header wird mit -shadow angehängt.
   

Gateways verwalten

Gateway beschreibt einen Load Balancer, der an der Kante des Meshs arbeitet, das eingehende oder ausgehende HTTP/TCP-Verbindungen empfängt. Gatewaykonfigurationen werden auf eigenständige Envoy-Proxys angewendet, die am Rand des Meshs ausgeführt werden, und nicht auf Sidecar-Envoy-Proxys, die neben Ihren Service-Workloads ausgeführt werden. Istio stellt einige vorkonfigurierte Gatewayproxy-Deployments bereit: istio-ingressgateway und istio-egressgateway.

istioctl install

Der Befehl stellt Istio mit den Standardeinstellungen bereit, die ein Gateway enthalten. Weitere Informationen finden Sie hier.

Ingress mit Istio Gateway konfigurieren

Das Ingress-Gateway konfiguriert verfügbare Ports und Protokolle. Im Gegensatz zu Kubernetes-Ingress-Ressourcen enthält es jedoch keine Trafficroutingkonfiguration. Traffic-Routing für Ingress-Traffic wird stattdessen mit Istio-Routingregeln konfiguriert. Weitere Informationen zum Istio-Ingress finden Sie hier.

1. Erstellen Sie ein Istio-Gateway, das auf Port 80 für HTTP-Traffic konfiguriert wird.

   kubectl apply -f - <<EOF
   apiVersion: networking.istio.io/v1beta1
   kind: Gateway
   metadata:
     name: bookinfo-gateway
   spec:
     selector:
       istio: ingressgateway # use istio default controller
     servers:
       - port:
           number: 80
           name: http
           protocol: HTTP
         hosts:
           - "*"
   EOF

2. Konfigurieren Sie Routen für Traffic, der über das Gateway eingeht:

   kubectl apply -f - <<EOF
   apiVersion: networking.istio.io/v1beta1
   kind: VirtualService
   metadata:
     name: bookinfo
   spec:
     hosts:
     - "*"
     gateways:
     - bookinfo-gateway
     http:
     - match:
       - uri:
           exact: /productpage
       - uri:
           prefix: /static
       - uri:
           exact: /login
       - uri:
           exact: /logout
       - uri:
           prefix: /api/v1/products
       route:
       - destination:
           host: productpage
           port:
             number: 9080
   EOF

3. Informationen zum Bereitstellen der Bookinfo-Anwendung finden Sie im Abschnitt "Ausführen der Bookinfo-Anwendung" der Seite Installieren von Istio und OKE.
4. Greifen Sie mit curl auf den productpage-Service zu:

   curl -s -I http://$INGRESS_HOST:$INGRESS_PORT/productpage

   Der Befehl erzeugt die folgende Ausgabe:

   HTTP/1.1 200 OK
   content-type: text/html; charset=utf-8
   content-length: 4183
   server: istio-envoy
   date: Tue, 07 Sep 2021 13:48:39 GMT
   x-envoy-upstream-service-time: 36

5. Greifen Sie auf andere URLs zu, die nicht explizit angegeben wurden. Es wird ein HTTP 404-Fehler angezeigt.

   curl -s -I http://$INGRESS_HOST:$INGRESS_PORT/any

   Der Befehl erzeugt die folgende Ausgabe:

   HTTP/1.1 404 Not Found
   date: Tue, 07 Sep 2021 13:49:45 GMT
   server: istio-envoy
   transfer-encoding: chunked

6. Verwenden Sie für explizite Hosts in Gateways das Flag -H, um den HTTP-Header des Hosts festzulegen. Das Flag wird benötigt, weil das Ingress-Gateway und der virtuelle Service für die Verarbeitung des Hosts konfiguriert sind. Beispiel: Ihr Host ist example.com, und der Name wird sowohl in Gateways als auch in virtuellen Services angegeben.

   curl -s -I -HHost:example.com http://$INGRESS_HOST:$INGRESS_PORT/productpage

7. Öffnen Sie außerdem die URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage in einem Browser, um die Bookinfo-Webseite anzuzeigen.

Ingress mit Kubernetes-Ingress-Ressource konfigurieren

Der Reader geht davon aus, dass die Bookinfo-Anwendung im Cluster bereitgestellt wird. Informationen zum Bereitstellen der Bookinfo-Anwendung finden Sie im Abschnitt "Ausführen der Bookinfo-Anwendung" der Seite Installieren von Istio und OKE.

1. Entfernen Sie das Istio-Gateway, wenn die Konfiguration bereits angewendet wurde.

   kubectl delete -f samples/bookinfo/networking/bookinfo-gateway.yaml

2. Erstellen Sie eine Ingress-Ressource auf Port 80 für HTTP-Traffic.

   kubectl apply -f - <<EOF
   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     annotations:
       kubernetes.io/ingress.class: istio
     name: ingress
   spec:
     rules:
     - http:
        paths:
        - path: /productpage
          pathType: Prefix
          backend:
             service:
               name: productpage
               port:
                 number: 9080
   EOF

   Die Annotation kubernetes.io/ingress.class ist erforderlich, um den Istio-Gatewaycontroller anzuweisen, diese Ingress zu verarbeiten.

3. Prüfen Sie den Zugriff auf die Bookinfo-Anwendung, indem Sie die Anweisungen aus dem vorherigen Abschnitt befolgen.
4. Löschen Sie die Ressource, und aktivieren Sie das Istio-Gateway für weitere Aufgaben.

   kubectl delete ingress ingress
   kubectl apply -f samples/bookinfo/networking/bookinfo-gateway.yaml

Auf externe Services mit Egress zugreifen

Standardmäßig wird der gesamte ausgehende Traffic von einem Istio-fähigen Pod an seinen Sidecar-Proxy umgeleitet, und Istio konfiguriert den Envoy-Proxy so, dass er Anforderungen für unbekannte Services weiterleitet. Istio konfiguriert das Sidecar-Handling externer Dienste über ein Konfigurationsfeld meshConfig.outboundTrafficPolicy.mode. Ist diese Option auf:

• ALLOW_ANY (Standard): Der Istio-Proxy lässt Anrufe an unbekannte Services passieren.
• REGISTRY_ONLY: Istio-Proxy blockiert jeden Host, ohne dass ein HTTP-Service- oder Serviceeintrag im Mesh definiert ist.

Der Reader geht davon aus, dass die Bookinfo-Anwendung im Cluster bereitgestellt wird. Wenn nicht, führen Sie die Schritte zum Bereitstellen der Bookinfo-Anwendung aus.

Envoy Passthrough für externe Services verwalten

Führen Sie die folgenden Schritte aus, um Passthrough für externe Services zu aktivieren.

1. Ändern Sie die Option meshConfig.outboundTrafficPolicy.mode mit istioctl in ALLOW_ANY.

   istioctl install --set meshConfig.outboundTrafficPolicy.mode=ALLOW_ANY

   Hinweis
   
   Dieser Schritt ist nur erforderlich, wenn Sie die Option während der Installation explizit auf REGISTRY_ONLY gesetzt haben.
2. Um erfolgreiche 200 Antworten zu bestätigen, stellen Sie eine Anforderung an externe Services von der SOURCE_POD:

   export SOURCE_POD=$(kubectl get pod -l app=ratings -o jsonpath='{.items..metadata.name}')
   kubectl exec $SOURCE_POD -c ratings -- curl -sI http://httpbin.org/headers | grep "HTTP"

   Der Befehl gibt folgende Ausgabe aus:

   HTTP/1.1 200 OK

Nachteilig bei diesem Ansatz ist jedoch, dass die Überwachung und Kontrolle von Istio für den Verkehr zu externen Diensten verloren geht.

Zugriff auf externe Services kontrollieren [empfohlen]

So richten Sie den kontrollierten Zugriff auf externe Services ein:

1. Ändern Sie die Option meshConfig.outboundTrafficPolicy.mode in REGISTRY_ONLY. Dieser Schritt ist nur erforderlich, wenn Sie die Option während der Installation nicht explizit auf REGISTRY_ONLY gesetzt haben.
2. Folgen Sie nur Schritt 1 aus dem Abschnitt "Envoy Passthrough to External Services". Die einzige Änderung, die Sie hier vornehmen müssen, ist, ALLOW_ANY durch REGISTRY_ONLY zu ersetzen.
3. Um zu prüfen, ob die externen Services blockiert sind, stellen Sie einige Anforderungen an externe HTTPS-Services von der SOURCE_POD. Die Propagierung von Konfigurationsänderungen dauert mehrere Sekunden, sodass erfolgreiche Verbindungen möglich sind. Warten Sie einige Sekunden, und wiederholen Sie dann den letzten Befehl.

   export SOURCE_POD=$(kubectl get pod -l app=ratings -o jsonpath='{.items..metadata.name}')
   kubectl exec $SOURCE_POD -c ratings -- curl -sI http://httpbin.org/headers | grep "HTTP"

   Der Befehl gibt folgende Ausgabe aus:

   HTTP/1.1 502 Bad Gateway

4. Erstellen Sie eine ServiceEntry, um den Zugriff auf einen externen HTTP-Service zuzulassen.

   kubectl apply -f - <<EOF
   apiVersion: networking.istio.io/v1beta1
   kind: ServiceEntry
   metadata:
     name: httpbin-ext
   spec:
     hosts:
     - httpbin.org
     ports:
     - number: 80
       name: http
       protocol: HTTP
     resolution: DNS
     location: MESH_EXTERNAL
   EOF

5. Stellen Sie eine Anforderung an den externen HTTP-Service von SOURCE_POD. Beachten Sie, dass die vom Istio-Sidecar-Proxy hinzugefügten Header: X-Envoy-Decorator-Operation.

   kubectl exec $SOURCE_POD -c ratings -- curl -sI http://httpbin.org/headers | grep "HTTP"

   Der Befehl gibt folgende Ausgabe aus:

   HTTP/1.1 200 OK

   Entfernen Sie den Befehl grep, um alle Header anzuzeigen.

   kubectl exec $SOURCE_POD -c ratings -- curl -sS http://httpbin.org/headers

   Der Befehl gibt folgende Ausgabe aus:

   {
     "headers": {
       "Accept": "*/*",
       "Host": "httpbin.org",
       "User-Agent": "curl/7.52.1",
       "X-Amzn-Trace-Id": "Root=1-61384b41-2d3cf8b5571ba7504ab9a834",
       "X-B3-Sampled": "0",
       "X-B3-Spanid": "6983ef0cec914f83",
       "X-B3-Traceid": "d510c4d190cb099d6983ef0cec914f83",
       "X-Envoy-Attempt-Count": "1",
       "X-Envoy-Decorator-Operation": "httpbin.org:80/*",
       "X-Envoy-Peer-Metadata": "ChsKDkFQUF9DT05UQUlORVJTEgkaB3JhdGluZ3MKGgoKQ0xVU1RFUl9JRBIMGgpLdWJlcm5ldGVzChkKDUlTVElPX1ZFUlNJT04SCBoGMS4xMS4xCtQBCgZMQUJFTFMSyQEqxgEKEAoDYXBwEgkaB3JhdGluZ3MKIAoRcG9kLXRlbXBsYXRlLWhhc2gSCxoJYzk5NDdiOTlmCiQKGXNlY3VyaXR5LmlzdGlvLmlvL3Rsc01vZGUSBxoFaXN0aW8KLAofc2VydmljZS5pc3Rpby5pby9jYW5vbmljYWwtbmFtZRIJGgdyYXRpbmdzCisKI3NlcnZpY2UuaXN0aW8uaW8vY2Fub25pY2FsLXJldmlzaW9uEgQaAnYxCg8KB3ZlcnNpb24SBBoCdjEKGgoHTUVTSF9JRBIPGg1jbHVzdGVyLmxvY2FsCiQKBE5BTUUSHBoacmF0aW5ncy12MS1jOTk0N2I5OWYtbGN4bHQKFgoJTkFNRVNQQUNFEgkaB2RlZmF1bHQKTgoFT1dORVISRRpDa3ViZXJuZXRlczovL2FwaXMvYXBwcy92MS9uYW1lc3BhY2VzL2RlZmF1bHQvZGVwbG95bWVudHMvcmF0aW5ncy12MQoXChFQTEFURk9STV9NRVRBREFUQRICKgAKHQoNV09SS0xPQURfTkFNRRIMGgpyYXRpbmdzLXYx",
       "X-Envoy-Peer-Metadata-Id": "sidecar~10.244.0.11~ratings-v1-c9947b99f-lcxlt.default~default.svc.cluster.local"
     }
   }

6. Ersetzen Sie für den Zugriff auf HTTPS-Aufrufe den Port und das Protokoll beim Erstellen von Serviceeinträgen.
7. Der Ansatz fügt externe Service Traffic Management-Funktionen wie Timeouts und Fault-Injection hinzu. Die folgende Anforderung gibt in etwa fünf Sekunden 200 (OK) zurück.

   kubectl exec $SOURCE_POD -c ratings -- curl http://httpbin.org/delay/5

   Verwenden Sie kubectl, um einen 3-Sekunden-Timeout bei Aufrufen des externen Service httpbin.org festzulegen:

   kubectl apply -f - <<EOF
   apiVersion: networking.istio.io/v1beta1
   kind: VirtualService
   metadata:
     name: httpbin-ext
   spec:
     hosts:
       - httpbin.org
     http:
     - timeout: 3s
       route:
         - destination:
             host: httpbin.org
           weight: 100
   EOF

   Diesmal wird ein Timeout nach 3 Sekunden angezeigt. Obwohl httpbin.org fünf Sekunden wartete, unterbrach Istio die Anforderung nach 3 Sekunden:

   kubectl exec $SOURCE_POD -c ratings -- curl http://httpbin.org/delay/5

8. Bereinigen Sie die Ressourcen für weitere zukünftige Aufgaben.

   kubectl delete serviceentry httpbin-ext
   kubectl delete virtualservice httpbin-ext --ignore-not-found=true

Zugriff auf externe Services weiterleiten

Dieser Ansatz umgeht den Istio-Seitenwagen-Proxy und gibt den Diensten direkten Zugriff auf jeden externen Server. Für die Konfiguration des Proxys auf diese Weise sind jedoch clusterproviderspezifische Kenntnisse und Konfigurationen erforderlich. Ähnlich wie beim ersten Ansatz verlieren wir die Überwachung des Zugangs zu externen Diensten und können Istio-Funktionen nicht auf den Verkehr auf externe Dienste anwenden. Befolgen Sie diese Schritte, um direkten Zugriff auf externe Services zu ermöglichen.

Authentifizierung konfigurieren

Istio bietet gegenseitige TLS als Full-Stack-Lösung für die Transportauthentifizierung an, die ohne Servicecodeänderungen aktiviert wird.

kubectl apply -f samples/sleep/sleep.yaml
kubectl apply -f samples/httpbin/httpbin.yaml

Standardmäßig führt Istio mehrere Aufgaben aus. Istio verfolgt die Server-Workloads, die zu Istio-Proxys migriert wurden. Istio konfiguriert Clientproxys, um gegenseitigen TLS-Datenverkehr automatisch an diese Workloads zu senden. Istio sendet Klartextverkehr zu Arbeitslasten ohne Nebenwagen.

kubectl exec "$(kubectl get pod -l app=sleep -o jsonpath={.items..metadata.name})" -c sleep -- curl -s http://httpbin.default:8000/headers -s | grep X-Forwarded-Client-Cert | sed 's/Hash=[a-z0-9]*;/Hash=<redacted>;/'

kubectl create ns legacy
kubectl apply -f samples/sleep/sleep.yaml -n legacy
kubectl apply -f samples/httpbin/httpbin.yaml -n legacy

kubectl exec "$(kubectl get pod -l app=sleep -o jsonpath={.items..metadata.name})" -c sleep -- curl http://httpbin.legacy:8000/headers -s | grep X-Forwarded-Client-Cert

kubectl exec "$(kubectl get pod -l app=sleep -n legacy -o jsonpath={.items..metadata.name})" -n legacy -c sleep -- curl http://httpbin.default:8000/headers

kubectl apply -f - <<EOF
apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: "default"
  namespace: "istio-system"
spec:
  mtls:
    mode: STRICT
EOF

kubectl exec "$(kubectl get pod -l app=sleep -n legacy -o jsonpath={.items..metadata.name})" -n legacy -c sleep -- curl http://httpbin.default:8000/headers

kubectl delete peerauthentication -n istio-system default

Zusätzlich zur globalen gegenseitigen TLS-Einstellung kann sie auch auf Namespace- oder Workload-Ebene festgelegt werden. Ausführliche Authentifizierungskonfigurationen finden Sie in der Istio-Dokumentation.

Autorisierung konfigurieren

Mit Istio können Sie Autorisierungs-Policys für Ihre Anwendungen konfigurieren.

kubectl apply -f - <<EOF
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: allow-nothing
  namespace: default
spec:
  {}
EOF

Öffnen Sie die Bookinfo-Produktseite in Ihrem Browser. Es wird der Fehler "RBAC: access denied" angezeigt, der bestätigt, dass die Policy deny-all wie beabsichtigt funktioniert.

kubectl apply -f - <<EOF
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: "productpage-viewer"
  namespace: default
spec:
  selector:
    matchLabels:
      app: productpage
  action: ALLOW
  rules:
  - to:
    - operation:
        methods: ["GET"]
EOF

Die Seite "Bookinfo-Beispiel" wird angezeigt, aber der productpage-Service kann nicht auf die Details- und Bewertungsseite zugreifen.

Fügen Sie die folgenden Policys hinzu, um productpage Workload-Zugriff auf die Details zu erteilen, Workloads zu prüfen und Workload-Zugriff auf die ratings-Workload zu prüfen.

Detailanzeige einrichten

kubectl apply -f - <<EOF
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: "details-viewer"
  namespace: default
spec:
  selector:
    matchLabels:
      app: details
  action: ALLOW
  rules:
  - from:
    - source:
        principals: ["cluster.local/ns/default/sa/bookinfo-productpage"]
    to:
    - operation:
        methods: ["GET"]
EOF

Überprüfungs-Viewer festlegen

kubectl apply -f - <<EOF
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: "reviews-viewer"
  namespace: default
spec:
  selector:
    matchLabels:
      app: reviews
  action: ALLOW
  rules:
  - from:
    - source:
        principals: ["cluster.local/ns/default/sa/bookinfo-productpage"]
    to:
    - operation:
        methods: ["GET"]
EOF

Bewertungsanzeige einrichten

kubectl apply -f - <<EOF
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: "ratings-viewer"
  namespace: default
spec:
  selector:
    matchLabels:
      app: ratings
  action: ALLOW
  rules:
  - from:
    - source:
        principals: ["cluster.local/ns/default/sa/bookinfo-reviews"]
    to:
    - operation:
        methods: ["GET"]
EOF

Zeigen Sie die Produktseite in einem Browser ohne Fehler an.

Um die angewendeten Policys wiederherzustellen, geben Sie die folgenden Befehle ein.

kubectl delete authorizationpolicy.security.istio.io/allow-nothing
kubectl delete authorizationpolicy.security.istio.io/productpage-viewer
kubectl delete authorizationpolicy.security.istio.io/details-viewer
kubectl delete authorizationpolicy.security.istio.io/reviews-viewer
kubectl delete authorizationpolicy.security.istio.io/ratings-viewer

Gateways mit TLS sichern

Wir können die Bookinfo-Anwendung als sicheren HTTPS-Service entweder mit einfacher oder gegenseitiger TLS bereitstellen. Um die Zertifikate für Ihre Services zu signieren, erstellen Sie ein Root-Zertifikat und einen privaten Schlüssel:

openssl req -x509 -sha256 -nodes -days 365 -newkey rsa:2048 -subj '/O=example Inc./CN=example.com' -keyout example.com.key -out example.com.crt

Erstellen Sie ein Zertifikat und einen Private Key für productpage.bookinfo.com.

openssl req -out bookinfo.example.com.csr -newkey rsa:2048 -nodes -keyout bookinfo.example.com.key -subj "/CN=bookinfo.example.com/O=bookinfo organization"
openssl x509 -req -days 365 -CA example.com.crt -CAkey example.com.key -set_serial 0 -in bookinfo.example.com.csr -out bookinfo.example.com.crt

Stellen Sie sicher, dass Sie die Bookinfo-Anwendung bereitgestellt haben. Erstellen Sie ein Secret für die Ingress-Gatewayzertifikate.

kubectl create -n istio-system secret tls bookinfo-credential --key=bookinfo.example.com.key --cert=bookinfo.example.com.crt

Aktualisieren Sie das Bookinfo-Gateway, um einen sicheren Port aufzunehmen.

kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1beta1
kind: Gateway
metadata:
  name: bookinfo-gateway-https
spec:
  selector:
    istio: ingressgateway
  servers:
  - port:
      number: 443
      name: https
      protocol: HTTPS
    tls:
      mode: SIMPLE
      credentialName: bookinfo-credential
    hosts:
    - bookinfo.example.com
EOF

Erstellen Sie Bookinfo-Zielregeln, sofern sie noch nicht erstellt wurden.

kubectl apply -f samples/bookinfo/networking/destination-rule-all.yaml

Erstellen Sie einen virtuellen Service, der an das Gateway gebunden ist.

kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: bookinfo-https
spec:
  hosts:
  - "bookinfo.example.com"
  gateways:
  - bookinfo-gateway-https
  http:
  - route:
    - destination:
        host: productpage
        subset: v1
EOF

Sie können die TLS-Verbindung zum Gateway mit dem folgenden curl-Befehl prüfen.

curl -v -HHost:bookinfo.example.com --resolve "bookinfo.example.com:443:$INGRESS_HOST" --cacert example.com.crt "https://bookinfo.example.com/productpage"