🥇Anwendungsvorbereitung für Istio

Istio ist ein benutzerfreundliches Tool zur Verbindung, Sicherung und Überwachung verteilter Anwendungen. Bei Istio kommen verschiedene Technologien zum Einsatz, um Software in großem Maßstab 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. ohne Istio. Wenn Ihnen diese Tools 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 der Installation der Erweiterung Istio auf GKE.

Dies ist eine schrittweise Anleitung, in der wir den gesamten Prozess vom Quellcode bis zum Container auf GKE durchgehen, damit Sie ein grundlegendes Verständnis dieser Technologien anhand eines Beispiels erhalten. Außerdem werden Sie sehen, wie Istio die Möglichkeiten dieser Technologien nutzt. Es wird davon ausgegangen, dass Sie nichts über Container, Kubernetes, Service Mesh oder Istio wissen.

Aufgaben

In diesem Handbuch werden Sie folgende Aufgaben erledigen:

Erforschung einer einfachen Hello-World-Anwendung mit mehreren Diensten.
Ausführen der Anwendung aus dem Quellcode.
Anwendung in Container verpacken.
Kubernetes-Cluster erstellen.
Container im Cluster bereitstellen.

Bevor Sie beginnen

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

Gehen Sie zur Kubernetes Engine-Seite 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. Das kann einige Minuten dauern.
Stellen Sie sicher, dass die Abrechnung für das Google Cloud Platform-Projekt eingerichtet ist. Erfahren Sie, wie Sie die Abrechnung aktivieren.

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

Option A: Verwendung von Cloud Shell

Vorteile der Nutzung von Cloud Shell:

Entwicklungsumgebungen für Python 2 und Python 3 (einschließlich virtualenv) sind vollständig konfiguriert.
Die Befehlszeilentools gcloud, docker, git und kubectl, die wir verwenden werden, sind bereits installiert.
Sie haben die Wahl zwischen mehreren Texteditoren:
1. Code-Editoren, die über das Bearbeitungssymbol in der oberen Ecke des Cloud Shell-Fensters geöffnet werden.
2. Emacs, Vim oder Nano, die über die Befehlszeile in Cloud Shell geöffnet werden.

Um Cloud Shell zu nutzen:

Gehen Sie zur GCP-Konsole.
Klicken Sie auf die Schaltfläche Aktivieren Sie Cloud Shell. (Aktivieren Sie Cloud Shell) oben im GCP-Konsole Fenster.

Unten im GCP-Konsole ö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 die folgenden Komponenten einrichten und installieren:

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

Herunterladen des Beispielcodes

Laden Sie den Quellcode herunter helloserver:

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

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

Untersuchung der Anwendung mit mehreren Diensten

Das Beispielanwendung 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 sendet an server, mit einer konfigurierbaren Anzahl von Anfragen pro Sekunde.

Starten der Anwendung aus dem Quellcode

Um ein Beispiel für die Anwendung zu erkunden, 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 weiteres Terminalfenster, um Anfragen an

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

der Server antwortet:

4) Von dem Verzeichnis, in das Sie den Beispielcode heruntergeladen haben, wechseln Sie in das Verzeichnis, das

Hallo Welt!

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 Nachricht aus:

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

In einem anderen Terminalfenster

werden ungefähr die folgenden Nachrichten in der Konsole angezeigt: server 127.0.0.1 - - [21/Jun/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/Jun/2019 14:22:01] "GET / HTTP/1.1" 200 -
INFO:root:GET-Anforderung,
Pfad: /
Header:
Host: localhost:8080
User-Agent: python-requests/2.22.0
Accept-Encoding: gzip, deflate
Accept: */*

Aus Sicht des Netzwerks läuft die gesamte Anwendung auf einem Host (lokalem Computer oder virtueller Cloud Shell). Daher können Sie localhost, um Anfragen an server.
10) Um zu stoppen loadgen und server, geben Sie ein Ctrl-c in jedem Terminalfenster.
11) Im Terminalfenster loadgen deaktivieren Sie die virtuelle Umgebung:

deactivate

Das Verpacken der Anwendung in Container

Um die Anwendung auf GKE auszuführen, muss das Beispiel der Anwendung verpackt werden — server und loadgen – dafür braucht man 10-mal weniger Hardware. Container. Ein Container ist eine Möglichkeit, eine Anwendung zu verpacken, um sie von der Umgebung zu isolieren.

Um die Anwendung in einen Container zu verpacken, benötigen Sie Dockerfile. Dockerfile — eine Textdatei, in der die Befehle zum Erstellen des Quellcodes der Anwendung und ihrer Abhängigkeiten in ein Docker-Image definiert sind. Nach dem erstellen laden Sie das Image in ein Container-Registry, wie beispielsweise Docker Hub oder Container Registry.

Im Beispiel sind bereits Dockerfile für server und loadgen mit allen benötigten Befehlen zum Erstellen der Images. Unten — Dockerfile für server:

VON python:3-slim als Basis
VON Basis als Builder
RUN apt-get -qq update 
    && apt-get install -y --no-install-recommends 
        g++ 
    && rm -rf /var/lib/apt/lists/*

# Unbuffered Logging aktivieren
VON Basis als final
ENV PYTHONUNBUFFERED=1

RUN apt-get -qq update 
    && apt-get install -y --no-install-recommends 
        wget

WORKDIR /helloserver

# Pakete vom Builder übernehmen
COPY --from=builder /usr/local/lib/python3.7/ /usr/local/lib/python3.7/

# Anwendung hinzufügen
COPY . .

EXPOSE 8080
ENTRYPOINT [ "python", "server.py" ]

Der Befehl VON python:3-slim als Basis weist Docker an, das neueste Image von Python 3 als Basis zu verwenden.
Der Befehl COPY . . kopiert die Quellcodedateien in das aktuelle Arbeitsverzeichnis (in unserem Fall nur server.py) in das Dateisystem des Containers.
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.
Der Befehl EXPOSE gibt an, dass server Daten über den Port erwartet. 8080. Dieser Befehl stellt keine Ports bereit.Das ist so ähnlich wie eine Dokumentation, die benötigt wird, um den Port 8080 beim Starten des Containers zu öffnen.

Vorbereitung zur Containerisierung der Anwendung

1) Setzen Sie die folgenden Umgebungsvariablen. Ersetzen Sie PROJECT_ID durch die ID Ihres GCP-Projekts.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

Mit den Werten PROJECT_ID und GCR_REPO Sie kennzeichnen das Docker-Image, wenn Sie es erstellen und in das private Container-Registry senden.

2) Legen Sie das Standard-GCP-Projekt für das CLI-Tool fest. gcloud.

gcloud config set project $PROJECT_ID

3) Legen Sie die Standardzone für das CLI-Tool fest. gcloud.

gcloud config set compute/zone us-central1-b

4) Stellen Sie sicher, dass der Container-Registry-Dienst im GCP-Projekt aktiviert ist.

gcloud services enable containerregistry.googleapis.com

Containerisierung des Servers

Navigieren Sie in das Verzeichnis, wo sich das Beispiel befindet. server:
```
cd YOUR_WORKING_DIRECTORY/istio-samples/sample-apps/helloserver/server/
```
Erstellen 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.

Laden Sie das Image in das Container-Registry hoch:

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

Containerisierung des Loadgens

1) Navigieren Sie in das Verzeichnis, wo sich das Beispiel befindet. loadgen:

cd ../loadgen

2) Erstellen Sie das Image:

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

3) Laden Sie das Image in das Container-Registry hoch:

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

Anzeigen der Liste von Images

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

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

Der Befehl gibt die Namen der gerade hochgeladenen Images aus:

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

Erstellung eines GKE-Clusters.

Diese Container könnten auf einer Cloud Shell-VM oder einem lokalen Computer mit dem Befehl gestartet werden. Aber in einer Produktionsumgebung ist ein zentraler Orchestrierungsmechanismus für Container erforderlich. Zum Beispiel benötigt man ein System, das sicherstellt, dass die Container immer laufen, und man benötigt eine Möglichkeit, die Anzahl der Instanzen zu erhöhen und zusätzliche Container zu starten, wenn der Datenverkehr steigt. docker runUm containerisierte Anwendungen auszuführen, kann man

GKE . GKE ist eine Plattform zur Orchestrierung von Containern, 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 zum Interagieren mit dem Cluster.Erstellung eines GKE-Clusters:

1) Erstellen Sie einen Cluster:

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

erstellt einen Cluster namens istioready im angegebenen GCP-Projekt und in der standardmäßigen Zone. Um Istio auszuführen, empfiehlt es sich, mindestens 4 Knoten und eine virtuelle Maschine zu haben.

Der Befehl gcloud erstellt einen Istio-Cluster im GCP-Projekt und in der von Ihnen angegebenen Standardzone. Um Istio zu starten, empfehlen wir mindestens 4 Knoten und eine virtuelle Maschine. n1-standard-2.

Das Team erstellt innerhalb von wenigen Minuten einen Cluster. Sobald der Cluster bereit ist, gibt das Team eine ähnliche Rückmeldung. Mitteilung.

2) Geben Sie die Anmeldeinformationen im Befehlszeilenwerkzeug an, kubectl, um den Cluster zu verwalten:

gcloud container clusters get-credentials istioready

3) Jetzt können Sie mit Kubernetes über kubectlkommunizieren. Mit dem folgenden Befehl können Sie beispielsweise den Status der Knoten überprüfen:

kubectl get nodes

Der Befehl gibt eine Liste von Knoten aus:

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

Schlüsselkonzepte von Kubernetes

Das Diagramm zeigt eine Anwendung auf GKE:

Bevor Sie Container in GKE bereitstellen, sollten Sie die grundlegenden Konzepte von Kubernetes verstehen. 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 werden, und in dem Sie containerisierte Anwendungen bereitstellen.
Pods. In Kubernetes werden Container in Pods gestartet. Ein Pod in Kubernetes ist eine unteilbare Einheit. Ein Pod fasst einen oder mehrere Container zusammen. Sie deployen Container und loadgen in separaten Pods. Wenn ein Pod mehrere Container enthält (zum Beispiel einen Anwendungsserver und Proxy-Server), werden die Container als ein einziges Objekt verwaltet und nutzen gemeinsam die Ressourcen des Pods.
Deployments. In Kubernetes ist ein Deployment ein Objekt, das aus einer Gruppe identischer Pods besteht. Ein Deployment startet mehrere Replikate von Pods, die über die Knoten des Clusters verteilt sind. Deployment ersetzt automatisch Pods, die ausgefallen sind oder nicht antworten.
Kubernetes-Service. Wenn Sie Anwendungs-Code in GKE ausführen, ändert sich die Verbindung zwischen loadgen und server. Nachdem Sie Dienste auf einer Cloud Shell-VM oder Ihrem Computer gestartet haben, haben Sie Anfragen an server an 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 ausgeführt wird, sodass es Pods keine festen IP-Adressen hat.
Um eine IP-Adresse für serverzu erhalten, müssen Sie eine Netzwerkabstraktion über den Pods definieren. Das ist der Kubernetes-Service. Der Kubernetes-Service bietet einen permanenten Endpunkt für eine Gruppe von Pods. Es gibt verschiedene Typen von Services. server nutzt LoadBalancer, der eine externe IP-Adresse bereitstellt, um mit server außerhalb des Clusters zu kommunizieren.
Kubernetes verfügt außerdem über ein integriertes DNS-System, das DNS-Namen (z.B. helloserver.default.cluster.local) für Services zuweist. Dadurch können Pods innerhalb des Clusters mit anderen Pods im Cluster über eine feste Adresse kommunizieren. Der DNS-Name kann außerhalb des Clusters nicht verwendet werden, zum Beispiel in Cloud Shell oder auf einem Computer.

Kubernetes Manifeste

Als Sie die Anwendung aus dem Quellcode starteten, verwendeten Sie einen imperativen Befehl python3

server.py

. Imperativ bedeutet: "Tu das".

Kubernetes nutzt 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, um sicherzustellen, dass der tatsächliche Zustand des Systems dem gewünschten entspricht.

Den gewünschten Zustand geben Sie in den Manifesten, oder Dateien, an. YAMLEine YAML-Datei enthält Spezifikationen für ein oder mehrere Kubernetes-Objekte.

Im Beispiel enthält es eine YAML-Datei für server und loadgen. Jede YAML-Datei gibt den gewünschten Zustand des Bereitstellungsobjekts und des Kubernetes-Dienstes 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 Objekttyp an.
metadata.name gibt den Namen der Bereitstellung an.
Das erste Feld spec enthält die Beschreibung des gewünschten Zustands.
spec.replicas gibt die gewünschte Anzahl von Pods an.
Abschnitt spec.template definiert die Vorlagen für den Pod. In der Pod-Spezifikation gibt es ein Feld image, in dem der Name des Images angegeben wird, das aus dem Container-Registry abgerufen werden soll.

Der Dienst 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: Kunden senden Anfragen an die IP-Adresse des Load Balancers, der eine feste IP-Adresse hat und von außerhalb des Clusters erreichbar ist.
targetPort: Wie Sie sich erinnern, hat der Befehl EXPOSE 8080 in Dockerfile keine Ports bereitgestellt. Sie geben den Port an 8080, um mit dem Container server außerhalb des Clusters zu kommunizieren. In unserem Fall hellosvc.default.cluster.local:80 (kurzname: 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. Dieser definiert die Umgebungsvariablen, die benötigt werden loadgen und die Sie beim Starten 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 entgegen, für das Feld type ist angegeben ClusterIP. Dieser Typ stellt eine permanente IP-Adresse zur Verfügung, die von Diensten im Cluster verwendet werden kann, jedoch wird diese IP-Adresse nicht externen Clients bereitgestellt.

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) Navigieren Sie in das Verzeichnis, wo sich das Beispiel befindet. server:

cd YOUR_WORKING_DIRECTORY/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 PROJECT_ID durch die ID Ihres GCP-Projekts.
4) Speichern und schließen Sie server.yaml.
5) Wenden Sie die YAML-Datei in Kubernetes an:

kubectl apply -f server.yaml

Nach erfolgreichem Abschluss gibt der Befehl den folgenden Code aus:

deployment.apps/helloserver erstellt
service/hellosvc erstellt

6) Wechseln Sie in das Verzeichnis, in dem 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 PROJECT_ID durch die ID Ihres GCP-Projekts.
9) Speichern und schließen Sie loadgen.yaml, schließen Sie den Texteditor.
10) Wenden Sie die YAML-Datei in Kubernetes an:

kubectl apply -f loadgen.yaml

Nach erfolgreichem Abschluss gibt der Befehl den folgenden Code aus:

deployment.apps/loadgenerator erstellt
service/loadgensvc erstellt

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 aus dem Pod loadgen. Ersetzen Sie POD_ID durch die ID aus der vorherigen Antwort.

kubectl logs loadgenerator-POD_ID

13) Holen Sie sich die externen IP-Adressen hellosvc:

kubectl get service

Die Ausgabe 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

Lassen Sie uns mit Istio beginnen.

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

Wie interagieren die Dienste? Welche Beziehungen bestehen zwischen den Diensten? Wie läuft der Datenverkehr zwischen den Diensten? Sie wissen, dass loadgen Anfragen an serversendet, aber stellen Sie sich vor, dass Sie nichts über die Anwendung wissen. Um diese Fragen zu beantworten, betrachten wir die Liste der laufenden Pods in GKE.
Metriken. Wie lange server reagiert auf eingehende Anfragen? Wie viele Anfragen pro Sekunde trifft der Server? Gibt er Fehlermeldungen aus?
Sicherheitsinformationen. Der Datenverkehr zwischen loadgen und server verläuft einfach über HTTP oder über mTLS?

Auf all diese Fragen gibt Istio Antworten. Dafür platziert Istio einen Sidecar-Proxy Envoy in jeden Pod. Der Envoy-Proxy fängt den gesamten eingehenden und ausgehenden Datenverkehr zu den Anwendungscontainern ab. Das bedeutet, dass server und loadgen über den Sidecar-Proxy Envoy empfangen werden, und der gesamte Datenverkehr von loadgen zu server verläuft über den Proxy Envoy.

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

Sobald der Envoy-Proxy in seinen Containern läuft, kann Istio fast ohne Änderungen am Anwendungscode über das GKE-Cluster installiert werden. Sie haben jedoch einige Vorbereitungen getroffen, um die Anwendung für das Management mit Istio vorzubereiten.

Dienste für alle Container. Zu den Deployments server und loadgen ist ein Kubernetes-Service zugeordnet. Sogar ein loadgen, der keine eingehenden Anfragen erhält, hat einen Dienst.
Ports in den Diensten müssen benannt sein. Obwohl in GKE Dienstports ohne Namen belassen werden können, erfordert Istio die Angabe von Portnamen gemäß seinem Protokoll. In der YAML-Datei ist der Port für server nannte http, da der Server das Protokoll verwendet HTTP. Hätte service verwendet gRPC, würden Sie den Port grpc.
Kennzeichnungen für Deployments. Deshalb können Sie Istio-Traffic-Management-Funktionen verwenden, um denTraffic zwischen Versionen eines Dienstes zu verteilen.

Istio-Installation

Istio kann auf zwei Arten installiert werden. Man kann die Istioerweiterung in GKE aktivieren oder die Open-Source-Version von Istio installieren Mit Istio auf GKE können Sie die Installation und das Upgrade von Istio im Lebenszyklus des GKE-Clusters ganz einfach verwalten. Wenn Sie die neueste Version von Istio benötigen oder mehr Kontrolle über die Konfiguration des Istio-Dashboards wollen, installieren Sie die Open-Source-Version anstelle der Istio-Erweiterung auf GKE. Lesen Sie den Artikel, um zu entscheiden, welcher Ansatz am besten geeignet ist. Brauche ich Istio auf GKE?.

Wählen Sie Ihre Option, studieren Sie das entsprechende Handbuch und folgen Sie den Anweisungen, um Istio in Ihrem 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 zu vermeiden, dass Kosten für die in diesem Handbuch verwendeten Ressourcen von Ihrem Google Cloud Platform-Konto abgebucht werden, löschen Sie den Container-Cluster, nachdem Sie Istio installiert und mit dem Beispielanwendung gespielt haben. Dies entfernt alle Ressourcen des Clusters, wie Recheninstanzen, Festplatten und Netzwerkressourcen.