ProHoster > Blog > Administratioun > Preparéieren eng Applikatioun fir Istio

Preparéieren eng Applikatioun fir Istio

Preparéieren eng Applikatioun fir Istio

Istio ass e praktescht Tool fir verdeelt Uwendungen ze verbannen, ze sécheren an ze iwwerwaachen. Istio benotzt eng Vielfalt vun Technologien fir Software op Skala ze lafen an ze verwalten, dorënner Container fir Applikatiounscode an Ofhängegkeete fir Deployment ze packen, a Kubernetes fir dës Container ze managen. Dofir, fir mat Istio ze schaffen, musst Dir wësse wéi eng Applikatioun mat ville Servicer baséiert op dësen Technologien funktionnéiert ouni Istio. Wann dës Tools a Konzepter Iech scho vertraut sinn, fillt Iech gratis dësen Tutorial ze iwwersprangen a gitt direkt an d'Sektioun Installéiert Istio op Google Kubernetes Engine (GKE) oder eng Extensioun installéieren Istio op GKE.

Dëst ass e Schrëtt-fir-Schrëtt Guide wou mir de ganze Prozess vu Quellcode bis GKE Container duerchgoën fir Iech e Basisverständnis vun dësen Technologien duerch e Beispill ze ginn. Dir gesitt och wéi Istio d'Kraaft vun dësen Technologien benotzt. Dëst gëtt ugeholl datt Dir näischt iwwer Container, Kubernetes, Service Meshes oder Istio wësst.

Aufgaben

An dësem Tutorial wäert Dir déi folgend Aufgaben ausfëllen:

  1. Léiert eng einfach Hallo Welt Applikatioun mat ville Servicer.
  2. Run der Applikatioun vum Quellcode.
  3. Verpackt d'Applikatioun an Containeren.
  4. Erstellt e Kubernetes Cluster.
  5. Behälter an e Cluster ofsetzen.

Ier Dir ufänken

Follegt d'Instruktioune fir de Kubernetes Engine API z'aktivéieren:

  1. Gitt op Kubernetes Engine Säit an der Google Cloud Plattform Konsol.
  2. Erstellt oder wielt e Projet.
  3. Waart bis d'API a verbonne Servicer aktivéiert sinn. Dëst kann e puer Minutten huelen.
  4. Vergewëssert Iech datt d'Rechnung fir Äre Google Cloud Plattform Projet ageriicht ass. Léiert wéi Dir Rechnung aktivéiert.

An dësem Tutorial kënnt Dir Cloud Shell benotzen, déi d'virtuell Maschinn virbereet g1-kleng an Google Compute Engine mat Debian-baséiert Linux, oder engem Linux oder macOS Computer.

Optioun A: Benotzt Cloud Shell

Virdeeler vum Cloud Shell benotzen:

  • Python 2 a Python 3 Entwécklungsëmfeld (inklusiv virtualenv) komplett konfiguréiert sinn.
  • Kommando Linn Tools gcloud, Docker, Go и kubectl, déi mir benotze wäerte scho installéiert sinn.
  • Dir hutt e puer ze wielen aus Text Redaktoren:
    1. Code Editor, déi opmaacht mat der Ännerung Ikon am Top vun der Cloud Shell Fënster.
    2. Emacs, Vim oder Nano, déi vun der Kommandozeil an der Cloud Shell opmaachen.

Benotzen Cloud Shell:

  1. Gitt op d'GCP Konsole.
  2. Press Aktivéiert Cloud Shell (Cloud Shell aktivéieren) uewen an der GCP Konsolfenster.

Preparéieren eng Applikatioun fir Istio

Am ënneschten Deel GCP Konsol Eng Cloud Shell Sessioun mat enger Kommandozeil gëtt an enger neier Fënster opgemaach.

Preparéieren eng Applikatioun fir Istio

Optioun B: Benotzt Command Line Tools lokal

Wann Dir op engem Computer mat Linux oder MacOS schafft, musst Dir déi folgend Komponenten konfiguréieren an installéieren:

  1. Personnaliséieren Python 3 a Python 2 Entwécklungsëmfeld.

  2. Installéiert Cloud SDK mat Kommando Linn Outil gcloud.

  3. Installéieren kubectl - Kommando Linn Outil fir eng Aarbecht mat Kubernetes.

    gcloud components install kubectl

  4. Installéieren Docker Community Edition (CE). Dir wäert de Kommandozeil Tool benotzen Dockerfir Container Biller fir d'Probeapplikatioun ze kreéieren.

  5. Installéiert den Tool Git Versioun Kontrollfir d'Probeapplikatioun vu GitHub ze kréien.

Download Prouf Code

  1. Luet de Quellcode erof halloserver:

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

  2. Gitt an de Beispill Code Verzeechnes:

    cd istio-samples/sample-apps/helloserver

Entdeckt eng Applikatioun mat ville Servicer

D'Probeapplikatioun ass am Python geschriwwen a besteet aus zwee Komponenten déi mat interagéieren Rescht:

  • Server: Einfach Server mat engem Endpunkt GET, /, déi "Hallo Welt" op d'Konsole dréckt.
  • loadgen: Skript datt Verkéier schéckt ze Server, mat enger konfiguréierbarer Unzuel vun Ufroen pro Sekonn.

Preparéieren eng Applikatioun fir Istio

Lafen eng Applikatioun aus Quellcode

Fir d'Probeapplikatioun ze entdecken, lafen se an der Cloud Shell oder op Ärem Computer.
1) Am Katalog istio-samples/sample-apps/helloserver lafen Server:

python3 server/server.py

Beim Startup Server folgend gëtt ugewisen:

INFO:root:Starting server...

2) Öffnen eng aner Terminalfenster fir Ufroen ze schécken Server. Wann Dir Cloud Shell benotzt, klickt op d'Add Ikon fir eng aner Sessioun opzemaachen.
3) Schéckt eng Ufro un Server:

curl http://localhost:8080

Server Äntwerten:

Hello World!

4) Vum Verzeechnes wou Dir de Probecode erofgelueden hutt, gitt an de Verzeechnes deen enthält loadgen:

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

5) Erstellt déi folgend Ëmfeldvariablen:

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

6) Lafen virtualenv:

virtualenv --python python3 env

7) Aktivéiert dat virtuellt Ëmfeld:

source env/bin/activate

8) Set Ufuerderunge fir loadgen:

pip3 install -r requirements.txt

9) Lafen loadgen:

python3 loadgen.py

Beim Startup loadgen weist eppes wéi de folgende Message:

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

An enger anerer Terminalfenster Server gëtt déi folgend Messagen op d'Konsol eraus:

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 enger Netzwierkperspektiv leeft déi ganz Applikatioun op engem eenzegen Host (lokale Computer oder Cloud Shell virtuell Maschinn). Dofir kënnt Dir benotzen localhostUfroen ze schécken Server.
10) Stoppen loadgen и Server, enter Ctrl-c an all Terminalfenster.
11) An der Terminalfenster loadgen desaktivéiere virtuell Ëmfeld:

deactivate

Verpakung eng Applikatioun a Container

Fir d'Applikatioun op GKE ze lafen, musst Dir d'Beispillapplikatioun packen - Server и loadgen - an Container. E Container ass e Wee fir eng Applikatioun ze packen fir se vu senger Ëmwelt ze isoléieren.

Fir eng Applikatioun an e Container ze packen, braucht Dir dockerfile. dockerfile ass eng Textdatei déi Kommandoen definéiert fir de Quellcode vun der Applikatioun a seng Ofhängegkeeten ze bauen Docker Bild. Eemol gebaut, lued Dir d'Bild an e Container Registry wéi Docker Hub oder Container Registry.

D'Beispill huet schonn dockerfile fir Server и loadgen mat all déi néideg Kommandoen fir Biller ze sammelen. Drënner - dockerfile fir 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" ]

  • Equipe VUN Python: 3-schlank als Basis erzielt Docker déi lescht ze benotzen Python 3 Bild als Basis.
  • Equipe COPY. . kopéiert d'Quelldateien an den aktuellen Aarbechtsverzeichnis (nëmmen an eisem Fall server.py) an de Dateiesystem vum Container.
  • ENTRYPOINT definéiert de Kommando deen benotzt gëtt fir de Container ze starten. An eisem Fall ass dëse Kommando bal d'selwecht wéi deen deen Dir benotzt fir ze lafen server.py aus Quellcode.
  • Equipe EXPOSÉIEREN weist dat un Server waart op Daten duerch den Hafen 8080. Dës Equipe ass net stellt Häfen. Dëst ass eng Zort Dokumentatioun déi gebraucht gëtt fir den Hafen opzemaachen 8080 beim Start vum Container.

Virbereedung fir Är Applikatioun ze containeriséieren

1) Setzt déi folgend Ëmfeldvariablen. Ersetzen PROJECT_ID op Är GCP Projet ID.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

Benotzt Wäerter PROJECT_ID и GCR_REPO Dir markéiert den Docker Bild wann Dir et baut an dréckt et an e private Container Registry.

2) Setzt de Standard-GCP-Projet fir de Kommandozeil-Tool gcloud.

gcloud config set project $PROJECT_ID

3) Setzt d'Standardzon fir de Kommandozeilinstrument gcloud.

gcloud config set compute/zone us-central1-b

4) Vergewëssert Iech datt de Container Registry Service am GCP Projet aktivéiert ass.

gcloud services enable containerregistry.googleapis.com

Containeriséierungsserver

  1. Gitt an den Dossier wou d'Beispill läit Server:

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

  2. Assemblée d'Bild mat Hëllef dockerfile an d'Ëmfeldvariablen déi Dir virdru definéiert hutt:

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

Parameter -t representéiert den Docker Tag. Dëst ass den Numm vum Bild dat Dir benotzt wann Dir de Container installéiert.

  1. Eroplueden d'Bild an de Container Registry: 
    docker push gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1

Containerization vun loadgen

1) Gitt an den Dossier wou d'Beispill läit loadgen:

cd ../loadgen

2) Sammelt d'Bild:

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

3) Eroplueden d'Bild an de Container Registry:

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

Kuckt eng Lëscht vu Biller

Iwwerpréift d'Lëscht vun de Biller am Repository a kontrolléiert datt d'Biller eropgeluede goufen:

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

De Kommando weist d'Nimm vun den nei eropgelueden Biller:

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

Erstellt e GKE Cluster.

Dës Container kënnen op enger Cloud Shell virtueller Maschinn oder op engem Computer mam Kommando lafen Docker lafen. Awer an engem Produktiounsëmfeld braucht Dir e Wee fir Container zentral ze orchestréieren. Zum Beispill, Dir braucht e System deen sécher ass datt Container ëmmer lafen, an Dir braucht e Wee fir zousätzlech Containerinstanzen opzebauen an ze spinn wann de Traffic eropgeet.

Fir containeriséiert Uwendungen auszeféieren, kënnt Dir benotzen G.K.E.. GKE ass eng Container Orchestratiounsplattform déi virtuell Maschinnen an e Cluster aggregéiert. All virtuell Maschinn gëtt en Node genannt. GKE Cluster baséieren op dem Open Source Kubernetes Cluster Management System. Kubernetes bitt Mechanismen fir mat dem Cluster ze interagéieren.

E GKE Cluster erstellen:

1) Erstellt e Cluster:

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

Equipe gcloud erstellt en istioready Cluster am GCP-Projet an der Standardzon, déi Dir uginn hutt. Fir Istio ze lafen, recommandéiere mir op d'mannst 4 Noden an eng virtuell Maschinn ze hunn n1-Standard-2.

D'Team erstellt de Cluster an e puer Minutten. Wann de Cluster fäerdeg ass, gëtt de Kommando esou eppes aus Message.

2) Gitt Umeldungsinformatiounen am Kommandozeilinstrument kubectlfir et ze benotzen fir de Cluster ze managen:

gcloud container clusters get-credentials istioready

3) Elo kënnt Dir mat Kubernetes kommunizéieren via kubectl. Zum Beispill kann de folgende Kommando de Status vun den Noden erausfannen:

kubectl get nodes

De Kommando produzéiert eng Lëscht vun Noden:

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ëssel Konzepter

Den Diagramm weist eng Applikatioun op GKE:

Preparéieren eng Applikatioun fir Istio

Ier Dir Container an GKE ofsetzt, léiert d'Schlësselkonzepter vu Kubernetes. Et gi Linken um Enn wann Dir méi wëllt léieren.

  • Noden a Stärekéip. A GKE ass en Node eng virtuell Maschinn. Op anere Kubernetes Plattformen kann en Node e Computer oder eng virtuell Maschinn sinn. E Cluster ass eng Sammlung vun Noden déi als eenzeg Eenheet ugesi kënne ginn, wou Dir eng containeriséierter Applikatioun ofsetzt.
  • Pods. Zu Kubernetes lafen Container a Pods. E Pod zu Kubernetes ass eng ondeelbar Eenheet. E Pod hält een oder méi Container. Dir deploy Server Container an loadgen an getrennten Stäck. Wann et e puer Container an engem Pod sinn (zum Beispill en Applikatiounsserver an Proxy Server), Container ginn als eenzeg Entitéit geréiert a Podressourcen deelen.
  • Détachementer. A Kubernetes ass en Détachement en Objet deen eng Sammlung vun identesche Pods ass. Deployment lancéiert verschidde Repliken vu Pods verdeelt iwwer Clusternoden. Deployment ersetzt automatesch Pods déi gescheitert sinn oder net reagéieren.
  • Kubernetes Service. Wann Dir Applikatiounscode am GKE leeft, ass d'Verbindung tëscht loadgen и Server. Wann Dir Servicer op enger Cloud Shell virtueller Maschinn oder Desktop ugefaang hutt, hutt Dir Ufroe geschéckt Server um localhost: 8080. Eemol op GKE ofgesat, Pods ginn op verfügbare Wirbelen ausgefouert. Par défaut hutt Dir keng Kontroll iwwer wéi en Node de Pod leeft, sou datt Dir pods keng permanent IP Adressen.
    Fir eng IP Adress ze kréien fir Server, Dir musst eng Netzwierkabstraktioun uewen op de Pods definéieren. Dat ass wat et ass Kubernetes Service. De Kubernetes Service bitt e persistent Endpunkt fir eng Rei vu Pods. Et ginn e puer Zorte vu Servicer. Server benotzt LoadBalancer, déi eng extern IP Adress ubitt fir ze kontaktéieren Server vun ausserhalb vum Cluster.
    Kubernetes huet och en agebauten DNS System deen DNS Nimm zouginn (z. helloserver.default.cluster.local) Servicer. Dank dësem kommunizéieren Pods am Cluster mat anere Pods am Cluster op enger permanenter Adress. Den DNS Numm kann net ausserhalb vum Cluster benotzt ginn, sou wéi an der Cloud Shell oder op engem Computer.

Kubernetes manifestéiert

Wann Dir d'Applikatioun aus der Quell leeft, hutt Dir den Imperativ Kommando benotzt python3

server.py

Imperativ implizéiert e Verb: "maacht dëst."

Kubernetes benotzt deklarativ Modell. Dëst bedeit datt mir Kubernetes net genee soen wat se maache sollen, mä éischter de gewënschten Zoustand beschreiwen. Zum Beispill, Kubernetes fänkt a stoppt Pods wéi néideg fir sécherzestellen datt den aktuellen Zoustand vum System dem gewënschten Zoustand entsprécht.

Dir gitt de gewënschten Zoustand a Manifestatiounen oder Dateien un JAML. Eng YAML Datei enthält Spezifikatioune fir een oder méi Kubernetes Objeten.

D'Beispill enthält eng YAML Datei fir Server и loadgen. All YAML-Datei spezifizéiert de gewënschten Zoustand vum Détachementobjekt a Kubernetes Service.

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

  • Aart weist d'Zort vum Objet un.
  • metadata.name spezifizéiert den Détachement Numm.
  • Éischt Feld Spekulatioun enthält eng Beschreiwung vun der gewënschter Staat.
  • spec.repliken weist déi gewënscht Zuel vun de Pods un.
  • Sektioun spec.Schabloun definéiert eng Pod Schabloun. Et gëtt e Feld an der Pod Spezifizéierung Bild, wat den Numm vum Bild spezifizéiert, deen aus dem Container Registry extrahéiert muss ginn.

De Service ass wéi follegt definéiert:

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

  • LoadBalancer: Clientë schécken Ufroen un d'IP Adress vum Lastbalancer, deen eng persistent IP Adress huet an ass vu baussen vum Cluster zougänglech.
  • targetPort: wéi Dir Iech erënnert, d'Equipe EXPOSITIOUN 8080 в dockerfile huet net Häfen ugebueden. Dir liwwert den Hafen 8080fir datt Dir de Container kontaktéiere kënnt Server ausserhalb vum Stärekoup. An eisem Fall hellosvc.default.cluster.local:80 (kuerzen Numm: hellosvc) entsprécht dem Hafen 8080 Pod IP Adressen halloserver.
  • port: Dëst ass d'Portnummer wou aner Servicer am Cluster Ufroe schécken.

loadgen.yaml

Détachement Objet ze loadgen.yaml ausgesi wéi server.yaml. Den Ënnerscheed ass datt den Détachementobjekt eng Sektioun enthält schécken. Et definéiert d'Ëmfeldvariablen déi néideg sinn loadgen an déi Dir installéiert hutt wann Dir d'Applikatioun aus der Quell leeft.

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

Zäiten loadgen akzeptéiert net Entréeën Demanden, fir den Terrain Typ uginn ClusterIP. Dësen Typ liwwert eng persistent IP Adress déi Servicer am Stärekoup benotze kënnen, awer dës IP Adress ass net op externe Clienten ausgesat.

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

Container an GKE ofsetzen

1) Gitt an den Dossier wou d'Beispill läit Server:

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

2) Open server.yaml an engem Texteditor.
3) Ersetzen den Numm am Feld Bild op den Numm vun Ärem Docker Bild.

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

Ersetzen PROJECT_ID op Är GCP Projet ID.
4) Späicheren an zoumaachen server.yaml.
5) Deploy d'YAML Datei op Kubernetes:

kubectl apply -f server.yaml

Nom erfollegräichen Ofschloss produzéiert de Kommando de folgende Code:

deployment.apps/helloserver created
service/hellosvc created

6) Gitt an den Dossier wou loadgen:

cd ../loadgen

7) Open loadgen.yaml an engem Texteditor.
8) Ersetzen den Numm am Feld Bild op den Numm vun Ärem Docker Bild.

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

Ersetzen PROJECT_ID op Är GCP Projet ID.
9) Späicheren an zoumaachen loadgen.yaml, den Texteditor zoumaachen.
10) Deploy d'YAML Datei op Kubernetes:

kubectl apply -f loadgen.yaml

Nom erfollegräichen Ofschloss produzéiert de Kommando de folgende Code:

deployment.apps/loadgenerator created
service/loadgensvc created

11) Kuckt de Status vun de Pods:

kubectl get pods

De Kommando weist de Status:

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

12) Extrait Applikatioun Logbicher aus dem Pod loadgen. Ersetzen POD_ID zum Identifizéierer vun der viregter Äntwert.

kubectl logs loadgenerator-POD_ID

13) Kritt extern IP Adressen hellosvc:

kubectl get service

D'Kommando Äntwert gesäit sou eppes 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) Schéckt eng Ufro un hellosvc: ersetzen EXTERNAL_IP op extern IP Adress hellosvc.

curl http://EXTERNAL_IP

Loosst eis op Istio huelen

Dir hutt schonn eng Applikatioun op GKE ofgesat. loadgen kann Kubernetes DNS benotzen (hello:80) fir Ufroen ze schécken Serveran Dir kënnt Demanden schécken ze Server duerch extern IP Adress. Och wann Kubernetes vill Features huet, fehlt et e puer Informatioun iwwer d'Servicer:

  • Wéi interagéiere Servicer? Wat sinn d'Relatiounen tëscht Servicer? Wéi fléisst de Verkéier tëscht Servicer? Sidd Dir bewosst, datt loadgen schéckt Demanden un Server, awer stellt Iech vir datt Dir näischt iwwer d'Applikatioun wësst. Fir dës Froen ze beäntweren, kucke mer d'Lëscht vun de lafende Pods am GKE.
  • Metriken. Wéi laang Server reagéiert op eng erakommen Ufro? Wéi vill Ufroe pro Sekonn ginn vum Server kritt? Gëtt et Fehlermeldungen?
  • Sécherheet Informatiounen. Verkéier tëscht loadgen и Server geet just duerch HTTP oder vum mTLS?

Istio äntwert all dës Froen. Fir dëst ze maachen, setzt Istio e Sidecar Proxy spécial an all Pod. Den Envoy Proxy interceptéiert all erakommen an erausginn Traffic op Applikatiounscontainer. Et heescht dat Server и loadgen kréien via sidecar Proxy Envoy, an all Verkéier vun loadgen к Server geet duerch den Envoy Proxy.

Verbindungen tëscht Envoy Proxy bilden e Service Mesh. D'Servicemesh-Architektur bitt eng Kontrollschicht uewen op Kubernetes.

Preparéieren eng Applikatioun fir Istio

Zënter Envoy-Proxyen an hiren eegene Container lafen, kann Istio uewen op engem GKE-Cluster installéiert ginn mat bal keng Ännerungen am Applikatiounscode. Awer Dir hutt e puer Aarbecht gemaach fir Är Applikatioun prett ze kréien fir vun Istio geréiert ze ginn:

  • Servicer fir all Container. Zu Deployementer Server и loadgen un de Kubernetes Service gebonnen. Souguer loadgen, déi net erakommen Ufroe kritt, gëtt et e Service.
  • Häfen a Servicer mussen Nimm hunn. Obwuel Service Häfen kann onbenannt an GKE lénks ginn, Istio verlaangt Dir uginn port Numm am Aklang mat sengem Protokoll. An der YAML Datei den Hafen fir Server nennt httpwell Server benotzt de Protokoll HTTP... Wann Service benotzt gRPC, Dir géift den Hafen nennen grpc.
  • Détachementer sinn markéiert. Dofir kënnt Dir d'Istio Traffic Management Feature benotzen, wéi zum Beispill Traffic opzedeelen tëscht Versioune vum selwechte Service.

Installéiert Istio

Et ginn zwou Weeër fir Istio z'installéieren. Kann aktivéiert Istio op GKE Extensioun oder installéiert d'Open Source Versioun vun Istio op de Cluster. Mat Istio op GKE kënnt Dir einfach Istio Installatiounen an Upgrades am ganze GKE Cluster Liewenszyklus managen. Wann Dir déi lescht Versioun vun Istio oder méi Kontroll iwwer Är Istio Kontrollpanelkonfiguratioun wëllt, installéiere déi Open Source Versioun anstatt d'Istio op GKE Extensioun. Fir iwwer d'Approche ze entscheeden, liest den Artikel Braucht ech Istio op GKE?.

Wielt eng Optioun, iwwerpréift de passenden Guide, a befollegt d'Instruktioune fir Istio op Ärem Cluster z'installéieren. Wann Dir Istio mat Ärer nei ofgebauter Applikatioun benotze wëllt, aktivéiert Sidecar Implementatioun fir Nummraum Standarddrécker.

Botzen

Fir ze vermeiden datt Dir op Äre Google Cloud Plattform Kont berechent sidd fir d'Ressourcen déi Dir an dësem Tutorial benotzt hutt, läscht de Containercluster eemol Dir Istio installéiert hutt a mat der Probeapplikatioun gespillt hutt. Dëst wäert all Clusterressourcen ewechhuelen, sou wéi Recheninstanzen, Disken an Netzwierkressourcen.

Wat d'nächst?

Source: will.com

Setzt e Commentaire