TOC

Vorgehensweise bei Canary-Bereitstellungen mit Istio und Kubernetes

Einführung

Bei der Einführung neuer Versionen eines Dienstes ist es häufig wünschenswert, einen kontrollierten Prozentsatz des Benutzerverkehrs auf eine neuere Version des Dienstes zu verlagern, wenn die ältere Version auslaufen soll. Diese Technik wird als kanarische Bereitstellung bezeichnet.

Kubernetes-Clusterbetreiber können canary deployments nativ über https://kubernetes.io/docs/concepts/overview/working orchestrieren -with-objects / labels / [labels] und Deployments. Diese Technik weist jedoch bestimmte Einschränkungen auf: Die Verteilung des Datenverkehrs und die Anzahl der Replikate sind gekoppelt, was in der Praxis bedeutet, dass die Replikatverhältnisse manuell gesteuert werden müssen, um den Datenverkehr auf die kanarische Freigabe zu beschränken. Mit anderen Worten, um 10% des Datenverkehrs auf eine kanarische Bereitstellung zu leiten, benötigen Sie einen Pool von zehn Pods, wobei ein Pod 10% des Benutzerverkehrs und die anderen neun den Rest des Datenverkehrs erhalten.

Durch die Bereitstellung mit einem Istio -Service-Mesh kann dieses Problem behoben werden, indem eine klare Trennung zwischen Replikatanzahl und Verkehrsverwaltung ermöglicht wird. Das Istio-Netz ermöglicht eine fein abgestimmte Datenverkehrssteuerung, die die Verteilung und Verwaltung des Datenverkehrs von der Skalierung der Replikate entkoppelt. Anstatt die Replikatverhältnisse manuell zu steuern, können Sie Verkehrsprozentsätze und -ziele definieren, und der Rest wird von Istio verwaltet.

In diesem Lernprogramm erstellen Sie eine kanarische Bereitstellung mit Istio und Kubernetes. Sie werden zwei Versionen einer Demoanwendung Node.js bereitstellen und Virtual Service verwenden und Destination Rule, um das Datenverkehrsrouting sowohl für die neuere als auch für die ältere Version zu konfigurieren. Dies wird ein guter Ausgangspunkt sein, um zukünftige kanarische Bereitstellungen mit Istio aufzubauen.

Voraussetzungen

Schritt 1 - Verpacken der Anwendung

Im vorausgesetzten Lernprogramm https://www.digitalocean.com/community/tutorials/installations- und verwendungsanleitung-mit- kubernetzexpertenInstallation und Verwendung von Istio mit Kubernetzexperten können Sie https: // www.digitalocean.com/community/tutorials/how-to-install-and-use-istio#step-1-%E2%80%94-packaging-the-application[created a + node-demo + Docker image] um eine Hai-Informationsanwendung auszuführen und dieses Image an Docker Hub zu senden. In diesem Schritt erstellen Sie ein weiteres Image: eine neuere Version der Anwendung, die Sie für Ihre kanarische Bereitstellung verwenden.

Unsere ursprüngliche Demo-Anwendung hat einige freundliche Fakten über Haie auf ihrer * Shark Info * -Seite hervorgehoben:

image: https://assets.digitalocean.com/articles/docker_node_image/sharks.png [Hai-Infoseite]

Wir haben uns jedoch entschlossen, in unserer neuen kanarischen Version einige beängstigendere Fakten hervorzuheben:

Bild: https://assets.digitalocean.com/articles/istio_canary/scary_sharks.png [Scary Shark Info Page]

Unser erster Schritt wird darin bestehen, den Code für diese zweite Version unserer Anwendung in ein Verzeichnis mit dem Namen "++" zu klonen. Klonen Sie mit dem folgenden Befehl das Repository nodejs-canary-app aus der DigitalOcean Community GitHub-Konto. Dieses Repository enthält den Code für die zweite, erschreckendere Version unserer Anwendung:

git clone https://github.com/do-community/nodejs-canary-app.git

Navigiere zum ++ Verzeichnis:

cd

Dieses Verzeichnis enthält Dateien und Ordner für die neuere Version unserer Hai-Informationsanwendung, in der Benutzer Informationen zu Haien wie in der ursprünglichen Anwendung, jedoch mit Schwerpunkt auf beängstigenderen Fakten, erhalten. Zusätzlich zu den Anwendungsdateien enthält das Verzeichnis eine Docker-Datei mit Anweisungen zum Erstellen eines Docker-Images mit dem Anwendungscode. Weitere Informationen zu den Anweisungen in der Docker-Datei finden Sie unter https://www.digitalocean.com/community/tutorials/how-to-build-a-node-js-application-with-docker#step-3-%E2% 80% 94-writing-the-dockerfile [Schritt 3 von So erstellen Sie eine Node.js-Anwendung mit Docker].

Um zu testen, ob der Anwendungscode und die Docker-Datei wie erwartet funktionieren, können Sie das Image mit dem Befehl https://docs.docker.com/engine/reference/commandline/build/[`docker build + `] erstellen und kennzeichnen Verwenden Sie das Bild, um einen Demo-Container auszuführen. Wenn Sie das Flag " -t " mit " docker build +" verwenden, können Sie das Image mit Ihrem Docker Hub-Benutzernamen kennzeichnen, damit Sie es nach dem Testen an Docker Hub senden können.

Erstellen Sie das Image mit dem folgenden Befehl:

docker build -t / .

Das ". +" Im Befehl gibt an, dass der Erstellungskontext das aktuelle Verzeichnis ist. Wir haben das Image "+" genannt, um auf das "+ node-demo +" - Image zu verweisen. Https://www.digitalocean.com/community/tutorials/how-to-install-and-use-istio#step-1 -% E2% 80% 94-packaging-the-application [von uns erstellt] unter How To Installieren und Verwenden von Istio mit Kubernetes.

Sobald der Erstellungsprozess abgeschlossen ist, können Sie Ihre Bilder unter `+docker images + ` auflisten:

docker images

Sie werden die folgende Ausgabe sehen, die den Image-Build bestätigt:

OutputREPOSITORY                            TAG                 IMAGE ID            CREATED             SIZE
/  latest              37f1c2939dbf        5 seconds ago       77.6MB
node                                  10-alpine           9dfa73010b19        2 days ago          75.3MB

Als nächstes erstellen Sie mit + docker run + einen Container, der auf diesem Bild basiert. Wir werden drei Flags in diesen Befehl aufnehmen:

  • + -p +: Hiermit wird der Port auf dem Container veröffentlicht und einem Port auf unserem Host zugeordnet. Wir werden den Port "+ 80 +" auf dem Host verwenden, aber Sie können dies nach Bedarf ändern, wenn auf diesem Port ein anderer Prozess ausgeführt wird. Weitere Informationen zur Funktionsweise finden Sie in dieser Diskussion in den Docker-Dokumenten unter port binding.

  • + -d +: Hiermit wird der Container im Hintergrund ausgeführt.

  • + - name +: Hiermit können wir dem Container einen benutzerdefinierten Namen geben.

Führen Sie den folgenden Befehl aus, um den Container zu erstellen:

docker run --name  -p 80:8080 -d /

Überprüfen Sie Ihre laufenden Container mit `+docker ps + `:

docker ps

Sie sehen die Ausgabe, die bestätigt, dass Ihr Anwendungscontainer ausgeführt wird:

OutputCONTAINER ID        IMAGE                                  COMMAND                  CREATED             STATUS              PORTS                  NAMES
49a67bafc325        /   "docker-entrypoint.s…"   8 seconds ago       Up 6 seconds        0.0.0.0:80->8080/tcp

Sie können jetzt Ihre Server-IP in Ihrem Browser aufrufen, um Ihr Setup zu testen: + http: // +. Ihre Anwendung zeigt die folgende Zielseite an:

image: https://assets.digitalocean.com/articles/docker_node_image/landing_page.png [Landing Page der Anwendung]

Klicken Sie auf die Schaltfläche * Get Shark Info *, um zu den erschreckenderen Informationen zu gelangen:

Bild: https://assets.digitalocean.com/articles/istio_canary/scary_sharks.png [Scary Shark Info Page]

Nachdem Sie die Anwendung getestet haben, können Sie den laufenden Container stoppen. Verwenden Sie + docker ps + erneut, um Ihre + CONTAINER ID + zu erhalten:

docker ps
OutputCONTAINER ID        IMAGE                                  COMMAND                  CREATED              STATUS              PORTS                  NAMES
49a67bafc325        /   "docker-entrypoint.s…"   About a minute ago   Up About a minute   0.0.0.0:80->8080/tcp

Stoppen Sie den Container mit https://docs.docker.com/engine/reference/commandline/stop/[`docker stop + `]. Stellen Sie sicher, dass Sie die hier aufgeführte " CONTAINER ID " durch Ihre eigene " CONTAINER ID +" ersetzen:

docker stop

Nachdem Sie das Image getestet haben, können Sie es an Docker Hub senden. Melden Sie sich zunächst bei dem Docker Hub-Konto an, das Sie unter den folgenden Voraussetzungen erstellt haben:

docker login -u

Wenn Sie dazu aufgefordert werden, geben Sie Ihr Docker Hub-Kontokennwort ein. Wenn Sie sich auf diese Weise anmelden, wird eine "+ ~ / .docker / config.json +" - Datei mit Ihren Docker Hub-Anmeldeinformationen im Stammverzeichnis Ihres Nicht-Root-Benutzers erstellt.

Senden Sie das Anwendungsimage mit dem Befehl https://docs.docker.com/engine/reference/commandline/push/[`docker push + `an Docker Hub. Denken Sie daran, "+" durch Ihren eigenen Docker Hub-Benutzernamen zu ersetzen:

docker push /

Sie haben jetzt zwei Anwendungsimages in Docker Hub gespeichert: das Image "+ node-demo " und "+". Wir werden nun die Manifeste ändern, die Sie im vorausgesetzten Lernprogramm How To Install and Use Istio With Kubernetes erstellt haben , um den Datenverkehr auf die kanarische Version Ihrer Anwendung zu leiten.

Schritt 2 - Ändern der Anwendungsbereitstellung

In Installation und Verwendung von Istio With Kubernetes haben Sie eine Anwendung https: // kubernetes erstellt .io / docs / concepts / cluster-administration / manage-deployment / # Organisation von Ressourcenkonfigurationen [manifest] mit specifications für Ihre Anwendung Service und Deployment Objekte. Diese Spezifikationen beschreiben den gewünschten Zustand jedes Objekts. In diesem Schritt fügen Sie diesem Manifest eine Bereitstellung für die zweite Version Ihrer Anwendung sowie Versionsbezeichnungen hinzu, mit denen Istio diese Ressourcen verwalten kann.

Wenn Sie den Anweisungen zur Einrichtung im vorausgesetzten Lernprogramm gefolgt sind, haben Sie ein Verzeichnis mit dem Namen "+ istio_project " und zwei Manifeste " yaml " erstellt: " node-app.yaml +", das die Spezifikationen für Ihre Dienst- und Bereitstellungsobjekte enthält, und " + node-istio.yaml + `, das Spezifikationen für Ihre Istio Virtual Service- und Gateway-Ressourcen enthält.

Navigieren Sie jetzt zum Verzeichnis + istio_project +:

cd
cd istio_project

Öffnen Sie "+ node-app.yaml " mit " nano +" oder Ihrem bevorzugten Editor, um Änderungen an Ihrer Anwendung vorzunehmen:

nano node-app.yaml

Derzeit sieht die Datei folgendermaßen aus:

~ / istio_project / node-app.yaml

apiVersion: v1
kind: Service
metadata:
 name: nodejs
 labels:
   app: nodejs
spec:
 selector:
   app: nodejs
 ports:
 - name: http
   port: 8080
---
apiVersion: apps/v1
kind: Deployment
metadata:
 name: nodejs
 labels:
   version: v1
spec:
 replicas: 1
 selector:
   matchLabels:
     app: nodejs
 template:
   metadata:
     labels:
       app: nodejs
       version: v1
   spec:
     containers:
     - name: nodejs
       image: /node-demo
       ports:
       - containerPort: 8080

Eine vollständige Erklärung des Inhalts dieser Datei finden Sie unter https://www.digitalocean.com/community/tutorials/how-to-install-and-use-istio#step-3-%E2%80%94-creating-application -Objekte [Schritt 3] unter https://www.digitalocean.com/community/tutorials/Installations-und Verwendungsanleitung-mit-KubernetsenSo installieren und verwenden Sie Istio mit Kubernetsen].

Wir haben bereits Versionsbezeichnungen in unsere Felder "+ Metadaten " und " Vorlage " aufgenommen, die https://istio.io/docs/setup/kubernetes/prepare/requirements/[Istios Empfehlungen für Pods und Services] folgen. Jetzt können wir Spezifikationen für ein zweites Deployment-Objekt hinzufügen, das die zweite Version unserer Anwendung darstellt, und das " name +" unseres ersten Deployment-Objekts schnell ändern.

Ändern Sie zunächst den Namen Ihres vorhandenen Bereitstellungsobjekts in "+ nodejs +":

~ / istio_project / node-app.yaml

...
apiVersion: apps/v1
kind: Deployment
metadata:
 name: nodejs
 labels:
   version: v1
...

Fügen Sie als Nächstes unter den Spezifikationen für diese Bereitstellung die Spezifikationen für Ihre zweite Bereitstellung hinzu. Denken Sie daran, den Namen Ihres eigenen Bildes in das Feld "+ Bild +" einzufügen:

~ / istio_project / node-app.yaml

...
---
apiVersion: apps/v1
kind: Deployment
metadata:
 name: nodejs-v2
 labels:
   version: v2
spec:
 replicas: 1
 selector:
   matchLabels:
     app: nodejs
 template:
   metadata:
     labels:
       app: nodejs
       version: v2
   spec:
     containers:
     - name: nodejs
       image: /node-demo-v2
       ports:
       - containerPort: 8080

Wie bei der ersten Bereitstellung wird bei dieser Bereitstellung ein "+ version " - Etikett verwendet, um die Version der Anwendung anzugeben, die dieser Bereitstellung entspricht. In diesem Fall unterscheidet " v2 " die mit dieser Bereitstellung verknüpfte Anwendungsversion von " v1 +", was unserer ersten Bereitstellung entspricht.

Wir haben auch sichergestellt, dass auf dem von der Bereitstellung von + v2 + verwalteten Pods das kanarische Image + node-demo-v2 + ausgeführt wird. was wir im vorherigen Schritt gebaut haben.

Speichern und schließen Sie die Datei, wenn Sie mit der Bearbeitung fertig sind.

Wenn Sie Ihr Anwendungsmanifest geändert haben, können Sie Änderungen an Ihrer Datei + node-istio.yaml + vornehmen.

Schritt 3 - Gewichtung des Datenverkehrs mit virtuellen Diensten und Hinzufügen von Zielregeln

In Installation und Verwendung von Istio With Kubernetes haben Sie zuzulassende Gateway- und Virtual Service-Objekte erstellt externe Zugriffe in das Istio-Netz und leiten Sie es an Ihren Anwendungsdienst weiter. Hier ändern Sie Ihre Virtual Service-Konfiguration so, dass sie das Routing zu Ihren Application Service-Teilmengen umfasst - "+ v1 " und " v2 ". Sie fügen außerdem eine https://istio.io/docs/reference/config/networking/v1alpha3/destination-rule/[Destination Rule] hinzu, um zusätzliche versionsbasierte Richtlinien zu den Routing-Regeln zu definieren, die Sie auf Ihr ` anwenden nodejs + `application Service.

Öffnen Sie die Datei + node-istio.yaml +:

nano node-istio.yaml

Derzeit sieht die Datei folgendermaßen aus:

~ / istio_project / node-istio.yaml

apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
 name: nodejs-gateway
spec:
 selector:
   istio: ingressgateway
 servers:
 - port:
     number: 80
     name: http
     protocol: HTTP
   hosts:
   - "*"
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
 name: nodejs
spec:
 hosts:
 - "*"
 gateways:
 - nodejs-gateway
 http:
 - route:
   - destination:
       host: nodejs

Eine vollständige Erläuterung der Spezifikationen in diesem Manifest finden Sie unter https://www.digitalocean.com/community/tutorials/how-to-install-and-use-istio#step-4-%E2%80%94-creating -istio-objects [Schritt 4] von https://www.digitalocean.com/community/tutorials/installations- und verwendungsanleitung-istio-mit- kubernetes[Installation und Verwendung von Istio mit Kubernetes].

Unsere erste Änderung betrifft den virtuellen Service. Gegenwärtig leitet diese Ressource den Verkehr, der in das Netz eintritt, durch unser "+ nodejs-gateway" zu unserem "+ nodejs" -Anwendungsservice. Wir möchten eine Routing-Regel konfigurieren, die 80% des Datenverkehrs an unsere ursprüngliche Anwendung und 20% an die neuere Version sendet. Sobald wir mit der Leistung von canary zufrieden sind, können wir unsere Verkehrsregeln neu konfigurieren, um den gesamten Verkehr schrittweise an die neuere Anwendungsversion zu senden.

Anstatt wie im ursprünglichen Manifest an ein einzelnes "+ Ziel" zu routen, fügen wir "+ Ziel" -Felder für beide Teilmengen unserer Anwendung hinzu: die ursprüngliche Version ("+ v1 ") und die kanarische Version (" v2 +") `).

Nehmen Sie die folgenden Ergänzungen zum virtuellen Dienst vor, um diese Routing-Regel zu erstellen:

~ / istio_project / node-istio.yaml

...
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
 name: nodejs
spec:
 hosts:
 - "*"
 gateways:
 - nodejs-gateway
 http:
 - route:
   - destination:
       host: nodejs

Die Richtlinie, die wir hinzugefügt haben, enthält zwei Ziele: die "+ Teilmenge " unseres " Nodejs " - Dienstes, auf dem die ursprüngliche Version unserer Anwendung ausgeführt wird, " v1 " und die " Teilmenge +", auf der der Kanarienvogel ausgeführt wird + v2 + `. Teilmenge 1 erhält 80% des eingehenden Verkehrs, während der Kanarienvogel 20% erhält.

Als Nächstes fügen wir eine Zielregel hinzu, die Regeln auf eingehenden Verkehr anwendet, nachdem dieser Verkehr an den entsprechenden Dienst weitergeleitet wurde. In unserem Fall konfigurieren wir "+ subset +" - Felder, um Datenverkehr mit den entsprechenden Versionsbezeichnungen an Pods zu senden.

Fügen Sie den folgenden Code unter Ihrer Definition des virtuellen Dienstes hinzu:

~ / istio_project / node-istio.yaml

...
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
 name: nodejs
spec:
 host: nodejs
 subsets:
 - name: v1
   labels:
     version: v1
 - name: v2
   labels:
     version: v2

Unsere Regel stellt sicher, dass der Datenverkehr zu unseren Service-Teilmengen "+ v1 " und " v2 " Pods mit den entsprechenden Bezeichnungen erreicht: " version: v1 " und " version: v2 +". Dies sind die Bezeichnungen, die wir in unsere Anwendungsbereitstellungsspezifikationen aufgenommen haben.

Wenn wir möchten, können wir jedoch auch bestimmte Verkehrsrichtlinien auf Untergruppenebene anwenden, um unsere kanarischen Bereitstellungen spezifischer zu gestalten. Weitere Informationen zum Definieren von Verkehrsrichtlinien auf dieser Ebene finden Sie in der official Istio documentation.

Speichern und schließen Sie die Datei, wenn Sie mit der Bearbeitung fertig sind.

Mit den überarbeiteten Anwendungsmanifesten können Sie Ihre Konfigurationsänderungen übernehmen und Ihre Anwendungsverkehrsdaten mit dem Grafana-Telemetrie-Addon überprüfen.

Schritt 4 - Anwenden von Konfigurationsänderungen und Zugreifen auf Verkehrsdaten

Die Anwendungsmanifeste werden aktualisiert, aber wir müssen diese Änderungen noch auf unseren Kubernetes-Cluster anwenden. Wir werden den Befehl `+kubectl apply + ` verwenden, um unsere Änderungen zu übernehmen, ohne die vorhandene Konfiguration vollständig zu überschreiben. Anschließend können Sie einige Anforderungen an Ihre Anwendung generieren und die zugehörigen Daten in Ihren Istio Grafana-Dashboards anzeigen.

Wenden Sie Ihre Konfiguration auf die Dienst- und Bereitstellungsobjekte Ihrer Anwendung an:

kubectl apply -f node-app.yaml

Sie werden die folgende Ausgabe sehen:

Outputservice/nodejs unchanged
deployment.apps/nodejs-v1 created
deployment.apps/nodejs-v2 created

Wenden Sie als Nächstes die von Ihnen vorgenommenen Konfigurationsaktualisierungen an "+ node-istio.yaml +" an, einschließlich der Änderungen am virtuellen Dienst und der neuen Zielregel:

kubectl apply -f node-istio.yaml

Sie werden die folgende Ausgabe sehen:

Outputgateway.networking.istio.io/nodejs-gateway unchanged
virtualservice.networking.istio.io/nodejs configured
destinationrule.networking.istio.io/nodejs created

Sie können jetzt Zugriffe auf Ihre Anwendung generieren. Bevor Sie dies tun, überprüfen Sie zunächst, ob der Dienst + grafana + ausgeführt wird:

kubectl get svc -n istio-system | grep grafana
Outputgrafana                  ClusterIP      10.245.233.51    <none>           3000/TCP                                                                                                                                     4d2h

Überprüfen Sie auch die zugehörigen Pods:

kubectl get svc -n istio-system | grep grafana
Outputgrafana-67c69bb567-jpf6h                 1/1     Running     0          4d2h

Überprüfen Sie abschließend, ob das "+ grafana-gateway " Gateway und der " grafana-vs +" Virtual Service vorhanden sind:

kubectl get gateway -n istio-system | grep grafana
Outputgrafana-gateway   3d5h
kubectl get virtualservice -n istio-system | grep grafana
Outputgrafana-vs   [grafana-gateway]   [*]     4d2h

Wenn die Ausgabe dieser Befehle nicht angezeigt wird, überprüfen Sie die Schritte https://www.digitalocean.com/community/tutorials/how-to-install-and-use-istio#step-2-%E2%80%94-. Installieren von istio with helm und https://www.digitalocean.com/community/tutorials/Installations-und Verwendungsanleitung#step-5-%E2%80%94-creating- Anwendungsressourcen und Aktivierung des Telemetriezugriffs [5] unter https://www.digitalocean.com/community/tutorials/installations- und verwendungsanleitung für kubernetes[How To Install and Use and Use Istio With Kubernetes], in dem erläutert wird, wie das Grafana-Telemetrie-Addon bei der Installation von Istio aktiviert wird und wie der HTTP-Zugriff auf den Grafana-Dienst aktiviert wird.

Sie können jetzt im Browser auf Ihre Anwendung zugreifen. Dazu benötigen Sie die externe IP-Adresse, die Ihrem Service zugeordnet ist (LoadBalancer-Servicetyp). Wir haben unser + nodejs-gateway + Gateway mit diesem Controller abgeglichen, als wir unser Gateway-Manifest in https://www.digitalocean.com/community/tutorials/how-to-install-and-use-istio-with-kubernetes[How geschrieben haben So installieren und verwenden Sie Istio mit Kubernetes Weitere Informationen zum Gateway-Manifest finden Sie unter https://www.digitalocean.com/community/tutorials/how-to-install-and-use-istio#step-4-%E2%80%94-creating-istio- Objekte [Schritt 4 dieses Tutorials.

Rufen Sie die externe IP für den Dienst "+ istio-ingressgateway +" mit dem folgenden Befehl ab:

kubectl get svc -n istio-system

Sie sehen die Ausgabe wie folgt:

OutputNAME                     TYPE           CLUSTER-IP       EXTERNAL-IP       PORT(S)                                                                                                                                      AGE
grafana                  ClusterIP      10.245.85.162    <none>            3000/TCP                                                                                                                                     42m
istio-citadel            ClusterIP      10.245.135.45    <none>            8060/TCP,15014/TCP                                                                                                                           42m
istio-galley             ClusterIP      10.245.46.245    <none>            443/TCP,15014/TCP,9901/TCP                                                                                                                   42m
istio-ingressgateway        10.245.171.39     15020:30707/TCP,80:31380/TCP,443:31390/TCP,31400:31400/TCP,15029:30285/TCP,15030:31668/TCP,15031:32297/TCP,15032:30853/TCP,15443:30406/TCP   42m
istio-pilot              ClusterIP      10.245.56.97     <none>            15010/TCP,15011/TCP,8080/TCP,15014/TCP                                                                                                       42m
istio-policy             ClusterIP      10.245.206.189   <none>            9091/TCP,15004/TCP,15014/TCP                                                                                                                 42m
istio-sidecar-injector   ClusterIP      10.245.223.99    <none>            443/TCP                                                                                                                                      42m
istio-telemetry          ClusterIP      10.245.5.215     <none>            9091/TCP,15004/TCP,15014/TCP,42422/TCP                                                                                                       42m
prometheus               ClusterIP      10.245.100.132   <none>            9090/TCP                                                                                                                                     42m

Das "+ istio-ingress gateway" sollte der einzige Dienst mit dem "+ TYPE" "+ LoadBalancer" und der einzige Dienst mit einer externen IP sein.

Navigieren Sie in Ihrem Browser zu dieser externen IP: + http: // +.

Sie sollten die folgende Zielseite sehen:

image: https://assets.digitalocean.com/articles/docker_node_image/landing_page.png [Landing Page der Anwendung]

Klicken Sie auf die Schaltfläche * Get Shark Info *. Sie werden eine von zwei Hai-Informationsseiten sehen:

image: https://assets.digitalocean.com/articles/docker_node_image/sharks.png [Hai-Infoseite]

Bild: https://assets.digitalocean.com/articles/istio_canary/scary_sharks.png [Scary Shark Info Page]

Klicken Sie mehrmals auf "Aktualisieren". Sie sollten die Seite mit den Informationen zu freundlicheren Haien öfter sehen als die erschreckendere Version.

Sobald Sie durch fünf- oder sechsmaliges Aktualisieren etwas Last erzeugt haben, können Sie zu Ihren Grafana-Dashboards übergehen.

Navigieren Sie in Ihrem Browser zu der folgenden Adresse, und verwenden Sie dabei erneut die externe IP-Adresse "+ istio-ingressgateway " und den im Grafana Gateway-Manifest definierten Port: " http: // +".

Sie sehen die folgende Zielseite:

image: https://assets.digitalocean.com/articles/istio_install/grafana_home.png [Grafana Home Dash]

Wenn Sie oben auf der Seite auf "Home" klicken, gelangen Sie zu einer Seite mit einem * istio * -Ordner. Um eine Liste der Dropdown-Optionen zu erhalten, klicken Sie auf das Ordnersymbol * istio *:

image: https://assets.digitalocean.com/articles/istio_install/istio_dropdown.png [Dropdown-Menü für Istio Dash-Optionen]

Klicken Sie in dieser Liste von Optionen auf * Istio Service Dashboard *.

Dadurch gelangen Sie zu einer Zielseite mit einem anderen Dropdown-Menü:

image: https://assets.digitalocean.com/articles/istio_install/service_dropdown.png [Service-Dropdown in Istio Service Dash]

Wählen Sie aus der Liste der verfügbaren Optionen "+ nodejs.default.svc.cluster.local +" aus.

Wenn Sie zum Abschnitt * Service Workloads * der Seite navigieren, können Sie * Eingehende Anforderungen nach Ziel und Antwortcode anzeigen *:

image: https://assets.digitalocean.com/articles/istio_canary/service_workloads_dash.png [Dashboards für Service-Workloads]

Hier sehen Sie eine Kombination von 200 und 304 HTTP-Antwortcodes, die erfolgreiche "+ OK" - und "+ Nicht modifizierte" -Antworten anzeigen. Die mit "+ nodejs-v1 " gekennzeichneten Antworten sollten die mit " nodejs-v2 +" gekennzeichneten Antworten übertreffen, was darauf hinweist, dass eingehender Datenverkehr gemäß den in unseren Manifesten definierten Parametern an unsere Anwendungsteilmengen weitergeleitet wird.

Fazit

In diesem Tutorial haben Sie eine kanarische Version einer Demo-Anwendung von Node.js unter Verwendung von Istio und Kubernetes bereitgestellt. Sie haben Ressourcen für virtuelle Dienste und Zielregeln erstellt, mit denen Sie 80% Ihres Datenverkehrs an Ihren ursprünglichen Anwendungsdienst und 20% an die neuere Version senden können. Sobald Sie mit der Leistung der neueren Anwendungsversion zufrieden sind, können Sie Ihre Konfigurationseinstellungen wie gewünscht aktualisieren.

Weitere Informationen zum Verkehrsmanagement in Istio finden Sie in der Dokumentation unter high-level overview sowie in bestimmten Beispielen, die Istios https: // verwenden. istio.io/docs/tasks/traffic-management/traffic-shifting/ [+ bookinfo +] und https://istio.io/blog/2017/0.1-canary/ [+ helloworld +] Beispielanwendungen.

Related