🥇Anwendung für Istio vorbereiten

Istio ist ein praktisches Werkzeug zur Verbindung, Sicherung und Überwachung verteilter Anwendungen. In Istio werden verschiedene Technologien verwendet, um Software skalierbar bereitzustellen und zu verwalten, einschließlich Container zur Verpackung des Anwendungscodes und seiner Abhängigkeiten für die Bereitstellung sowie Kubernetes zur Verwaltung dieser Container. Daher sollten Sie wissen, wie eine Anwendung mit mehreren Diensten, die auf diesen Technologien basiert, funktioniert, um mit Istio zu arbeiten. ohne Istio. Wenn Ihnen diese Werkzeuge und Konzepte bereits vertraut sind, können Sie dieses Handbuch überspringen und direkt zum Abschnitt übergehen. Installation von Istio auf Google Kubernetes Engine (GKE) oder die Erweiterung installieren Istio auf GKE.

Dies ist eine schrittweise Anleitung, in der wir den gesamten Prozess von dem Quellcode bis hin zu Containern auf GKE behandeln, damit Sie eine grundlegende Vorstellung von diesen Technologien bekommen. Auch werden Sie sehen, wie Istio die Möglichkeiten dieser Technologien nutzt. Es wird vorausgesetzt, dass Ihnen Container, Kubernetes, Service Mesh oder Istio unbekannt sind.

Aufgaben

In diesem Handbuch werden Sie die folgenden Aufgaben durchführen:

Ein einfaches Hello World-Anwendung mit mehreren Diensten erkunden.
Die Anwendung aus dem Quellcode starten.
Die Anwendung in Container verpacken.
Ein Kubernetes-Cluster erstellen.
Container in das Cluster bereitstellen.

Bevor Sie beginnen

Befolgen Sie die Anweisungen, um die Kubernetes Engine API zu aktivieren:

Gehen Sie auf die Seite Kubernetes Engine in der Google Cloud Platform Konsole.
Erstellen oder wählen Sie ein Projekt aus.
Warten Sie, bis die API und die zugehörigen Dienste aktiviert sind. Dies kann einige Minuten in Anspruch nehmen.
Stellen Sie sicher, dass für das Projekt Google Cloud Platform die Abrechnung aktiviert ist. Erfahren Sie, wie Sie die Abrechnung aktivieren können.

In diesem Handbuch können Sie die Cloud Shell verwenden, die eine virtuelle Maschine g1-small in Google Compute Engine mit Debian-basiertem Linux oder einen Linux- oder macOS-Computer bereitstellt.

Option A: Verwendung von Cloud Shell

Vorteile der Verwendung von Cloud Shell:

Die Python 2 und Python 3 Entwicklungsumgebungen (einschließlich virtualenv) sind vollständig eingerichtet.
Befehlszeilenwerkzeuge gcloud, docker, git und kubectl, die wir verwenden werden, sind bereits installiert.
Sie haben die Wahl zwischen mehreren Texteditoren:
1. Der Code-Editor, der durch das Bearbeitungssymbol oben im Cloud Shell Fenster geöffnet wird.
2. Emacs, Vim oder Nano, die aus der Befehlszeile in Cloud Shell geöffnet werden.

Um Cloud Shell:

zu verwenden,
Klicken Sie auf die Schaltfläche gehen Sie zur GCP-Konsole. (Cloud Shell aktivieren) oben im GCP-Konsolenfenster.

Unten im GCP-Konsolenfenster öffnet sich in einem neuen Fenster eine Cloud Shell-Sitzung mit der Eingabeaufforderung.

Option B: Verwendung von Befehlszeilenwerkzeugen lokal

Wenn Sie auf einem Computer mit Linux oder macOS arbeiten, müssen Sie folgende Komponenten einrichten und installieren:

Konfigurieren Sie Python 3- und Python 2-Entwicklungsumgebung.
Cloud SDK installieren mit dem Befehlszeilenwerkzeug gcloud.
Installieren Sie kubectl — Befehlszeilenwerkzeug zur Arbeit mit Kubernetes.
```
gcloud components install kubectl
```
Installieren Sie Docker Community Edition (CE). Sie verwenden das Befehlszeilenwerkzeug docker, um Container-Images für das Beispielanwendungsprojekt zu erstellen.
Installieren Sie das Werkzeug Versionskontrollsystem Git, um das Beispielprojekt von GitHub zu erhalten.

Codebeispiel herunterladen

Laden Sie den Quellcode herunter helloserver:

git clone https://github.com/GoogleCloudPlatform/istio-samples

Wechseln Sie in das Verzeichnis des Codebeispiels:
```
cd istio-samples/sample-apps/helloserver
```

Untersuchung einer Anwendung mit mehreren Diensten

Das Beispielanwendungsprojekt ist in Python geschrieben und besteht aus zwei Komponenten, die über REST:

server: einen einfachen Server mit einem Endpunkt GET, /, der "hello world" in der Konsole ausgibt.
loadgen: ein Skript, das Verkehr an server, mit einer konfigurierbaren Anzahl von Anfragen pro Sekunde, sendet.

Anwendung aus dem Quellcode starten

Um das Beispielprojekt zu untersuchen, führen Sie es in der Cloud Shell oder auf Ihrem Computer aus.
1) Im Verzeichnis istio-samples/sample-apps/helloserver führen Sie aus server:

python3 server/server.py

Beim Start wird Folgendes angezeigt: server INFO:root:Server wird gestartet...

2) Öffnen Sie ein anderes Terminalfenster, um Anfragen an

zu senden. Wenn Sie die Cloud Shell verwenden, klicken Sie auf das Plus-Symbol, um eine andere Sitzung zu öffnen. server3) Senden Sie eine Anfrage an
curl http://localhost:8080 server:

der Server antwortet mit:

Hallo Welt!

4) Wechseln Sie in das Verzeichnis, in das Sie das Beispielprojekt heruntergeladen haben:

cd YOUR_WORKING_DIRECTORY/istio-samples/sample-apps/helloserver/loadgen loadgen:

5) Erstellen Sie die folgenden Umgebungsvariablen:

export SERVER_ADDR=http://localhost:8080 export REQUESTS_PER_SECOND=5

6) Starten Sie

virtualenv --python python3 env virtualenv:

7) Aktivieren Sie die virtuelle Umgebung:

source env/bin/activate

8) Installieren Sie die Anforderungen für

pip3 install -r requirements.txt loadgen:

9) Führen Sie aus

python3 loadgen.py loadgen:

gibt ungefähr die folgende Ausgabe aus:

Beim Start wird Folgendes angezeigt: loadgen Starte loadgen: 2019-05-20 10:44:12.448415 5 Anfrage(n) abgeschlossen an http://localhost:8080

In einem anderen Terminalfenster

gibt ungefähr die folgenden Nachrichten auf der Konsole aus: server 127.0.0.1 - - [21/Juni/2019 14:22:01] "GET / HTTP/1.1" 200 - INFO:root:GET-Anfrage, Pfad: / Header: Host: localhost:8080 User-Agent: python-requests/2.22.0 Accept-Encoding: gzip, deflate Accept: */*

127.0.0.1 - - [21/Juni/2019 14:22:01] "GET / HTTP/1.1" 200 -\nINFO:root:GET-Anfrage,\nPfad: /\nHeader:\nHost: localhost:8080\nUser-Agent: python-requests/2.22.0\nAccept-Encoding: gzip, deflate\nAccept: */*

Aus Sicht des Netzwerks funktioniert die gesamte Anwendung auf einem einzigen Host (lokalen Computer oder virtueller Cloud Shell-Maschine). Daher kann man verwenden localhost, um Anfragen an server.
10) Um zu stoppen loadgen und server, geben Sie ein Ctrl-c in jedem Terminalfenster.
11) Deaktivieren Sie die virtuelle Umgebung im Terminalfenster: loadgen deactivate

Verpacken der Anwendung in Container

Um die Anwendung auf GKE zu starten, müssen Sie das Beispiel der Anwendung verpacken —

Container server und loadgen — bei . Ein Container ist eine Möglichkeit, die Anwendung zu verpacken, um sie von der Umgebung zu isolieren.Um die Anwendung in einem Container zu verpacken, benötigen Sie

eine Textdatei, die die Befehle zur Erstellung des Quellcodes der Anwendung und ihrer Abhängigkeiten in Dockerfile. Dockerfile ein Docker-Image definiert. Nach dem Erstellen laden Sie das Image in ein Container-Registry, beispielsweise Docker Hub oder Container Registry. Im Beispiel sind bereits.

alle notwendigen Befehle vorhanden, um Bilder zu erstellen. Unten ist Dockerfile für server und loadgen FROM python:3-slim as base FROM base as builder RUN apt-get -qq update && apt-get install -y --no-install-recommends g++ && rm -rf /var/lib/apt/lists/*# Aktivieren Sie unpuffertes Logging FROM base as final ENV PYTHONUNBUFFERED=1RUN apt-get -qq update && apt-get install -y --no-install-recommends wgetWORKDIR /helloserver# Holen Sie Pakete vom Builder COPY --from=builder /usr/local/lib/python3.7/ /usr/local/lib/python3.7/# Fügen Sie die Anwendung hinzu COPY . .EXPOSE 8080 ENTRYPOINT [ "python", "server.py" ] Dockerfile für server:

FROM python:3-slim as base

Team lädt Docker das neueste Image von Python 3 als Basis. COPY . .
Team kopiert die Quelldateien in das aktuelle Arbeitsverzeichnis (in unserem Fall nur ) in das Dateisystem des Containers. server.py.
ENTRYPOINT definiert den Befehl, der verwendet wird, um den Container zu starten. In unserem Fall entspricht dieser Befehl fast dem, den Sie zum Starten verwendet haben server.py aus dem Quellcode.
Team EXPOSE gibt an, dass server Daten über den Port 8080erwartet werden. Dieser Befehlstellt keine Ports bereit. 8080 Es ist eine Art Dokumentation, die benötigt wird, um den Port

beim Starten des Containers zu öffnen.

Vorbereitung zur Containerisierung der Anwendung 1) Stellen Sie die folgenden Umgebungsvariablen ein. Ersetzen Sie PROJECT_ID

durch die ID Ihres GCP-Projekts.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio" 1) Stellen Sie die folgenden Umgebungsvariablen ein. Ersetzen Sie und Mit den Werten GCR_REPO

markieren Sie das Docker-Image, wenn Sie es erstellen und in das private Container Registry hochladen. gcloud.

2) Setzen Sie das Standardprojekt für das Befehlszeilentool

gcloud config set project $PROJECT_ID gcloud.

3) Setzen Sie die Standardzone für das Befehlszeilentool

gcloud config set compute/zone us-central1-b

gcloud Dienste aktivieren containerregistry.googleapis.com

Containerisierung server

Wechseln Sie in das Verzeichnis, in dem sich das Beispiel befindet server:
```
cd IHR_ARBEITSVERZEICHNIS/istio-samples/sample-apps/helloserver/server/
```
Bauen Sie das Image mit Dockerfile und den Umgebungsvariablen, die Sie zuvor definiert haben:
```
docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1 .
```

Parameter -t stellt das Docker-Tag dar. Dies ist der Name des Images, das Sie beim Bereitstellen des Containers verwenden.

Übertragen Sie das Image in das Container-Registry:

docker push gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1

Containerisierung loadgen

1) Wechseln Sie in das Verzeichnis, in dem sich das Beispiel befindet loadgen:

cd ../loadgen

2) Bauen Sie das Image:

docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/loadgen:v0.0.1 .

3) Übertragen Sie das Image in das Container-Registry:

docker push gcr.io/$PROJECT_ID/$GCR_REPO/loadgen:v0.0.1

Anzeigen der Liste der Images

Überprüfen Sie die Liste der Images im Repository und stellen Sie sicher, dass die Images übertragen wurden:

gcloud container images list --repository gcr.io/$PROJECT_ID/preparing-istio

Der Befehl gibt die Namen der gerade übertragenen Images aus:

NAME
gcr.io/PROJECT_ID/preparing-istio/helloserver
gcr.io/PROJECT_ID/preparing-istio/loadgen

Erstellen eines GKE-Clusters.

Diese Container könnten auf einer Cloud Shell-VM oder lokal mit dem Befehl docker run. Aber in einer Produktionsumgebung benötigt man eine Möglichkeit, Container zentral zu orchestrieren. Beispielsweise wird ein System benötigt, das sicherstellt, dass Container immer laufen, und es muss auch eine Möglichkeit geben, die Skalierung zu erhöhen und zusätzliche Instanzen von Containern zu starten, wenn der Datenverkehr zunimmt.

Um containerisierte Anwendungen auszuführen, können Sie GKEverwenden. GKE ist eine Container-Orchestrierungsplattform, die virtuelle Maschinen in einem Cluster vereint. Jede virtuelle Maschine wird als Knoten bezeichnet. GKE-Cluster basieren auf dem Open-Source-Cluster-Management-System Kubernetes. Kubernetes bietet Mechanismen zur Interaktion mit dem Cluster.

Cluster erstellen in GKE:

1) Erstellen Sie einen Cluster:

gcloud container clusters create istioready 
  --cluster-version latest 
  --machine-type=n1-standard-2 
  --num-nodes 4

Team gcloud erstellt den Cluster istioready in dem von Ihnen angegebenen GCP-Projekt und der Standardzone. Um Istio auszuführen, wird empfohlen, mindestens 4 Knoten und eine virtuelle Maschine zu haben. n1-standard-2.

Der Befehl erstellt den Cluster innerhalb weniger Minuten. Sobald der Cluster bereit ist, gibt der Befehl etwas Ähnliches aus Nachricht.

2) Geben Sie die Anmeldeinformationen im CLI-Tool an, kubectlum den Cluster zu verwalten:

gcloud container clusters get-credentials istioready

3) Jetzt können Sie mit Kubernetes über kubectlkommunizieren. Zum Beispiel kann der folgende Befehl den Status der Knoten abrufen:

kubectl get nodes

Der Befehl gibt eine Liste der Knoten aus:

NAME                                       STATUS   ROLES    AGE    VERSION
gke-istoready-default-pool-dbeb23dc-1vg0   Bereit       99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-36z5   Bereit       100s   v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-fj7s   Bereit       99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-wbjw   Bereit       99s    v1.13.6-gke.13

Schlüsselbegriffe in Kubernetes

Das Diagramm zeigt eine Anwendung auf GKE:

Bevor Sie Container in GKE bereitstellen, sollten Sie sich mit den Schlüsselbegriffen von Kubernetes vertraut machen. Am Ende finden Sie Links, wenn Sie mehr erfahren möchten.

Knoten und Cluster. In GKE ist ein Knoten eine virtuelle Maschine. Auf anderen Kubernetes-Plattformen kann ein Knoten ein Computer oder eine virtuelle Maschine sein. Ein Cluster ist eine Gruppe von Knoten, die als Einheit betrachtet wird, in der Sie containerisierte Anwendungen bereitstellen.
Pods. In Kubernetes werden Container in Pods ausgeführt. Ein Pod in Kubernetes ist eine unteilbare Einheit. Ein Pod fasst einen oder mehrere Container zusammen. Sie stellen die Container server und loadgen in separaten Pods bereit. Wenn ein Pod mehrere Container hat (zum Beispiel einen Anwendungsserver und Proxy-Server), werden die Container als ein einzelnes Objekt verwaltet und teilen sich die Ressourcen des Pods.
Bereitstellungen. In Kubernetes ist eine Bereitstellung ein Objekt, das eine Gruppe von identischen Pods darstellt. Die Bereitstellung startet mehrere Replikate von Pods, die auf den Knoten des Clusters verteilt sind. Die Bereitstellung ersetzt automatisch Pods, die ausgefallen sind oder nicht reagieren.
Kubernetes-Service. Wenn Ihr Anwendungs-Code in GKE ausgeführt wird, ändert sich die Verbindung zwischen loadgen und server. Wenn Sie Dienste auf einer Cloud Shell-VM oder einem Computer gestartet haben, haben Sie Anfragen an server die Adresse localhost:8080. Nach der Bereitstellung in GKE werden Pods auf verfügbaren Knoten ausgeführt. Standardmäßig können Sie nicht steuern, auf welchem Knoten ein Pod bereitgestellt wird, daher haben Pods keine festen IP-Adressen.
Um eine IP-Adresse für serverzu erhalten, müssen Sie eine Netzwerkabstraktion über Pods definieren. Das ist der Kubernetes-Service. Der Kubernetes-Service bietet einen dauerhaften Endpunkt für eine Gruppe von Pods. Es gibt mehrere Servicetypen. server verwendet LoadBalancer, die eine externe IP-Adresse bereitstellen, um von server außerhalb des Clusters zu kommunizieren.
Kubernetes verfügt auch über ein integriertes DNS-System, das DNS-Namen zuweist (zum Beispiel helloserver.default.cluster.local) Dienstleistungen. Dank dessen verbinden sich Pods innerhalb des Clusters mit anderen Pods im Cluster über eine feste Adresse. Der DNS-Name kann außerhalb des Clusters nicht verwendet werden, z. B. in Cloud Shell oder auf einem Computer.

Kubernetes-Manifeste

Als Sie die Anwendung aus dem Quellcode gestartet haben, haben Sie einen imperativen Befehl verwendet python3

server.py

Imperativität impliziert ein Verb: „Tu das“.

Kubernetes verwendet ein deklaratives Modell. Das bedeutet, dass wir Kubernetes nicht sagen, was genau zu tun ist, sondern den gewünschten Zustand beschreiben. Zum Beispiel startet und stoppt Kubernetes Pods nach Bedarf, damit der tatsächliche Zustand des Systems dem gewünschten entspricht.

Den gewünschten Zustand geben Sie in den Manifeste oder Dateien an YAML. Die YAML-Datei enthält Spezifikationen für eines oder mehrere Kubernetes-Objekte.

Das Beispiel enthält eine YAML-Datei für server und loadgen. Jede YAML-Datei gibt den gewünschten Zustand des Bereitstellungs- und Serviceobjekts in Kubernetes an.

server.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: helloserver
spec:
  selector:
    matchLabels:
      app: helloserver
  replicas: 1
  template:
    metadata:
      labels:
        app: helloserver
    spec:
      terminationGracePeriodSeconds: 5
      restartPolicy: Always
      containers:
      - name: main
        image: gcr.io/google-samples/istio/helloserver:v0.0.1
        imagePullPolicy: Always

kind gibt den Typ des Objekts an.
. Das liegt daran, dass der Name des Pods im untergeordneten Feld name des Feldes definiert ist gibt den Namen der Bereitstellung an.
Das erste Feld spec enthält eine Beschreibung des gewünschten Zustands.
spec.replicas gibt die gewünschte Anzahl von Pods an.
Abschnitt spec.template definiert die Vorlage des Pods. In der Podspezifikation gibt es ein Feld Image, in dem der Name des Images angegeben wird, das aus dem Container-Registry abgerufen werden soll.

Der Service wird wie folgt definiert:

apiVersion: v1
kind: Service
metadata:
  name: hellosvc
spec:
  type: LoadBalancer
  selector:
    app: helloserver
  ports:
  - name: http
    port: 80
    targetPort: 8080

LoadBalancer: Die Clients senden Anfragen an die IP-Adresse des Lastenausgleichs, der eine feste IP-Adresse hat und von außerhalb des Clusters erreichbar ist.
targetPort: Wie Sie sich erinnern, gab der Befehl EXPOSE 8080 in Dockerfile keine Ports an. Sie geben den Port an 8080, damit eine Verbindung zum Container hergestellt werden kann server von außerhalb des Clusters. In unserem Fall hellosvc.default.cluster.local:80 (kurzer Name: hellosvc) entspricht dem Port 8080 IP-Adresse des Pods helloserver.
port: Dies ist die Portnummer, an die andere Dienste im Cluster Anfragen senden werden.

loadgen.yaml

Das Bereitstellungsobjekt in loadgen.yaml ähnelt server.yaml. Der Unterschied besteht darin, dass das Bereitstellungsobjekt einen Abschnitt enthält env. Er definiert die erforderlichen Umgebungsvariablen loadgen und die Sie bei der Installation der Anwendung aus dem Quellcode festgelegt haben.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: loadgenerator
spec:
  selector:
    matchLabels:
      app: loadgenerator
  replicas: 1
  template:
    metadata:
      labels:
        app: loadgenerator
    spec:
      terminationGracePeriodSeconds: 5
      restartPolicy: Always
      containers:
      - name: main
        image: gcr.io/google-samples/istio/loadgen:v0.0.1
        imagePullPolicy: Always
        env:
        - name: SERVER_ADDR
          value: "http://hellosvc:80/"
        - name: REQUESTS_PER_SECOND
          value: "10"
        resources:
          requests:
            cpu: 300m
            memory: 256Mi
          limits:
            cpu: 500m
            memory: 512Mi

Eins loadgen nimmt keine eingehenden Anfragen an, für das Feld type angegeben ClusterIP. Diese Art bietet eine dauerhafte IP-Adresse, die von den Diensten im Cluster verwendet werden kann, aber diese IP-Adresse wird externen Clients nicht zur Verfügung gestellt.

apiVersion: v1
kind: Service
metadata:
  name: loadgensvc
spec:
  type: ClusterIP
  selector:
    app: loadgenerator
  ports:
  - name: http
    port: 80
    targetPort: 8080

Bereitstellung von Containern in GKE

1) Wechseln Sie in das Verzeichnis, in dem sich das Beispiel befindet server:

cd IHR_ARBEITSVERZEICHNIS/istio-samples/sample-apps/helloserver/server/

2) Öffnen Sie server.yaml in einem Texteditor.
3) Ersetzen Sie den Namen im Feld Image durch den Namen Ihres Docker-Images.

image: gcr.io/PROJECT_ID/preparing-istio/helloserver:v0.0.1

Ersetzen Sie 1) Stellen Sie die folgenden Umgebungsvariablen ein. Ersetzen Sie durch die ID Ihres GCP-Projekts.
4) Speichern Sie und schließen Sie server.yaml.
5) Bereitstellen der YAML-Datei in Kubernetes:

kubectl apply -f server.yaml

Nach erfolgreichem Abschluss gibt der Befehl den folgenden Code aus:

deployment.apps/helloserver created
service/hellosvc created

6) Wechseln Sie in das Verzeichnis, wo sich loadgen:

cd ../loadgen

7) Öffnen Sie loadgen.yaml in einem Texteditor.
8) Ersetzen Sie den Namen im Feld Image durch den Namen Ihres Docker-Images.

image: gcr.io/PROJECT_ID/preparing-istio/loadgenv0.0.1

Ersetzen Sie 1) Stellen Sie die folgenden Umgebungsvariablen ein. Ersetzen Sie durch die ID Ihres GCP-Projekts.
9) Speichern Sie und schließen Sie loadgen.yaml, schließen Sie den Texteditor.
10) Bereitstellen der YAML-Datei in Kubernetes:

kubectl apply -f loadgen.yaml

Nach erfolgreichem Abschluss gibt der Befehl den folgenden Code aus:

deployment.apps/loadgenerator created
service/loadgensvc created

11) Überprüfen Sie den Status der Pods:

kubectl get pods

Der Befehl zeigt den Status an:

NAME                             READY   STATUS    RESTARTS   AGE
helloserver-69b9576d96-mwtcj     1/1     Running   0          58s
loadgenerator-774dbc46fb-gpbrz   1/1     Running   0          57s

12) Extrahieren Sie die Anwendungsprotokolle vom Pod loadgen. Ersetzen Sie POD_ID durch die ID aus der vorherigen Antwort.

kubectl logs loadgenerator-POD_ID

13) Erhalten Sie die externen IP-Adressen hellosvc:

kubectl get service

Die Antwort des Befehls sieht ungefähr so aus:

NAME         TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
hellosvc     LoadBalancer   10.81.15.158   192.0.2.1       80:31127/TCP   33m
kubernetes   ClusterIP      10.81.0.1                443/TCP        93m
loadgensvc   ClusterIP      10.81.15.155             80/TCP         4m52s

14) Senden Sie eine Anfrage an hellosvc: ersetzen Sie EXTERNAL_IP durch die externe IP-Adresse hellosvc.

curl http://EXTERNAL_IP

Kümmern wir uns um Istio

Sie haben bereits eine Anwendung, die in GKE bereitgestellt ist. loadgen kann Kubernetes DNS verwenden (hellosvc:80), um Anfragen an serverzu senden, und Sie können Anfragen an server über die externe IP-Adresse. Obwohl Kubernetes viele Möglichkeiten bietet, fehlt es an Informationen über die Dienste:

Wie interagieren die Dienste? Welche Beziehungen bestehen zwischen den Diensten? Wie fließt der Traffic zwischen den Diensten? Sie wissen, dass loadgen Anfragen an server, aber stellen Sie sich vor, dass Sie nichts über die Anwendung wissen. Um diese Fragen zu beantworten, schauen wir uns die Liste der laufenden Pods in GKE an.
Metriken. Wie lange server antwortet auf eingehende Anfragen? Wie viele Anfragen pro Sekunde kommen auf den Server? Gibt es Fehlermeldungen?
Sicherheitsinformationen. Der Traffic zwischen loadgen und server verläuft einfach über HTTP oder über mTLS?

Auf all diese Fragen antwortet Istio. Dafür platziert Istio einen Sidecar-Proxy Envoy in jeden Pod. Der Envoy-Proxy überwacht den gesamten eingehenden und ausgehenden Verkehr zu den Anwendungscontainern. Das bedeutet, dass server und loadgen über den Sidecar-Proxy Envoy empfangen werden, und der gesamte Traffic von loadgen zu server läuft über den Envoy-Proxy.

Die Verbindungen zwischen den Envoy-Proxys bilden ein Service-Mesh. Die Architektur des Service-Mesh bietet eine Kontrollschicht über Kubernetes.

Da der Envoy-Proxy in seinen Containern läuft, kann Istio über den GKE-Cluster installiert werden, ohne den Anwendungscode stark zu ändern. Aber Sie haben einige Arbeiten geleistet, um die Anwendung für die Verwaltung mit Istio vorzubereiten:

Dienste für alle Container. Jedes Deployment server und loadgen hat einen Kubernetes-Dienst. Sogar der loadgen, der keine eingehenden Anfragen erhält, hat einen Dienst.
Die Ports in den Diensten müssen benannt werden. Obwohl in GKE die Ports der Dienste unbenannt bleiben können, verlangt Istio, dass der Portname entsprechend seinem Protokoll angegeben wird. In der YAML-Datei wird der Port für server genannt, da der Server das Protokoll verwendet http. Wenn HTTPwürde service gRPC , würden Sie den Portgrpc benennen. Deployments werden markiert. Daher können Sie die Traffic-Management-Funktionen von Istio nutzen, um den Verkehr zwischen den Versionen eines Dienstes zu teilen..
Istio-Installation

Istio kann auf zwei Arten installiert werden. Sie können

die Istio-Erweiterung in GKE aktivieren die Open-Source-Version von Istio oder im Cluster installieren. Mit Istio in GKE können Sie die Installation und das Upgrade von Istio im Lebenszyklus des GKE-Clusters einfach verwalten. Wenn Sie die neueste Version von Istio oder mehr Kontrolle über die Konfiguration des Istio-Dashboards benötigen, installieren Sie die Open-Source-Version anstelle der Istio-Erweiterung in GKE. Um zu entscheiden, welchen Ansatz Sie wählen sollten, lesen Sie den Artikel Brauche ich Istio in GKE? Brauche ich Istio auf GKE?.

Wählen Sie eine Option, studieren Sie das entsprechende Handbuch und folgen Sie den Anweisungen, um Istio in dem Cluster zu installieren. Wenn Sie Istio mit einer gerade bereitgestellten Anwendung verwenden möchten, aktivieren Sie das Sidecar-Deployment für den Namespace default.

Bereinigung

Um Gebühren für die Ressourcen, die Sie in diesem Handbuch verwendet haben, nicht von Ihrem Google Cloud Platform-Konto abgezogen zu bekommen, löschen Sie den Container-Cluster, sobald Sie Istio installiert haben und mit dem Beispielantrag gespielt haben. Dabei werden alle Cluster-Ressourcen wie Recheninstanzen, Festplatten und Netzwerkressourcen gelöscht.