🥇Príprava aplikácie na Istio

Istio je užitočný nástroj na prepojenie, ochranu a monitorovanie distribuovaných aplikácií. Istio využíva rôzne technológie na škálovanie nasadenia softvéru a jeho správy, vrátane kontajnerov na zabalenie kódu aplikácie a závislostí na nasadenie a Kubernetes na správu týchto kontajnerov. Preto, aby ste mohli pracovať s Istio, musíte vedieť, ako aplikácia s viacerými službami založená na týchto technológiách funguje. bez Istio. Ak sú vám tieto nástroje a pojmy už známe, bez váhania preskočte túto príručku a prejdite priamo na sekciu. Inštalácia Istio na Google Kubernetes Engine (GKE) alebo inštalácia rozšírenia Istio na GKE.

Toto je krok za krokom sprievodca, kde prejdeme celý proces od zdrojového kódu po kontajner na GKE, aby ste mali základné predstavy o týchto technológiách na príklade. Taktiež uvidíte, ako Istio využíva možnosti týchto technológií. Predpokladá sa, že neviete nič o kontajneroch, Kubernetes, service mesh alebo Istio.

Úlohy

V tejto príručke vykonáte nasledujúce úlohy:

Preskúmanie jednoduchého hello world aplikácie s viacerými službami.
Spustenie aplikácie zo zdrojového kódu.
Zabalenie aplikácie do kontajnerov.
Vytvorenie Kubernetes klastra.
Nasadenie kontajnerov do klastra.

Predtým, ako začnete

Postupujte podľa pokynov na aktiváciu Kubernetes Engine API:

Navštívte stránku Kubernetes Engine v konzole Google Cloud Platform.
Vytvorte alebo vyberte projekt.
Čakajte, kým bude API a súvisiace služby aktivované. Môže to trvať niekoľko minút.
Uistite sa, že vystavenie faktúr pre projekt Google Cloud Platform je nastavené. Zistite, ako aktivovať vystavenie faktúr.

V tejto príručke môžete použiť Cloud Shell, ktorý pripraví virtuálny stroj g1-small na Google Compute Engine s Linuxom založeným na Debiane alebo počítač s Linuxom alebo macOS.

Možnosť A: použitie Cloud Shell

Výhody používania Cloud Shell:

Vývojové prostredia Python 2 a Python 3 (vrátane virtualenv) sú úplne nakonfigurované.
Nástroje príkazového riadku gcloud, docker, git a kubectl, ktoré budeme používať, sú už nainštalované.
Máte na výber niekoľko textových editorov:
1. Editor kódu, ktorý sa otvorí ikonkou úpravy v hornej časti okna Cloud Shell.
2. Emacs, Vim alebo Nano, ktoré sa otvárajú z príkazového riadku v Cloud Shell.

Aby ste mohli použiť Cloud Shell:

Prejdite do konzoly GCP.
Kliknite na tlačidlo Aktivovať Cloud Shell (Aktivovať Cloud Shell) v hornej časti okna konzoly GCP.

V dolnej časti konzoly GCP v novom okne sa otvorí relácia Cloud Shell s príkazovým riadkom.

Možnosť B: použitie nástrojov príkazového riadku lokálne

Ak budete pracovať na počítači s Linuxom alebo macOS, musíte nastaviť a nainštalovať nasledujúce komponenty:

Nastavte vývojové prostredie Python 3 a Python 2.
Nainštalujte Cloud SDK s nástrojom príkazového riadku gcloud.
Nainštalujte kubectl — nástroj príkazového riadku na prácu s Kubernetes.
```
gcloud components install kubectl
```
Nainštalujte Docker Community Edition (CE). Budete používať nástroj príkazového riadku docker, na vytváranie obrazov kontajnerov pre ukážkovú aplikáciu.
Nainštalujte nástroj verzií Git, aby ste získali ukážkovú aplikáciu z GitHubu.

Stiahnutie ukážkového kódu

Stiahnite zdrojový kód helloserver:

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

Prejdite do adresára ukážkového kódu:
```
cd istio-samples/sample-apps/helloserver
```

Preskúmanie aplikácie s viacerými službami

Ukážková aplikácia je napísaná v Pythone a pozostáva z dvoch komponentov, ktoré komunikujú pomocou REST:

server: jednoduchý server s jednou koncovou bodom GET, /, ktorý vypisuje „hello world“ na konzole.
loadgen: skript, ktorý posiela prenos na server, s nastaviteľným počtom požiadaviek za sekundu.

Spustenie aplikácie zo zdrojového kódu

Ak chcete preskúmať ukážkovú aplikáciu, spustite ju v Cloud Shell alebo na počítači.
1) V adresári istio-samples/sample-apps/helloserver spustite server:

python3 server/server.py

Pri spustení sa zobrazuje nasledujúce: server INFO:root:Spúšťanie servera...

2) Otvorte ďalšie okno terminálu, aby ste mohli posielať požiadavky na

. Ak používate Cloud Shell, kliknite na ikonu pridať, aby ste otvorili ďalšiu reláciu. server3) Odešlite požiadavku na
curl http://localhost:8080 server:

server odpovedá:

4) Z adresára, kam ste stiahli ukážkový kód, prejdite do adresára, ktorý obsahuje

Hello World!

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

5) Vytvorte nasledujúce premenné prostredia:

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

6) Spustite

virtualenv --python python3 env virtualenv:

7) Aktivujte virtuálne prostredie:

source env/bin/activate

8) Nainštalujte požiadavky pre

pip3 install -r requirements.txt loadgen:

9) Spustite

python3 loadgen.py loadgen:

vypíše približne nasledujúcu správu:

Pri spustení sa zobrazuje nasledujúce: loadgen Spúšťanie loadgen: 2019-05-20 10:44:12.448415 5 požiadaviek dokončených na http://localhost:8080

V inom okne terminálu

vypíše na konzole približne nasledujúce správy: server 127.0.0.1 - - [21/Jun/2019 14:22:01] "GET / HTTP/1.1" 200 - INFO:root:GET požiadavka, Cesta: / Hlavičky: Host: localhost:8080 User-Agent: python-requests/2.22.0 Accept-Encoding: gzip, deflate Accept: */*

127.0.0.1 - - [21/Jún/2019 14:22:01] "GET / HTTP/1.1" 200 -
INFO:root:Žiadosť GET,
Cesta: /
Hlavice:
Hostiteľ: localhost:8080
User-Agent: python-requests/2.22.0
Accept-Encoding: gzip, deflate
Accept: */*

Z hľadiska siete funguje celá aplikácia na jednom hoste (lokálnom počítači alebo virtuálnom stroji Cloud Shell). Preto možno používať localhost, na odosielanie požiadaviek na server.
10) Na zastavenie loadgen a server, zadajte Ctrl-c v každom terminálovom okne.
11) V terminálovom okne loadgen deaktivujte virtuálne prostredie:

deactivate

Balenie aplikácie do kontajnerov

Aby ste spustili aplikáciu na GKE, musíte zabaliť ukážku aplikácie — server a loadgen — v kontajnery. Kontajner je spôsob, ako zabaliť aplikáciu tak, aby bola izolovaná od prostredia.

Na zabalenie aplikácie do kontajnera potrebujete Dockerfile. Dockerfile — je to textový súbor, kde sú definované príkazy na zostavenie zdrojového kódu aplikácie a jej závislostí do obrazu Docker. Po zostavení nahrajete obraz do registra kontajnerov, ako napríklad Docker Hub alebo Container Registry.

V príklade už existuje Dockerfile pre server a loadgen so všetkými potrebnými príkazmi na zostavenie obrazov. Nižšie — Dockerfile pre 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" ]

Tím FROM python:3-slim as base prikazuje Dockeru, aby používal posledný obraz Python 3 ako základný.
Tím COPY . . skopíruje zdrojové súbory do aktuálneho pracovného adresára (v našom prípade iba server.py) do súborového systému kontajnera.
ENTRYPOINT určuje príkaz, ktorý sa používa na spustenie kontajnera. V našom prípade tento príkaz takmer zodpovedá tomu, ktorý ste použili na spustenie server.py zo zdrojového kódu.
Tím EXPOSE uvádza, že server očakáva dáta cez port 8080. Tento príkaz ne poskytuje porty.Je to niečo ako dokumentácia, ktorá je potrebná na otvorenie portu 8080 pri spustení kontajnera.

Príprava na kontajnerizáciu aplikácie

1) Nastavte nasledujúce premenné prostredia. Nahradíte PROJECT_ID identifikátorom svojho projektu GCP.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

S použitím hodnôt PROJECT_ID a GCR_REPO označíte obraz Docker pri jeho zostavení a odoslaní do súkromného Container Registry.

2) Nastavte predvolený projekt GCP pre nástroj príkazového riadku gcloud.

gcloud config set project $PROJECT_ID

3) Nastavte predvolenú zónu pre nástroj príkazového riadku gcloud.

gcloud config set compute/zone us-central1-b

4) Uistite sa, že služba Container Registry je povolená v projekte GCP.

gcloud services enable containerregistry.googleapis.com

Kontejnerizácia servera

Prejdite do adresára, kde sa nachádza príklad server:

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

Spoznajte obraz pomocou Dockerfile a premenných prostredia, ktoré ste definovali skôr:
```
docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1 .
```

Parameter -t predstavuje tag Docker. To je názov obrazu, ktorý používate pri nasadzovaní kontajnera.

Odošlite obraz do Container Registry:

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

Kontejnerizácia loadgen

1) Prejdite do adresára, kde sa nachádza príklad loadgen:

cd ../loadgen

2) Spoznať obraz:

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

3) Odošlite obraz do Container Registry:

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

Zobrazenie zoznamu obrazov

Prehrajte zoznam obrazov v repozitári a uistite sa, že obrazy boli odoslané:

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

Príkaz vráti názvy práve odoslaných obrazov:

NÁZOV
gcr.io/PROJECT_ID/preparing-istio/helloserver
gcr.io/PROJECT_ID/preparing-istio/loadgen

Vytvorenie GKE klastera.

Tieto kontajnery by mohli bežať na virtuálnej mašine Cloud Shell alebo na počítači príkazom docker run. Ale v produkčnom prostredí potrebujeme spôsob, ako centralizovane orchestráciou kontajnerov. Napríklad, potrebujeme systém, ktorý zabezpečí, aby kontajnery vždy fungovali, a potrebujeme spôsob, ako zväčšovať a spúšťať ďalšie inštancie kontajnerov, ak sa zvýši prevádzka.

Na spustenie kontajnerových aplikácií môžeme použiť GKE. GKE je platforma na orchestráciu kontajnerov, ktorá spája virtuálne mašiny do klasteru. Každá virtuálna mašina sa nazýva uzol. Klastery GKE sú založené na open-source systéme správy klastrov Kubernetes. Kubernetes poskytuje mechanizmy na interakciu s klastrom.

Vytvorenie GKE klastera:

1) Vytvorte klaster:

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

Tím gcloud vytvorí klaster istioready v projekte GCP a v predvolenom formulári, ktoré ste zadali. Odporúčame mať aspoň 4 uzly a virtuálnu mašinu n1-standard-2.

Príkaz vytvorí klaster za niekoľko minút. Po pripravení klastera príkaz vráti niečo podobné správa.

2) Získajte údaje o účte do príkazového nástroja kubectl, aby ste mohli spravovať klaster:

gcloud container clusters get-credentials istioready

3) Teraz môžete komunikovať s Kubernetes cez kubectl. Napríklad, nasledujúcim príkazom sa môžete dozvedieť stav uzlov:

kubectl get nodes

Príkaz vráti zoznam uzlov:

Názov                                       Stav   Úlohy    Vek    Verzia
gke-istoready-default-pool-dbeb23dc-1vg0   Pripravený    <žiadne>   99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-36z5   Pripravený    <žiadne>   100s   v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-fj7s   Pripravený    <žiadne>   99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-wbjw   Pripravený    <žiadne>   99s    v1.13.6-gke.13

Kľúčové pojmy Kubernetes

Na schéme je zobrazená aplikácia na GKE:

Predtým, ako nasadíte kontajnery v GKE, zoznámte sa s kľúčovými pojmami Kubernetes. Na konci sú odkazy, ak chcete získať viac informácií.

Uzly a klastry. V GKE je uzol virtuálny stroj. Na iných platformách Kubernetes môže byť uzlom počítač alebo virtuálny stroj. Klastr je súbor uzlov, ktoré môžete považovať za celok a kde nasadzujete kontajnerizovanú aplikáciu.
Pod'y. V Kubernetes sa kontajnery spúšťajú v pod'y. Pod v Kubernetes je nedeliteľná jednotka. Pod obsahuje jeden alebo viac kontajnerov. Nasadzujete kontajnery server a loadgen v samostatných pod'y. Keď je v pod'e viacero kontajnerov (napríklad server aplikácie a proxy server), kontajnery sa spravujú ako jediný objekt a spoločně zdieľajú zdroje pod'a.
Nasadenia. V Kubernetes je nasadenie objekt, ktorý predstavuje súbor identických pod'y. Nasadenie spúšťa niekoľko replik pod'y, rozdelených medzi uzly klastra. Nasadenie automaticky nahrádza pod'y, ktoré zlyhali alebo neodpovedajú.
Služba Kubernetes. Pri spúšťaní kódu aplikácie v GKE sa mení pripojenie medzi loadgen a server. Keď ste spúšťali služby na virtuálnom stroji Cloud Shell alebo na počítači, posielali ste požiadavky na server na adrese localhost:8080. Po nasadení v GKE pod'y bežia na dostupných uzloch. Predvolene nemôžete spravovať, na ktorom uzle beží pod, takže nemá pod'y žiadne trvalé IP adresy.
Aby ste získali IP adresu pre server, musíte definovať abstrakciu siete nad pod'ami. To je služba Kubernetes. Služba Kubernetes poskytuje trvalý koncový bod pre súbor pod'y. Existuje niekoľko typov služieb. server používa LoadBalancer, ktorý poskytuje vonkajšiu IP adresu na kontaktovanie server z vonku klastra.
V Kubernetes je tiež zabudovaný systém DNS, ktorý prideľuje názvy DNS (napríklad helloserver.default.cluster.local) službám. Vďaka tomu sa pod’y v rámci klastra spájajú s inými pod’mi v klastri za stálej adresy. Názov DNS nemožno použiť mimo klastra, napríklad v Cloud Shell alebo na počítači.

Manifesty Kubernetes

Keď ste spúšťali aplikáciu zo zdrojového kódu, použili ste imperatívny príkaz python3

server.py

Imperativnosť znamená sloveso: „urob to“.

Kubernetes používa deklaračnú model. To znamená, že nehovoríme Kubernetes, čo presne má robiť, ale opisujeme požadovaný stav. Napríklad Kubernetes spúšťa a zastavuje pod’y podľa potreby, aby sa skutočný stav systému zhodoval s požadovaným.

Požadovaný stav uvádzate v manifestoch alebo súboroch YAML. Súbor YAML obsahuje špecifikácie pre jeden alebo viac objektov Kubernetes.

V príklade sa nachádza súbor YAML pre server a loadgen. Každý súbor YAML uvádza požadovaný stav objektu nasadenia a služby Kubernetes.

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

druh uvádza typ objektu.
metadata.name uvádza názov nasadenia.
Prvé pole spec obsahuje opis požadovaného stavu.
spec.replicas uvádza požadovaný počet pod’ov.
Sekcia spec.template definuje šablónu pod’a. V špecifikácii pod’ov je pole obrázok, kde je uvedené meno obrazu, ktorý sa má stiahnuť z Container Registry.

Služba sa definuje nasledovne:

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

LoadBalancer: klienti odosielajú požiadavky na IP adresu vyrovnávača zaťaženia, ktorý má stále IP adresu a je prístupný z vonkajšej strany klastra.
targetPort: ako si pamätáte, príkaz EXPOSE 8080 v Dockerfile neuvádzal porty. Poskytujete port 8080, aby sa dalo skontaktovať s kontajnerom server z vonkajšej strany klastra. V našom prípade hellosvc.default.cluster.local:80 (krátke meno: hellosvc) zodpovedá portu 8080 IP adresy pod’a helloserver.
port: je to číslo portu, na ktorý budú ostatné služby v klastri odosielať požiadavky.

loadgen.yaml

Objekt nasadenia v loadgen.yaml je podobný server.yaml. Rozdiel je v tom, že objekt nasadenia obsahuje sekciu env. Definuje premenné prostredia, ktoré sú potrebné loadgen a ktoré ste nainštalovali pri spustení aplikácie zo zdrojového kódu.

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

Jedna loadgen neprijíma prichádzajúce požiadavky, pre pole type uvedené ClusterIP. Tento typ poskytuje trvalú IP adresu, ktorú môžu používať služby v klustre, ale táto IP adresa nie je poskytovaná externým klientom.

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

Nasadenie kontajnerov v GKE

1) Prejdite do adresára, kde sa nachádza príklad server:

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

2) Otvorte server.yaml v textovom editore.
3) Nahraďte názov v poli obrázok názvom vášho Docker obrazu.

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

Nahradiť PROJECT_ID identifikátorom vášho projektu GCP.
4) Uložte a zatvorte server.yaml.
5) Nasadte súbor YAML do Kubernetes:

kubectl apply -f server.yaml

Po úspešnom dokončení príkaz vydá nasledujúci kód:

deployment.apps/helloserver created
service/hellosvc created

6) Prejdite do adresára, kde sa nachádza loadgen:

cd ../loadgen

7) Otvorte loadgen.yaml v textovom editore.
8) Nahraďte názov v poli obrázok názvom vášho Docker obrazu.

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

Nahradiť PROJECT_ID identifikátorom vášho projektu GCP.
9) Uložte a zatvorte loadgen.yaml, zatvorte textový editor.
10) Nasadte súbor YAML do Kubernetes:

kubectl apply -f loadgen.yaml

Po úspešnom dokončení príkaz vydá nasledujúci kód:

deployment.apps/loadgenerator created
service/loadgensvc created

11) Skontrolujte stav podov:

kubectl get pods

Príkaz ukazuje stav:

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

12) Získajte logy aplikácie z podu loadgen. Nahraďte POD_ID identifikátorom z predchádzajúcej odpovede.

kubectl logs loadgenerator-POD_ID

13) Získajte externé IP adresy hellosvc:

kubectl get service

Odpoveď príkazu vyzerá približne takto:

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) Odošlite požiadavku na hellosvc: nahraďte EXTERNAL_IP externou IP adresou hellosvc.

curl http://EXTERNAL_IP

Začneme s Istio

Už máte aplikáciu nasadenú v GKE. loadgen môže používať Kubernetes DNS (hellosvc:80), aby posielal požiadavky na server, a môžete posielať požiadavky na server podľa externého IP adresy. Hoci má Kubernetes veľa možností, chýba niektoré informácie o službách:

Ako interagujú služby? Aké sú vzťahy medzi službami? Ako prebieha prenos dát medzi službami? Ste si vedomí, že loadgen posiela požiadavky na server, ale predstavte si, že o aplikácii nič neviete. Aby sme odpovedali na tieto otázky, pozrieme sa na zoznam spustených podov v GKE.
Metódy. Ako dlho server odpovedá na prichádzajúcu požiadavku? Koľko požiadaviek za sekundu prichádza na server? Zobrazuje chybové správy?
Informácie o bezpečnosti. Prenos dát medzi loadgen a server prechádza jednoducho cez HTTP alebo cez mTLS?

Na všetky tieto otázky odpovedá Istio. Na tento účel Istio umiestňuje sidecar proxy Envoy do každého podu. Proxy Envoy zachytáva všetok prichádzajúci a odchádzajúci prenos dát k aplikáciovým kontajnerom. To znamená, že server a loadgen dostáva prostredníctvom sidecar proxy Envoy a celý prenos dát od loadgen k server prechádza cez proxy Envoy.

Spojenia medzi proxy Envoy tvoria service mesh. Architektúra service mesh poskytuje úroveň kontroly nad Kubernetes.

Keďže proxy Envoy bežia vo svojich kontajneroch, Istio sa dá nainštalovať nad klaster GKE takmer bez zmeny kódu aplikácie. Ale vykonali ste určité úkony na prípravu aplikácie na správu pomocou Istio:

Služby pre všetky kontajnery. Ku nasadeniam server a loadgen je priradená jedna služba Kubernetes. Aj pre loadgen, ku ktorému neprichádzajú prichádzajúce požiadavky, existuje služba.
Porty v službách musia mať názvy. Hoci v GKE môžu byť porty služieb bez názvu, Istio vyžaduje, aby ste uviedli názov portu podľa jeho protokolu. V súbore YAML je port pre server sa nazýva http, pretože server používa protokol HTTP. Keby service používal gRPC, port by ste nazvali grpc.
Nasadenia sú označené. Preto môžete využívať funkcie správy prenosu Istio, napríklad rozdeľovať prenos medzi verziami jednej služby.

Inštalácia Istio

Istio sa dá nainštalovať dvoma spôsobmi. Môžete povoliť rozšírenie Istio on GKE alebo nainštalovať open-source verziu Istio na klastri. S Istio on GKE môžete jednoducho spravovať inštaláciu a aktualizáciu Istio v rámci životného cyklu klastru GKE. Ak potrebujete najnovšiu verziu Istio alebo väčšiu kontrolu nad konfiguráciou ovládacieho panela Istio, nainštalujte open-source verziu namiesto rozšírenia Istio on GKE. Pre rozhodovanie o prístupe si prečítajte článok Potrebujem Istio on GKE?.

Vyberte možnosť, preštudujte si príslušnú príručku a postupujte podľa pokynov na inštaláciu Istio na klastri. Ak chcete použiť Istio s práve nasadenou aplikáciou, aktivujte nasadenie sidecar’ov pre názvové priestory default.

Vymazanie

Aby sa vám z účtu Google Cloud Platform nezúčtovali náklady na zdroje použité v tejto príručke, odstráňte kontajnerový klaster po nainštalovaní Istio a po tom, ako si vyskúšate ukážkovú aplikáciu. Týmto spôsobom sa vymažú všetky zdroje klastru, ako sú výpočtové inštancie, disky a sieťové zdroje.