🥇Rakenduse ettevalmistamine Istio jaoks

Istio — mugav tööriist hajutatud rakenduste ühendamiseks, kaitsmiseks ja jälgimiseks. Istios kasutatakse erinevaid tehnoloogiaid, et skaleerida ja hallata tarkvara, sealhulgas konteinerid rakenduskoodi ja sõltuvuste pakkimiseks ning Kubernetes nende konteinerite haldamiseks. Seetõttu peate Istio kasutamiseks teadma, kuidas mitme teenusega rakendus nende tehnoloogiate põhjal töötab. ilma Istio. Kui need tööriistad ja mõisted on teile juba tuttavad, võite selle juhendi julgelt vahele jätta ja minna otse jaotisse. Istio installimine Google Kubernetes Engine'is (GKE) või laienduse installimine Istio GKE-l.

See on samm-sammult juhend, kus käsitleme kogu protsessi lähtekoodist kuni konteinerini GKE-s, et saaksite nende tehnoloogiate üldise arusaama näite põhjal. Näete ka, kuidas Istio nende tehnoloogiate võimalusi ära kasutab. Eeldatakse, et te ei tea konteineritest, Kubernetesest, teenuseteemast ega Istio'st midagi.

Ülesanded

Selles juhendis täidate järgmised ülesanded:

Lihtsa hello world rakenduse uurimine, millel on mitu teenust.
Rakenduse käivitamine lähtekoodist.
Rakenduse pakkimine konteineritesse.
Kubernetesi klastrite loomine.
Konteinerite juurutamine klastri.

Enne alustamist

Järgige juhiseid, et aktiveerida Kubernetes Engine API:

Minge lehele Kubernetes Engine Google Cloud Platformi konsoolis.
Looge või valige projekt.
Oodake, kuni API ja sellega seotud teenused aktiveeritakse. See võib võtta mitu minutit.
Veenduge, et Google Cloud Platformi projekt on arveldamiseks seadistatud. Lisateabe saamiseks arveldamise aktiveerimise kohta.

Selles juhendis saate kasutada Cloud Shell'i, mis valmistab ette virtuaalmasina g1-small Google Compute Engine'is Debiani-põhise Linuxiga, või Linuxi või macOSi arvutit.

Variant A: Cloud Shell'i kasutamine

Cloud Shell'i kasutamise eelised:

Python 2 ja Python 3 arenduskeskkonnad (sealhulgas virtualenv) on täielikult seadistatud.
Käskude tööriistad gcloud, docker, git ja kubectl, mida me kasutame, on juba installitud.
Teil on valik mitmeid teksti redaktoreid:
1. Koodiredaktor, mis avatakse Cloud Shell'i akna ülaosas redigeerimise ikooni klõpsates.
2. Emacs, Vim või Nano, mis avatakse Cloud Shell'i käsurealt.

Cloud Shell'i kasutamiseks Minge GCP konsooli.:

Aktiveerige Cloud Shell
„Uuesti väljaandmine“ Aktiveeri Cloud Shell (Aktiveeri Cloud Shell) GCP konsooli akna ülaosas.

Akna alumises osas GCP konsool avaneb uues aknas Cloud Shell koos käsureaga.

Valik B: kasutada käsurea tööriistu kohalikult

Kui töötate Linuxi või macOS arvutis, peate seadistama ja installima järgmised komponendid:

Seadistage Python 3 ja Python 2 arenduskeskkond.
Installige Cloud SDK koos käsurea tööriistaga gcloud.
Installige kubectl — käsurea tööriist GCP-ga töötamiseks Kubernetes.
```
gcloud components install kubectl
```
Installige Docker Community Edition (CE). Te kasutate käsurea tööriista docker, et luua konteineripilte näidisrakenduse jaoks.
Installige versioonikontrolli tööriist Git, et saada näidisrakendus GitHubist.

Koodi näidislaadimine

Laadi alla lähtekood helloserver:

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

Liikuge näidisrakenduse katalooge:

cd istio-samples/sample-apps/helloserver

Mitme teenusega rakenduse uurimine

Näidisrakendus on kirjutatud Pythonis ja koosneb kahest komponendist, mis suhtlevad REST:

server: lihtne server ühe lõpp-punktiga GET, /, mis trükib „hello world” konsooli.
loadgen: skript, mis suunab liiklust server, kohandatava päringute arvu sekundis.

Rakenduse käivitamine lähtekoodist

Rakenduse näidiseks käitamiseks avage see Cloud Shellis või oma arvutis.
1) Kataloogis istio-samples/sample-apps/helloserver käivitage server:

python3 server/server.py

Käivitamisel kuvatakse järgmine: server INFO:root:Serveri käivitamine...

2) Avage teine terminaliakna, et saata päringud

. Kui kasutate Cloud Shelli, klõpsake lisaikoonil, et avada teine sessioon. server3) Saatke päring
curl http://localhost:8080 server:

server vastab:

4) Kataloogist, kuhu olete koode laadinud, minge katalooge, mis sisaldab

Hello World!

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

5) Looge järgmised keskkonnamuutujad:

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

6) Käivitage

virtualenv --python python3 env virtualenv:

7) Aktiveerige virtuaalne keskkond:

source env/bin/activate

8) Installige nõudmised

pip3 install -r requirements.txt loadgen:

9) Käivitage

python3 loadgen.py loadgen:

kuvatakse ligikaudu järgmine teade:

Käivitamisel kuvatakse järgmine: loadgen Käivitamine loadgen: 2019-05-20 10:44:12.448415 5 päringut on lõpetatud aadressile http://localhost:8080

Teises terminaliaknas

kuvatakse ligikaudu järgmised teated: server 127.0.0.1 - - [21/Jun/2019 14:22:01] "GET / HTTP/1.1" 200 - INFO:root:GET päring, Path: / Headers: Host: localhost:8080 User-Agent: python-requests/2.22.0 Accept-Encoding: gzip, deflate Accept: */*

127.0.0.1 - - [21/Juun/2019 14:22:01] "GET / HTTP/1.1" 200 -
INFO:root:GET päring,
Teekond: /
Päid:
Host: localhost:8080
User-Agent: python-requests/2.22.0
Accept-Encoding: gzip, deflate
Accept: */*

Võrgu seisukohalt töötab kogu rakendus ühel hostil (kohalikus arvutis või virtuaalses Cloud Shell'is). Seetõttu saab kasutada localhost, et saata päringuid server.
10) Rakenduse peatamiseks loadgen ja server, sisestage Ctrl-c iga terminaliaknas.
11) Terminaliaknas loadgen deaktiveerige virtuaalne keskkond:

deactivate

Rakenduse konteineritesse pakendamine

Et rakendust GKE-s käivitada, tuleb näidisrakendus pakendada — server ja loadgen — in konteinerites. Konteiner on viis rakenduse pakendamiseks, et isoleerida see keskkonnast.

Rakenduse konteinerisse pakendamiseks on vajalik Dockerfile. Dockerfile — tekstifail, kus määratletakse käsud rakenduse lähtekoodi ja selle sõltuvuste koostamiseks Docker'i pildiks. Pärast koostamist laadite pildi konteineriregistrisse, näiteks Docker Hub'i või Container Registry.

Näidis sisaldab juba Dockerfile kuna server ja loadgen kõiki vajalikke käske, et pilte koostada. Allpool — Dockerfile kuna server:

VÕTA python:3-slim kui põhja
VÕTA põhjast kui ehitaja
RUN apt-get -qq uuenda 
    && apt-get install -y --no-install-recommends 
        g++ 
    && rm -rf /var/lib/apt/lists/*

# Luba jääklogging
VÕTA põhjast kui lõpp
ENV PYTHONUNBUFFERED=1

RUN apt-get -qq uuenda 
    && 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/

# Lisa rakendus
COPY . .

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

Meeskond VÕTA python:3-slim kui põhja käseb Dockeril kasutada viimast Python 3 põhjana.
Meeskond COPY. . kopeerib lähtekoodid praegusesse töökatalooge (meie puhul ainult server.py) konteineri failisüsteemi.
ENTRYPOINT määrab käsu, mida kasutatakse konteineri käivitamiseks. Meie puhul kattub see käsk peaaegu sellega, mida te kasutasite lähtekoodist käivitamiseks. server.py näitab, et
Meeskond EXPOSE ootab andmeid kaudu porti server . See käsk ei 8080pakku ports . See on midagi nagu dokumentatsioon, mis on vajalik sadama avamisekskonteineri käivitamisel. 8080 Rakenduse konteinerimiseks ette valmistamine

1) Määrake järgmised keskkonnamuutujad. Asendage

1) Määrake järgmised keskkonnamuutujad. Asendage PROJECT_ID oma GCP projekti ID-ga.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

Kasutatavate väärtustega PROJECT_ID ja GCR_REPO Dokkeri pilti määrate, kui koostate ja saadate selle privaatse konteineri registrisse.

2) Määrake vaikimisi GCP projekt käsurea tööriistale gcloud.

gcloud config set project $PROJECT_ID

3) Määrake vaikimisi tsoon käsurea tööriistale gcloud.

gcloud config set compute/zone us-central1-b

4) Veenduge, et konteineri registri teenus oleks GCP projektis lubatud.

gcloud services enable containerregistry.googleapis.com

Serveri konteinerimine

Liikuge katalooge, kus näidis asub server:

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

Koostage pilt järgmise abil Dockerfile ja keskkonnamuutujatega, mille määrasite varem:
```
docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1 .
```

Parameeter -t tähistab Dokkeri sildi. See on pildi nimi, mida kasutate konteineri juurutamisel.

Saatke pilt konteineri registrisse:

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

Konteinerimise laadimisgenereerija

1) Liikuge katalooge, kus näidis asub loadgen:

cd ../loadgen

2) Koostage pilt:

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

3) Saatke pilt konteineri registrisse:

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

Piltide nimekirja vaatamine

Vaadake pilte registris ja veenduge, et pildid on saadetud:

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

Käsk annab välja just saadetud piltide nimed:

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

GKE klastri loomine.

Need konteinerid oleks saanud käivitada Cloud Shelli virtuaalmasinas või arvutis käsuga docker run. Kuid tootmis keskkonnas on vajalik viis konteinerite keskse orkestreerimise võimaldamiseks. Näiteks on vajalik süsteem, mis jälgib, et konteinerid töötaksid alati, ja on vaja võimalust suurendada mahutavust ning käivitada täiendavad konteinerite eksemplarid, kui liiklus suureneb.

Konteinerirakenduste käivitamiseks saab kasutada GKE. GKE on konteinerite orkestreerimisplatvorm, mis ühendab virtuaalsed masinad klastriks. Iga virtuaalne masin nimetatakse sõlmeks. GKE klastrid põhinevad avatud lähtekoodiga Kubernetes klastrihalduse süsteemil. Kubernetes pakub mehhanisme, kuidas suhelda klastriga.

GKE klastri loomine:

1) Klastri loomine:

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

Meeskond gcloud loob istioready klastri GCP projektis ja vaikimisi tsoonis, mille te määrate. Soovitame vähemalt 4 sõlme ja virtuaalmasinat Istio käivitamiseks. n1-standard-2.

Meeskond loob klastrit vaid mõne minutiga. Kui klaster on valmis, annab meeskond sarnase tulemuse. teate.

2) Sisestage andmed käsurea tööriista. kubectl, et hallata klastrit:

gcloud container clusters get-credentials istioready

3) Nüüd saab Kubernetesega suhelda kubectl. Näiteks järgmise käsu abil saab teada sõlmede staatuse:

kubectl get nodes

Käsk väljastab nimekirja sõlmedest:

NIMI                                    STAAKUS  ROLLID    VANUS    VERSIOON
gke-istoready-default-pool-dbeb23dc-1vg0   Valmis    <none>   99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-36z5   Valmis    <none>   100s   v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-fj7s   Valmis    <none>   99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-wbjw   Valmis    <none>   99s    v1.13.6-gke.13

Kubernetesi põhikontseptsioonid

Skeemil on kujutatud rakendust GKE-s:

Enne konteinerite juurutamist GKE-s tutvuge Kubernetesi põhikontseptsioonidega. Lõpus on lingid, kui soovite rohkem teada.

Sõlmed ja klastrid. GKE-s on sõlm virtuaalne masin. Teistel Kubernetes platvormidel võib sõlm olla arvuti või virtuaalne masin. Klaster on sõlmede kogum, mida saab pidada ühtseks ja kuhu te juurutate konteineriseeritud rakenduse.
Pod'id. Kubernetesis käivitatakse konteinerid pod'ides. Pod Kubernetesis on jagamatu üksus. Pod sisaldab ühte või mitut konteinerit. Te käivitate konteinerid server ja loadgen erinevates pod'ides. Kui pod'is on mitu konteinerit (näiteks rakenduse server ja proksi), siis konteinerid haldatakse kui ühtne objekti ja jagavad pod'i ressursse.
Juhtimised. Kubernetesis on juhtimine objekt, mis esindab identsete pod'ide kogumit. Juhtimine käivitab mitu pod'i koopiat, mis on jaotatud klastrite sõlmedele. Juhtimine asendab automaatselt pod'id, mis on ebaõnnestunud või ei reageeri.
Kubernetes Service. Kui te käivitate rakenduse koodi GKE's, muutub ühendus loadgen ja server. Kui käivitasite teenuseid virtuaalses Cloud Shelli masina või arvuti peal, saatsite päringud server aadressile localhost:8080. Pärast GKE'sse juurutamist käivitatakse pod'id saadaval olevates sõlmedes. Vaikimisi ei saa te juhtida, millisel sõlmel pod on käivitatud, seega ei pod'id oma IP-aadresse.
IP-aadressi saamiseks server, tuleb määratleda võrgustiku abstraktsioon pod'ide kohal. See on Kubernetes Service. Kubernetesi teenus pakub püsivat lõpp-punkti pod’ide rühmale. On mitmeid teenuse tüüpe. server kasutab LoadBalancer, mis pakuvad välisest IP-aadressi, et suhelda server klastri väljapoolt.
Kubernetes sisaldab ka sisseehitatud DNS-süsteemi, mis määrab DNS-nimesid (näiteks helloserver.default.cluster.local), teenustele. Tänu sellele saavad pod’id klastri sees suhelda teiste pod’idega püsiva aadressi kaudu. DNS-nime ei saa kasutada klastri välised, näiteks Cloud Shellis või arvutis.

Kubernetesi manifestid

Kui sa kä skite rakenduse lähtekoodist, kasutasite imperatiivset käsku python3

server.py

Imperatiivsuse mõisted tähendavad tegusõna: „tee seda“.

Kubernetes kasutab deklaratiivset mudelit. See tähendab, et me ei ütle Kubernetesile, mida täpselt teha, vaid kirjeldame soovitud olekut. Näiteks käivitab ja peatab Kubernetes pod’e vastavalt vajadusele tagamaks, et süsteemi tegelik olek vastaks soovitule.

Soovitud olekut määrate te manfestides, või failides YAML. YAML-fail sisaldab spetsifikatsioone ühe või mitme Kubernetes’i objekti kohta.

Näites on YAML-fail server ja loadgen. Iga YAML fail määrab Kubernetes'i objekti ja teenuse soovitud oleku.

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 määrab objekti tüübi.
metadata.name määrab juurutamise nime.
Esimene väli spec sisaldab soovitud oleku kirjeldust.
spec.replicas määrab soovitud pod'ide arvu.
Jaotis spec.template määratleb pod'i шаблон. Pod'i spetsifikatsioonis on väli pilt, kus määratakse pildi nimi, mida tuleb konteineriregistrist saada.

Teenust määratletakse järgmiselt:

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

LoadBalancer: kliendid saadavad päringud koormuse tasakaalustaja IP-aadressile, millel on püsiv IP-aadress ja mis on kergesti kättesaadav klastri väljast.
targetPort: nagu mäletate, käsk EXPOSE 8080 ühes Dockerfile ei määranud porte. Te määrate pordi 8080, et oleks võimalik suhelda konteineriga server klastri väljast. Meie puhul hellosvc.default.cluster.local:80 (lühipealkiri: hellosvc) vastab pordile 8080 podi IP-aadressid helloserver.
port: see on porti number, kuhu teised teenused klastris saadavad päringud.

loadgen.yaml

Juhtimise objekt loadgen.yaml on sarnane server.yaml. Erinevus seisneb selles, et juhtimise objekt sisaldab jaotist env. See määratleb keskkonnamuutujad, mis on vajalikud loadgen ja mille olete määranud rakenduse lähtekoodist käivitamisel.

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

Jah loadgen ei võta vastu sissetulevaid päringuid, väljale type on märgitud ClusterIP. See tüüp annab püsiva IP-aadressi, mida saavad kasutada klastris olevad teenused, kuid see IP-aadress ei ole saadaval välistele klientidele.

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

Konteinerite juurutamine GKE-is

1) Liikuge katalooge, kus näidis asub server:

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

2) Avage server.yaml tekstiredaktorist.
3) Asendage nimi väljale pilt teie Docker pildi nimel.

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

Asenda PROJECT_ID oma GCP projekti ID-ga.
4) Salvesta ja sulge server.yaml.
5) Suvige YAML-fail Kubernetesesse:

kubectl apply -f server.yaml

Pärast edukat täitmist annab käsk järgmise koodi:

deployment.apps/helloserver created
service/hellosvc created

6) Liikuge katalooge, kus asub loadgen:

cd ../loadgen

7) Avage loadgen.yaml tekstiredaktorist.
8) Asenda nimi välja pilt teie Docker pildi nimel.

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

Asenda PROJECT_ID oma GCP projekti ID-ga.
9) Salvesta ja sulge loadgen.yaml, sulge tekstiredaktor.
10) Suvige YAML-fail Kubernetesesse:

kubectl apply -f loadgen.yaml

Pärast edukat täitmist annab käsk järgmise koodi:

deployment.apps/loadgenerator created
service/loadgensvc created

11) Kontrolli podide staatust:

kubectl get pods

Käsk näitab staatust:

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

12) Tõmmake rakenduse logid podist loadgen. Asenda POD_ID eelneva vastuse ID-ga.

kubectl logs loadgenerator-POD_ID

13) Saage välised IP-aadressid hellosvc:

kubectl get service

Käsku vastus näeb välja umbes nii:

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) Saatke päring hellosvc: asenda EXTERNAL_IP välise IP-aadressiga hellosvc.

curl http://EXTERNAL_IP

Hakkame tegelema Istio'ga

Teil on juba GKE's rakendus, mis on juurutatud. loadgen võib kasutada Kubernetes DNS-i (hellosvc:80), et saata päringuid server, ja saate suunata päringud server välist IP-aadressi kaudu. Kuigi Kubernetesel on palju võimalusi, puudub teave teenuste kohta:

Kuidas teenused omavahel suhtlevad? Millised on teenuste vahelised suhted? Kuidas liigub liiklus teenuste vahel? Te teate, et loadgen saab päringuid server, aga kujutage ette, et te ei tea rakendusest midagi. Nendele küsimustele vastamiseks vaatame GKE's töötavate podide nimekirja.
Mõõdikud. Kui kaua server vastab sissetulevale päringule? Kui palju päringute sekundis jõuab serverisse? Kas ta väljastab vigu?
Julgeoleku andmed. Liiklus loadgen ja server liigub lihtsalt läbi HTTP või mTLS?

Igaühele nendele küsimustele vastab Istio. Selleks paigaldab Istio sidecar-proksi Envoy iga pod'i juurde. Proksi Envoy püüab kinni kogu sissetuleva ja väljuva liikluse rakenduse konteinerites. See tähendab, et server ja loadgen saab sidecar-proksi Envoy kaudu, ja kogu liiklus loadgen kellele server möödub Envoy proksi kaudu.

Prokside vahelised ühendused moodustavad teenuste võrgu. Teenuste võrgu arhitektuur pakub kontrolleetappi Kubernetes'e kohal.

Kuna Envoy proksi töötavad oma konteinerites, saab Istio paigaldada GKE klastri peale, muutes rakenduskoodi pea olematult. Kuid olete teinud mõningaid ettevalmistusi rakenduse haldamiseks Istio abil:

Teenused kõikide konteinerite jaoks. Juhtimisplaanidele server ja loadgen on seotud Kubernetes teenuse kaudu. I even loadgen, millele ei laeku sisendeid, on teenus.
Teenuste portidel peavad olema nimed. Kuigi GKE teenuste portide nimed võivad olla nimeta, nõuab Istio porti nime vastavalt oma protokollile. YAML failis on sadam server nimetatakse http, sest server kasutab protokolli HTTP. Kui teenus oleks kasutanud gRPC, oleksite sadama nimetanud grpc.
Paigaldi on märgitud. Seega saate kasutada Istio liikluse haldamise funktsioone, näiteks liikluse jagamist ühe teenuse versioonide vahel.

Istio paigaldamine

Istio saab installida kahte moodi. Saate aktiveerida Istio on GKE laienduse või paigaldada avatud lähtekoodiga versiooni Istio klastris. Istio on GKE abil on lihtne hallata Istio paigaldamist ja värskendusi GKE klassi elutsükli jooksul. Kui vajate kõige uuemat versiooni Istio’st või rohkem kontrolli Istio juhtpaneeli konfiguratsiooni üle, installige avatud lähtekoodiga versioon, mitte Istio on GKE laiendus. Õige lähenemise leidmiseks lugege artiklit Kas mul on vaja Istio on GKE-d?.

Valige valik, tutvuge vastava juhendiga ja järgige juhiseid, et installida Istio klastris. Kui soovite kasutada Istio uut loodud rakendusega, lülitage sisse sidecar'i juurutamine nimede ruumidesse default.

Kustutus

Kuna Google Cloud Platformi kontolt võetakse tasu kasutatud ressursside eest, kustutage konteineriklaster, kui olete Istio installinud ja näidiserakendusega katsetanud. Sellega eemaldatakse kõik klassi ressursid, näiteks arvutusnäidikud, kettad ja võrguressursid.