Mit Istio als eigenständigem Programm arbeiten

Erfahren Sie, wie Sie Istio als Standalone-Programm auf Clustern installieren, die Sie mit der Kubernetes Engine (OKE) erstellt haben.

Dieses Thema enthält ein Beispiel für die Installation von Istio als Standalone-Programm auf Clustern, die Sie mit der Kubernetes-Engine (OKE) erstellt haben. Darüber hinaus werden die wichtigsten Merkmale von OKE und Istio demonstriert.

Folgende Themen werden behandelt:

Beachten Sie, dass Service-Mesh-Produkte (wie Oracle Cloud Infrastructure Service Mesh, Istio und Linkerd) bei der Verwendung des OCI-VCN-nativen Podnetzwerk-CNI-Plug-ins für Podnetze unterstützt werden. Beachten Sie, dass der Support mit Ausnahme des Istio-Add-ons derzeit auf Oracle Linux 7 beschränkt ist (Oracle Linux 8-Support ist geplant). Das Add-on Istio wird sowohl mit Oracle Linux 7 als auch mit Oracle Linux 8 unterstützt. Worker-Knoten müssen Kubernetes 1.26 (oder höher) ausführen.

Hinweis

Sie können Istio mit verwalteten Knotenpools verwenden, jedoch nicht mit virtuellen Knotenpools.

Istio als eigenständiges Programm installieren

Um mit Istio zu beginnen, erstellen Sie ein OKE-Cluster, oder verwenden Sie ein vorhandenes OKE-Cluster, und installieren Sie Istio. In den folgenden Abschnitten werden die Schritte zum Installieren und Testen Ihrer Istio-Einrichtung erläutert. Eine vollständige Liste der Installationsoptionen finden Sie hier.

OKE-Cluster erstellen

Erstellen Sie ein OKE-Cluster.

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.
Um auf das OKE-Cluster auf dem lokalen Rechner zuzugreifen, installieren Sie kubectl und oci-cli.
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.

Laden Sie Istio herunter, indem Sie den folgenden Befehl ausführen:
```
curl -L https://istio.io/downloadIstio | sh -
```
Wechseln Sie in das Istio-Paketverzeichnis. Beispiel: Das Paket istio-1.11.2:
```
cd istio-1.11.2
```
Fügen Sie das Clienttool istioctl zur PATH für Ihre Workstation hinzu.
```
export PATH=$PWD/bin:$PATH
```
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

Installieren Sie Istio mit istioctl mit dem folgenden Befehl:

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.

Beschriften Sie den Namespace, der die Anwendung hostet, mit istio-injection=enabled.
```
kubectl label namespace default istio-injection=enabled
```

Stellen Sie die Bookinfo-Beispielanwendung bereit.

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

Stellen Sie sicher, dass alle Services und Pods ausgeführt werden.
```
kubectl get services
kubectl get pods
```

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>"

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

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

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.

Beobachtbarkeit von Istio untersuchen

In diesem Abschnitt werden die Performancemetriken und Tracing-Features erläutert, die von den Istio-Integrationsanwendungen bereitgestellt werden.

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

Klicken Sie im Header rechts neben Prometheus auf Diagramm. 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.

Hinweis

Generieren Sie Traffic zur Produktseite mit einem Browser oder curl, und zeigen Sie ihn im Grafana-Dashboard an.

Istio Mesh-Dashboard

Istio-Service-Dashboard

Istio-Arbeitsauslastungs-Dashboard

Istio Performance-Dashboard

Dashboard für Istio-Steuerungsbereich

Snapshot des Istio-Steuerbereichs-Dashboards

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.

Aktivieren und konfigurieren Sie das Tracing mit istioctl:
```
istioctl install --set meshConfig.enableTracing=true
```
Wenn die Bookinfo-Anwendung bereitgestellt ist, öffnen Sie die Jaeger-UI mit istioctl.
```
istioctl dashboard jaeger
```

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

Snapshot der Istio Jaeger-Anwendungsverfolgung

Verteiltes Tracing mit zipkin ausführen

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

Aktivieren und konfigurieren Sie das Tracing mit istioctl.
```
istioctl install --set meshConfig.enableTracing=true
```
Wenn die Bookinfo-Anwendung bereitgestellt ist, öffnen Sie die zipkin-Benutzeroberfläche mit istioctl.
```
istioctl dashboard zipkin
```

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.

Hinweis

Ausführliche Informationen zum Konfigurieren von APM-Service-Policys finden Sie unter:

Istio konfigurieren, um Traces an APM zu senden

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.

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

Wenden Sie die benutzerdefinierte Konfiguration an.

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

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: {}
---

Wenden Sie das YAML an. Alle neu gestarteten Pods senden Traces an APM.
```
kubectl apply -f samples/bookinfo/platform/kube/bookinfo.yaml
```

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

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

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

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

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, klicken Sie in der APM-Liste auf "Home".

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.

Aktivieren Sie die Anmeldung des Gesandten bei Istio mit istioctl.
```
istioctl install --set meshConfig.accessLogFile=/dev/stdout
```
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

Screenshot einer erweiterten OCI Logging-Suche

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 verwalten

Mit den Verkehrsroutingregeln von Istio können Sie den Verkehrsfluss zwischen Services steuern und die Konfiguration von Service-Level-Eigenschaften wie Circuit Breaker, Timeouts und Wiederholungen vereinfachen. Istio macht es einfach, wichtige Aufgaben wie A/B-Tests, kanarische Rollouts und inszenierte Rollouts mit prozentualen Traffic-Splits einzurichten.

Istios API-Ressourcen für das Verkehrsmanagement:

Damit Istio das Routing der Bookinfo-Anwendungsversion steuern kann, definieren Sie alle verfügbaren Versionen Ihres Service, die als Teilmengen bezeichnet werden, in Zielregeln. Standardzielregeln für die Bookinfo-Services erstellen:

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

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.

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.
Ü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.

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

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

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

Anforderungsrouting verwalten

Istio kann den Verkehr auf verschiedene Weise leiten. Um zu starten, konfigurieren Sie Istio so, dass der gesamte Traffic über v1 jedes Microservice geleitet wird.

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:

Ä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
```
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.
Ö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.

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

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
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
```
Ö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.

Initialisieren Sie das Routing der Anwendungsversion, indem Sie den folgenden Befehl ausführen:
```
kubectl apply -f samples/bookinfo/networking/virtual-service-all-v1.yaml
```

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

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

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.

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

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:

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
```
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.

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
```
Leiten Sie den gesamten Traffic an die v1-Version jedes Microservice weiter.
```
kubectl apply -f samples/bookinfo/networking/virtual-service-all-v1.yaml
```
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)
```

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

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

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

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

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.

Leiten Sie den gesamten Traffic an die v1-Version jedes Microservice weiter.
```
kubectl apply -f samples/bookinfo/networking/virtual-service-all-v1.yaml
```
Ä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.
Senden Sie Datenverkehr, indem Sie die URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage in einem Browser aktualisieren.
Logs des reviews:v1-Service. Hinweis: Der Service v1 ruft den Bewertungsservice nicht auf.
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.

Wenn Sie die Istio-Gateways nicht im Rahmen der Installation eingerichtet haben, führen Sie den folgenden Befehl aus, um sie zu installieren.

istioctl install

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

Hinweis

Bestimmen Sie INGRESS_HOST und INGRESS_PORT mit diesen Anweisungen.

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.

Hinweis

Wenn Sie die Bookinfo-Anwendung bereits bereitgestellt haben, sind die folgenden Schritte nicht erforderlich.

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

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

Informationen zum Bereitstellen der Bookinfo-Anwendung finden Sie im Abschnitt "Ausführen der Bookinfo-Anwendung" der Seite Installieren von Istio und OKE.

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

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

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
```
Ö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.

Entfernen Sie das Istio-Gateway, wenn die Konfiguration bereits angewendet wurde.
```
kubectl delete -f samples/bookinfo/networking/bookinfo-gateway.yaml
```

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 kubernetes.io/ingress.class-Annotation ist erforderlich, um den Istio-Gatewaycontroller anzufordern, diese Ingress zu verarbeiten.

Prüfen Sie den Zugriff auf die Bookinfo-Anwendung, indem Sie die Anweisungen aus dem vorherigen Abschnitt befolgen.

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.

Ä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.

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:

Ä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.
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.
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
```

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

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"
  }
}

Ersetzen Sie für den Zugriff auf HTTPS-Aufrufe den Port und das Protokoll beim Erstellen von Serviceeinträgen.
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
```

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.

Istio sichern

Die Istio-Sicherheitsfunktionen bieten starke Identitäts-, leistungsstarke Richtlinien, transparente TLS-Verschlüsselung sowie Authentifizierungs-, Autorisierungs- und Audit-(AAA-)Tools zum Schutz Ihrer Services und Daten.

Authentifizierung konfigurieren

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

Stellen Sie die Services sleep und httpbin im Standard-Namespace bereit.

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.

Um zu prüfen, ob Certs gesendet werden, senden Sie eine Anforderung von einem sleep-Pod an den httpbin-Pod, und suchen Sie nach dem X-Forwarded-Client-Cert-Header.

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>;/'

Stellen Sie eine weitere Instanz der Services sleep und httpbin bereit, ohne dass das Sidecar aktiviert ist.

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

Die Anforderung vom sleep-Pod im Standard-Namespace an den httpbin-Pod im Legacy-Namespace ist Klartext, weil das Ziel nicht für Sidecar aktiviert ist. Prüfen Sie, ob Nur-Text gesendet wird, indem Sie den folgenden Befehl ausführen.

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

Die Anforderung vom Pod sleep im Legacy-Namespace an httpbin im Standard-Namespace ist auch mit einer Klartextverbindung erfolgreich. Die Prüfung kann mit dem folgenden Befehl erfolgen.

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

Um nicht gegenseitigen TLS-Traffic für das gesamte Mesh zu verhindern, legen Sie eine Mesh-weite Peerauthentifizierungs-Policy fest, wobei der gegenseitige TLS-Modus auf STRICT gesetzt ist.

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

Die Verbindung von einem sleep-Pod im Legacy-Namespace zu httpbin im Standard-Namespace funktioniert nicht mehr, wenn der gegenseitige TLS-Modus auf STRICT gesetzt ist.

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

Setzen Sie die Einstellung für die Peerauthentifizierung STRICT zurück, indem Sie das CR löschen.

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.

Konfigurieren Sie zunächst eine einfache allow-nothing-Policy, die alle Anforderungen an die Workload ablehnt und dann schrittweise und inkrementell mehr Zugriff auf die Workload erteilt.

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.

Erstellen Sie eine Policy, um allen Benutzern und Workloads mit dem folgenden Befehl Zugriff auf die Produktseite zu erteilen.

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"

Oracle Cloud Infrastructure - Dokumentation

Mit Istio als eigenständigem Programm arbeiten

Istio als eigenständiges Programm installieren

OKE-Cluster erstellen

Istio von der Befehlszeile herunterladen

Istio mit istioctl installieren

Bookinfo-Anwendung ausführen

Istio-Integrationsanwendungen hinzufügen

Beobachtbarkeit von Istio untersuchen

Metriken aus Prometheus für Bookinfo-Anwendung abfragen

Metriken für die Bookinfo-Anwendung mit Grafana visualisieren

Verteiltes Tracing mit Jaeger ausführen

Verteiltes Tracing mit zipkin ausführen

Verteiltes Tracing mit OCI Application Performance Monitoring ausführen

Logs mit OCI Logging beobachten

Mesh mit Kiali visualisieren

Traffic verwalten

Traffic verschieben

Anforderungsrouting verwalten

Netzwerkresilienz testen

Mirroring

Gateways verwalten

Istio sichern

Authentifizierung konfigurieren

Autorisierung konfigurieren

Gateways mit TLS sichern