🥇Vorbereitung einer Bewerbung für Istio

Istio ist ein komfortables Tool zum Verbinden, Sichern und Überwachen verteilter Anwendungen. Istio nutzt eine Vielzahl von Technologien, um Software in großem Maßstab auszuführen und zu verwalten, darunter Container zum Packen von Anwendungscode und Abhängigkeiten für die Bereitstellung sowie Kubernetes zur Verwaltung dieser Container. Um mit Istio arbeiten zu können, müssen Sie daher wissen, wie eine Anwendung mit mehreren Diensten, die auf diesen Technologien basieren, funktioniert без Istio. Wenn Ihnen diese Tools und Konzepte bereits bekannt sind, können Sie dieses Tutorial gerne überspringen und direkt mit dem Abschnitt fortfahren Istio auf Google Kubernetes Engine (GKE) installieren oder eine Erweiterung installieren Istio auf GKE.

Dies ist eine Schritt-für-Schritt-Anleitung, in der wir den gesamten Prozess vom Quellcode bis zum GKE-Container durchgehen, um Ihnen anhand eines Beispiels ein grundlegendes Verständnis dieser Technologien zu vermitteln. Sie werden auch sehen, wie Istio die Leistungsfähigkeit dieser Technologien nutzt. Dies setzt voraus, dass Sie keine Ahnung von Containern, Kubernetes, Service Meshes oder Istio haben.

Aufgaben

In diesem Tutorial führen Sie die folgenden Aufgaben aus:

Erlernen einer einfachen Hallo-Welt-Anwendung mit mehreren Diensten.
Führen Sie die Anwendung über den Quellcode aus.
Verpacken der Anwendung in Containern.
Erstellen eines Kubernetes-Clusters.
Bereitstellen von Containern in einem Cluster.

Bevor du anfängst

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

überprüfen Kubernetes Engine-Seite in der Google Cloud Platform-Konsole.
Erstellen Sie ein Projekt oder wählen Sie es aus.
Warten Sie, bis die API und die zugehörigen Dienste aktiviert sind. Das kann ein paar minuten dauern.
Stellen Sie sicher, dass die Abrechnung für Ihr Google Cloud Platform-Projekt eingerichtet ist. Erfahren Sie, wie Sie die Abrechnung aktivieren.

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

Option A: Cloud Shell verwenden

Vorteile der Verwendung von Cloud Shell:

Python 2- und Python 3-Entwicklungsumgebungen (einschließlich virtualenv) sind vollständig konfiguriert.
Befehlszeilentools gcloud, Docker, git и kubectl, die wir verwenden werden, sind bereits installiert.
Sie haben mehrere zur Auswahl Texteditoren:
1. Code-Editor, das mit dem Bearbeitungssymbol oben im Cloud Shell-Fenster geöffnet wird.
2. Emacs, Vim oder Nano, die über die Befehlszeile in Cloud Shell geöffnet werden.

Benutzen Wolkenhülle:

Gehen Sie zur GCP-Konsole.
Presse Aktivieren Sie Cloud Shell (Cloud Shell aktivieren) oben im GCP-Konsolenfenster.

Im unteren Teil GCP-Konsole Eine Cloud Shell-Sitzung mit einer Befehlszeile wird in einem neuen Fenster geöffnet.

Option B: Lokale Verwendung von Befehlszeilentools

Wenn Sie an einem Computer mit Linux oder macOS arbeiten, müssen Sie die folgenden Komponenten konfigurieren und installieren:

Anpassen Entwicklungsumgebung für Python 3 und Python 2.
Installieren Sie das Cloud SDK mit Kommandozeilentool gcloud.
Setzen kubectl - Befehlszeilentool zum Arbeiten mit Kubernetes.
```
gcloud components install kubectl
```
Setzen Docker Community Edition (CE). Sie verwenden das Befehlszeilentool Dockerum Containerbilder für die Beispielanwendung zu erstellen.
Installieren Sie das Tool Git-Versionskontrolleum die Beispielanwendung von GitHub zu erhalten.

Beispielcode herunterladen

Laden Sie den Quellcode herunter halloserver:

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

Gehen Sie zum Beispielcodeverzeichnis:

cd istio-samples/sample-apps/helloserver

Erkunden einer Anwendung mit mehreren Diensten

Die Beispielanwendung ist in Python geschrieben und besteht aus zwei Komponenten, die mithilfe von interagieren REST:

Server: einfacher Server mit einem Endpunkt ERHALTEN, /, wodurch „Hallo Welt“ auf der Konsole ausgegeben wird.
ladengen: Skript, das Datenverkehr an sendet Server, mit einer konfigurierbaren Anzahl von Anfragen pro Sekunde.

Ausführen einer Anwendung aus dem Quellcode

Um die Beispielanwendung zu erkunden, führen Sie sie in Cloud Shell oder auf Ihrem Computer aus.
1) Im Katalog istio-samples/sample-apps/helloserver Lauf Server:

python3 server/server.py

Beim Ausführen Server Folgendes wird angezeigt:

INFO:root:Starting server...

2) Öffnen Sie ein weiteres Terminalfenster, an das Sie Anfragen senden können Server. Wenn Sie Cloud Shell verwenden, klicken Sie auf das Symbol „Hinzufügen“, um eine weitere Sitzung zu öffnen.
3) Senden Sie eine Anfrage an Server:

curl http://localhost:8080

Serverantworten:

Hello World!

4) Gehen Sie von dem Verzeichnis, in das Sie den Beispielcode heruntergeladen haben, zu dem Verzeichnis, das ihn enthält ladengen:

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

5) Erstellen Sie die folgenden Umgebungsvariablen:

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

6) Laufen virtualenv:

virtualenv --python python3 env

7) Aktivieren Sie die virtuelle Umgebung:

source env/bin/activate

8) Legen Sie Anforderungen fest ladengen:

pip3 install -r requirements.txt

9) Laufen ladengen:

python3 loadgen.py

Beim Ausführen ladengen zeigt etwa die folgende Meldung an:

Starting loadgen: 2019-05-20 10:44:12.448415
5 request(s) complete to http://localhost:8080

In einem anderen Terminalfenster Server gibt folgende Meldungen an die Konsole aus:

127.0.0.1 - - [21/Jun/2019 14:22:01] "GET / HTTP/1.1" 200 -
INFO:root:GET request,
Path: /
Headers:
Host: localhost:8080
User-Agent: python-requests/2.22.0
Accept-Encoding: gzip, deflate
Accept: */*

Aus Netzwerksicht läuft die gesamte Anwendung auf einem einzigen Host (lokaler Computer oder virtuelle Cloud Shell-Maschine). Daher können Sie verwenden localhostum Anfragen zu senden Server.
10) Aufhören ladengen и Server, Eintreten Strg-c in jedem Terminalfenster.
11) Im Terminalfenster ladengen Deaktivieren Sie die virtuelle Umgebung:

deactivate

Verpacken einer Anwendung in Container

Um die Anwendung auf GKE auszuführen, müssen Sie die Beispielanwendung packen Server и ladengen - in Behälter. Ein Container ist eine Möglichkeit, eine Anwendung zu verpacken, um sie von ihrer Umgebung zu isolieren.

Um eine Anwendung in einen Container zu packen, benötigen Sie Dockerfile. Dockerfile ist eine Textdatei, die Befehle zum Erstellen des Quellcodes der Anwendung und ihrer Abhängigkeiten definiert Docker-Image. Nach der Erstellung laden Sie das Image in eine Container-Registrierung wie Docker Hub oder hoch Container-Registrierung.

Das Beispiel hat bereits Dockerfile für Server и ladengen mit allen notwendigen Befehlen zum Sammeln von Bildern. Unten - Dockerfile für Server:

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/*

# Enable unbuffered logging
FROM base as final
ENV PYTHONUNBUFFERED=1

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

WORKDIR /helloserver

# Grab packages from builder
COPY --from=builder /usr/local/lib/python3.7/ /usr/local/lib/python3.7/

# Add the application
COPY . .

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

Team VON python:3-slim als Basis weist Docker an, die neueste Version zu verwenden Python 3-Bild als Basis.
Team KOPIEREN. . kopiert die Quelldateien in das aktuelle Arbeitsverzeichnis (nur in unserem Fall). server.py) in das Dateisystem des Containers.
EINSTIEGSPUNKT definiert den Befehl, der zum Starten des Containers verwendet wird. In unserem Fall ist dieser Befehl fast derselbe wie der, den Sie früher ausgeführt haben server.py aus dem Quellcode.
Team ENTLARVEN weist darauf hin, dass Server wartet auf Daten über den Port 8080. Dieses Team ist es nicht stellt Ports bereit. Hierbei handelt es sich um eine Art Dokumentation, die zum Öffnen des Ports benötigt wird 8080 beim Starten des Containers.

Bereiten Sie die Containerisierung Ihrer Anwendung vor

1) Legen Sie die folgenden Umgebungsvariablen fest. Ersetzen PROJECT_ID zu Ihrer GCP-Projekt-ID hinzufügen.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

Werte nutzen PROJECT_ID и GCR_REPO Sie kennzeichnen das Docker-Image beim Erstellen und übertragen es in eine private Container Registry.

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

gcloud config set project $PROJECT_ID

3) Legen Sie die Standardzone für das Befehlszeilentool 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

Containerisierungsserver

Gehen Sie in das Verzeichnis, in dem sich das Beispiel befindet Server:

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

Stellen Sie das Bild mit zusammen Dockerfile und die 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 Bild in die Container Registry hoch:

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

Containerisierung von Loadgen

1) Gehen Sie in das Verzeichnis, in dem sich das Beispiel befindet ladengen:

cd ../loadgen

2) Sammeln Sie das Bild:

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

3) Laden Sie das Bild in die Container Registry hoch:

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

Sehen Sie sich eine Liste mit Bildern an

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

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

Der Befehl zeigt die Namen der neu hochgeladenen Bilder an:

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

Erstellen eines GKE-Clusters.

Diese Container können mit dem Befehl auf einer virtuellen Cloud Shell-Maschine oder auf einem Computer ausgeführt werden Andocklauf. In einer Produktionsumgebung benötigen Sie jedoch eine Möglichkeit, Container zentral zu orchestrieren. Sie benötigen beispielsweise ein System, das sicherstellt, dass Container immer ausgeführt werden, und Sie benötigen eine Möglichkeit zur Skalierung und zum Hochfahren zusätzlicher Containerinstanzen, wenn der Datenverkehr zunimmt.

Zum Ausführen von Containeranwendungen können Sie verwenden GKE. GKE ist eine Container-Orchestrierungsplattform, die virtuelle Maschinen in einem Cluster zusammenfasst. Jede virtuelle Maschine wird als Knoten bezeichnet. GKE-Cluster basieren auf dem Open-Source-Clusterverwaltungssystem Kubernetes. Kubernetes bietet Mechanismen für die Interaktion mit dem Cluster.

Erstellen eines GKE-Clusters:

1) Erstellen Sie einen Cluster:

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

Team gcloud erstellt einen istioready-Cluster im von Ihnen angegebenen GCP-Projekt und der Standardzone. Um Istio auszuführen, empfehlen wir mindestens 4 Knoten und eine virtuelle Maschine n1-Standard-2.

Das Team erstellt den Cluster in wenigen Minuten. Wenn der Cluster bereit ist, gibt der Befehl etwa Folgendes aus Nachricht.

2) Geben Sie Anmeldeinformationen im Befehlszeilentool ein kubectlum damit den Cluster zu verwalten:

gcloud container clusters get-credentials istioready

3) Jetzt können Sie über mit Kubernetes kommunizieren kubectl. Der folgende Befehl kann beispielsweise den Status von Knoten ermitteln:

kubectl get nodes

Der Befehl erzeugt eine Liste von Knoten:

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

Kubernetes-Schlüsselkonzepte

Das Diagramm zeigt eine Anwendung auf GKE:

Bevor Sie Container in GKE bereitstellen, lernen Sie die Schlüsselkonzepte von Kubernetes kennen. Wenn Sie mehr erfahren möchten, finden Sie ganz am Ende Links.

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 Sammlung von Knoten, die als eine einzelne Einheit betrachtet werden können, in der Sie eine Containeranwendung bereitstellen.
Schoten. In Kubernetes werden Container in Pods ausgeführt. Ein Pod in Kubernetes ist eine unteilbare Einheit. Ein Pod enthält einen oder mehrere Container. Sie stellen Servercontainer bereit und ladengen in separaten Hülsen. Wenn sich in einem Pod mehrere Container befinden (z. B. ein Anwendungsserver und Proxy Server) werden Container als eine Einheit verwaltet und teilen sich Pod-Ressourcen.
Bereitstellungen. In Kubernetes ist ein Deployment ein Objekt, das eine Sammlung identischer Pods darstellt. Durch die Bereitstellung werden mehrere Replikate von Pods gestartet, die über Clusterknoten verteilt sind. Die Bereitstellung ersetzt automatisch Pods, die ausgefallen sind oder nicht reagieren.
Kubernetes-Dienst. Beim Ausführen von Anwendungscode in GKE besteht die Verbindung zwischen ladengen и Server. Wenn Sie Dienste auf einer virtuellen Maschine oder einem Cloud Shell-Desktop gestartet haben, haben Sie Anfragen an gesendet Server nach Adresse localhost: 8080. Nach der Bereitstellung in GKE werden Pods auf verfügbaren Knoten ausgeführt. Standardmäßig haben Sie keine Kontrolle darüber, auf welchem Knoten der Pod ausgeführt wird Schoten keine permanenten IP-Adressen.
Um eine IP-Adresse zu erhalten für Server, müssen Sie eine Netzwerkabstraktion über den Pods definieren. Das ist es Kubernetes-Dienst. Der Kubernetes-Dienst stellt einen dauerhaften Endpunkt für eine Reihe von Pods bereit. Es gibt ein paar Arten von Dienstleistungen. Server verwendet Lastenausgleicher, das eine externe IP-Adresse zur Kontaktaufnahme bereitstellt Server von außerhalb des Clusters.
Kubernetes verfügt außerdem über ein integriertes DNS-System, das DNS-Namen zuweist (z. B. helloserver.default.cluster.local) Dienstleistungen. Dadurch kommunizieren Pods innerhalb des Clusters über eine permanente Adresse mit anderen Pods im Cluster. Der DNS-Name kann nicht außerhalb des Clusters verwendet werden, beispielsweise in Cloud Shell oder auf einem Computer.

Kubernetes manifestiert sich

Als Sie die Anwendung aus der Quelle ausgeführt haben, haben Sie den Imperativ-Befehl verwendet python3

server.py

Imperativ impliziert ein Verb: „tue dies.“

Kubernetes verwendet deklaratives Modell. Das bedeutet, dass wir Kubernetes nicht genau sagen, was zu tun ist, sondern vielmehr den gewünschten Zustand beschreiben. Beispielsweise startet und stoppt Kubernetes Pods nach Bedarf, um den tatsächlichen Zustand des Systems mit dem gewünschten Zustand konsistent zu halten.

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

Das Beispiel enthält eine YAML-Datei für Server и ladengen. Jede YAML-Datei gibt den gewünschten Status 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

Art gibt den Typ des Objekts an.
metadata.name Gibt den Bereitstellungsnamen an.
Erstes Feld spec enthält eine Beschreibung des gewünschten Zustands.
spec.replicas gibt die gewünschte Anzahl an Pods an.
Abschnitt spec.template definiert eine Pod-Vorlage. In der Pod-Spezifikation gibt es ein Feld Image, der den Namen des Images angibt, das aus der Container Registry extrahiert werden muss.

Der Dienst ist wie folgt definiert:

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

Lastenausgleicher: Clients senden Anfragen an die IP-Adresse des Load Balancers, der über eine dauerhafte IP-Adresse verfügt und von außerhalb des Clusters zugänglich ist.
ZielPort: Wie Sie sich erinnern, das Team AUSSETZEN 8080 в Dockerfile keine Ports bereitgestellt. Sie stellen den Port zur Verfügung 8080damit Sie den Container kontaktieren können Server außerhalb des Clusters. In unserem Fall hellosvc.default.cluster.local:80 (kurzer Name: hallovc) entspricht dem Port 8080 Pod-IP-Adressen halloserver.
port : Dies ist die Portnummer, an die andere Dienste im Cluster Anforderungen senden.

Loadgen.yaml

Bereitstellungsobjekt für Loadgen.yaml ähnelt server.yaml. Der Unterschied besteht darin, dass das Bereitstellungsobjekt einen Abschnitt enthält env. Es definiert die benötigten Umgebungsvariablen ladengen und die Sie installiert haben, als Sie die Anwendung von der Quelle aus ausgeführt 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

Zeit ladengen akzeptiert keine eingehenden Anfragen für das Feld tippe angezeigt ClusterIP. Dieser Typ stellt eine dauerhafte IP-Adresse bereit, die von den Diensten im Cluster verwendet werden kann. Diese IP-Adresse wird jedoch nicht für externe Clients verfügbar gemacht.

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

Bereitstellen von Containern in GKE

1) Gehen Sie in das Verzeichnis, in dem sich das Beispiel befindet Server:

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

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

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

Ersetzen PROJECT_ID zu Ihrer GCP-Projekt-ID hinzufügen.
4) Speichern und schließen server.yaml.
5) Stellen Sie die YAML-Datei auf Kubernetes bereit:

kubectl apply -f server.yaml

Nach erfolgreichem Abschluss erzeugt der Befehl den folgenden Code:

deployment.apps/helloserver created
service/hellosvc created

6) Gehen Sie in das Verzeichnis, in dem ladengen:

cd ../loadgen

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

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

Ersetzen PROJECT_ID zu Ihrer GCP-Projekt-ID hinzufügen.
9) Speichern und schließen Loadgen.yaml, schließen Sie den Texteditor.
10) Stellen Sie die YAML-Datei auf Kubernetes bereit:

kubectl apply -f loadgen.yaml

Nach erfolgreichem Abschluss erzeugt der Befehl den folgenden Code:

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 Anwendungsprotokolle aus dem Pod ladengen. Ersetzen POD_ID zur Kennung aus der vorherigen Antwort.

kubectl logs loadgenerator-POD_ID

13) Beziehen Sie externe IP-Adressen hallovc:

kubectl get service

Die Befehlsantwort sieht etwa 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      <none>          443/TCP        93m
loadgensvc   ClusterIP      10.81.15.155   <none>          80/TCP         4m52s

14) Senden Sie eine Anfrage an hallovc: ersetzen EXTERNE_IP an externe IP-Adresse hallovc.

curl http://EXTERNAL_IP

Nehmen wir es mit Istio auf

Sie haben bereits eine Anwendung in GKE bereitgestellt. ladengen kann Kubernetes DNS verwenden (hellosvc:80), um Anfragen zu senden Serverund Sie können Anfragen an senden Server durch externe IP-Adresse. Obwohl Kubernetes über viele Funktionen verfügt, fehlen einige Informationen zu den Diensten:

Wie interagieren Dienste? Welche Beziehungen bestehen zwischen Diensten? Wie fließt der Datenverkehr zwischen den Diensten? Ist Ihnen das bewusst? ladengen sendet Anfragen an Server, aber stellen Sie sich vor, Sie wissen nichts über die Anwendung. Um diese Fragen zu beantworten, schauen wir uns die Liste der ausgeführten Pods in GKE an.
Metriken. Wie lang Server antwortet auf eine eingehende Anfrage? Wie viele Anfragen gehen pro Sekunde beim Server ein? Gibt es Fehlermeldungen?
Sicherheitsinformationen. Verkehr dazwischen ladengen и Server geht einfach durch HTTP oder von mTLS?

Istio beantwortet alle diese Fragen. Zu diesem Zweck platziert Istio einen Sidecar-Proxy Gesandte in jeder Kapsel. Der Envoy-Proxy fängt den gesamten ein- und ausgehenden Datenverkehr zu Anwendungscontainern ab. Das bedeutet es Server и ladengen Empfangen Sie über den Sidecar-Proxy Envoy und den gesamten Datenverkehr von ladengen к Server geht über den Envoy-Proxy.

Verbindungen zwischen Envoy-Proxys bilden ein Service-Mesh. Die Service-Mesh-Architektur bietet eine Kontrollebene auf Kubernetes.

Da Envoy-Proxys in ihren eigenen Containern laufen, kann Istio fast ohne Änderungen am Anwendungscode auf einem GKE-Cluster installiert werden. Aber Sie haben einige Arbeit geleistet, um Ihre Anwendung für die Verwaltung durch Istio vorzubereiten:

Dienstleistungen für alle Container. Zu Einsätzen Server и ladengen an den Kubernetes-Dienst gebunden. Sogar ladengen, der keine eingehenden Anfragen empfängt, gibt es einen Dienst.
Ports in Diensten müssen Namen haben. Obwohl Service-Ports in GKE unbenannt bleiben können, ist bei Istio eine Angabe erforderlich Portname gemäß seinem Protokoll. In der YAML-Datei der Port für Server er rief httpweil der Server das Protokoll verwendet HTTP. Wenn verwendet gRPC, würden Sie den Port benennen grpc.
Bereitstellungen werden markiert. Daher können Sie die Verkehrsverwaltungsfunktionen von Istio nutzen, z. B. die Aufteilung des Datenverkehrs zwischen Versionen desselben Dienstes.

Installation

Es gibt zwei Möglichkeiten, Istio zu installieren. Kann Aktivieren Sie Istio in der GKE-Erweiterung oder Installieren Sie die Open-Source-Version von Istio auf dem Cluster. Mit Istio auf GKE können Sie Istio-Installationen und -Upgrades während des gesamten GKE-Cluster-Lebenszyklus problemlos verwalten. Wenn Sie die neueste Version von Istio oder mehr Kontrolle über die Konfiguration Ihres Istio-Kontrollfelds wünschen, installieren Sie die Open-Source-Version anstelle der Istio on GKE-Erweiterung. Um sich für die Vorgehensweise zu entscheiden, lesen Sie den Artikel Benötige ich Istio auf GKE?.

Wählen Sie eine Option aus, lesen Sie die entsprechende Anleitung und befolgen Sie die Anweisungen zur Installation von Istio auf Ihrem Cluster. Wenn Sie Istio mit Ihrer neu bereitgestellten Anwendung verwenden möchten, Aktivieren Sie die Sidecar-Implementierung für Namensraum Standard.

Очистка

Um zu vermeiden, dass Ihrem Google Cloud Platform-Konto die in diesem Tutorial verwendeten Ressourcen in Rechnung gestellt werden, löschen Sie den Containercluster, nachdem Sie Istio installiert und mit der Beispielanwendung herumgespielt haben. Dadurch werden alle Clusterressourcen entfernt, z. B. Compute-Instanzen, Festplatten und Netzwerkressourcen.

Was kommt als nächstes?

Entdecken Sie die folgenden Technologien:
1. Docker
2. Container
3. Container-Registrierung
4. Kubernetes
5. GKE
6. Servicenetz
7. Istio
Entdecken Sie die folgenden Tools:
Lernen Sie Kubernetes-Konzepte kennen:
1. Cluster
2. Knoten
3. Schoten
4. Dienstleistungen
5. Einsatz

Source: habr.com

Vorbereitung einer Bewerbung für Istio