🥇Az alkalmazás előkészítése az Istio számára

Az Istio egy kényelmes eszköz elosztott alkalmazások összekapcsolására, védelmére és figyelésére. Az Istio különböző technológiákat használ a szoftverek skálázható indításához és kezeléséhez, beleértve a konténereket az alkalmazáskód és a függőségek csomagolására, valamint a Kubernetes-t ezen konténerek kezelésére. Ezért az Istio használatához tudnia kell, hogyan működik egy több szolgáltatásból álló alkalmazás ezen technológiák alapján. nélkül Istio. Ha ezek az eszközök és fogalmak már ismerősek önnek, nyugodtan ugorjon át ezt az útmutatót, és lépjen közvetlenül a szakaszra. Az Istio telepítése a Google Kubernetes Engine (GKE) szolgáltatásra. vagy a bővítmény telepítése. Istio GKE-n..

Ez egy lépésről lépésre útmutató, amely bemutatja az egész folyamatot a forrástól a konténerig a GKE-n, hogy alapvető betekintést nyerjen ezen technológiákba példaképpen. Ezenkívül láthatja, hogyan használja az Istio ezen technológiák lehetőségeit. Előfeltételezzük, hogy nem tud semmit a konténerekről, a Kubernetes-ről, a szolgáltatás-hálózatról vagy az Istio-ról.

Feladatok

Ebben az útmutatóban a következő feladatokat fogja végrehajtani:

Egy egyszerű hello world alkalmazás több szolgáltatással.
Az alkalmazás indítása forráskódból.
Az alkalmazás csomagolása konténerekbe.
Kubernetes klaszter létrehozása.
Konténerek telepítése a klaszterbe.

Mielőtt elkezdené

Kérjük, kövesse az utasításokat a Kubernetes Engine API engedélyezéséhez:

Látogasson el a Kubernetes Engine oldalra a Google Cloud Platform konzoljában.
Hozzon létre vagy válasszon projektet.
Várjon, amíg az API és a kapcsolódó szolgáltatások engedélyezésre kerülnek. Ez eltarthat néhány percig.
Győződjön meg róla, hogy a Google Cloud Platform projekthez be van állítva a számlázás. Tudja meg, hogyan lehet engedélyezni a számlázást..

Ebben az útmutatóban használhatja a Cloud Shelt, amely előkészít egy virtuális gépet. g1-small a Google Compute Engine szolgáltatásban Debian alapú Linuxra vagy Linux vagy macOS számítógépre.

A változat A: a Cloud Shell használata.

A Cloud Shell használatának előnyei:

A Python 2 és Python 3 fejlesztői környezetek (beleértve a virtualenv) teljesen be vannak állítva.
A parancssori eszközök gcloud, docker, git és kubectl, amelyeket használni fogunk, már telepítve vannak.
Több szövegszerkesztő közül választhat.:
1. A kód szerkesztője, amely a Cloud Shell ablakának felső részén található szerkesztési ikonra kattintva nyílik meg.
2. Az Emacs, Vim vagy Nano, amelyek a Cloud Shell parancssorából indíthatók.

A Cloud Shell használatához Lépjen a GCP konzolba.:

Aktiválja a Cloud Shelt.
Kattintson a gombra Aktiválja a Cloud Shell (Cloud Shell aktiválása) a GCP konzol ablakának tetején.

Az alsó részén a GCP konzolnak új ablakban megnyílik egy Cloud Shell munkaütem a parancssorral.

B verzió: parancssori eszközök használata helyben

Ha Linux vagy macOS számítógépen dolgozik, szükséges beállítani és telepíteni az alábbi komponenseket:

Állítsa be a Python 3 és Python 2 fejlesztői környezete.
Cloud SDK telepítése parancssori eszközzel gcloud.
Telepítse kubectl — parancssori eszköz a Kubernetes.
```
gcloud components install kubectl
```
Telepítse Docker Community Edition (CE). A parancssori eszközt fogja használni docker, hogy konténerképeket hozzon létre a példaalkalmazás számára.
Telepítse a verziókezelő eszközt, a Git-et, hogy megkapja a példaalkalmazást a GitHub-ból.

Példakód letöltése

Töltse le a forráskódot helloserver:

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

Navigáljon a példa kód mappájába:

cd istio-samples/sample-apps/helloserver

Több szolgáltatású alkalmazás tanulmányozása

A példaalkalmazás Python nyelven íródott, és két komponenst tartalmaz, amelyek a következő segítségével lépnek kapcsolatba: REST:

server: egy egyszerű szerver egy végponttal GET, /, amely "hello world"-ot ír ki a konzolra.
loadgen: egy szkript, amely forgalmat küld a server, testreszabott kérések másodpercenkénti számával.

Az alkalmazás indítása a forráskódból

A példaalkalmazás tanulmányozásához indítsa el a Cloud Shell-ben vagy a számítógépén.
1) A istio-samples/sample-apps/helloserver mappában indítsa el server:

python3 server/server.py

A futtatáskor server a következő jelenik meg:

INFO:root:Starting server...

2) Nyisson meg egy másik terminálablakot, hogy kéréseket küldhessen a server. Ha Cloud Shell-t használ, kattintson a plusz ikonra, hogy megnyisson egy másik munkamenetet.
3) Küldjön kérést a server:

curl http://localhost:8080

a szerver válasza:

Hello World!

4) Abból a könyvtárból, ahova letöltötte a példa kódot, lépjen be abba a könyvtárba, amely tartalmazza loadgen:

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

5) Hozzon létre az alábbi környezeti változókat:

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

6) Indítsa el virtualenv:

virtualenv --python python3 env

7) Aktiválja a virtuális környezetet:

source env/bin/activate

8) Telepítse a követelményeket loadgen:

pip3 install -r requirements.txt

9) Indítsa el loadgen:

python3 loadgen.py

A futtatáskor loadgen kb. a következő üzenetet írja ki:

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

Egy másik terminálablakban server kb. a következő üzeneteket írja ki a konzolra:

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

A hálózati szempontból az összes alkalmazás egy hoston (helyi számítógépen vagy Cloud Shell virtuális gépen) működik. Ezért használható localhost, hogy kéréseket küldjön a server.
10) A leállításhoz loadgen és server, írja be Ctrl-c minden terminálablakban.
11) A terminálablakban loadgen deaktiválja a virtuális környezetet:

deactivate

Az alkalmazás konténerbe csomagolása

Ahhoz, hogy az alkalmazást GKE-n futtassuk, az alkalmazás példáját csomagolni kell — server és loadgen — ehhez tízszer kevesebb hardver szükséges. konténerek. A konténer egy módszer az alkalmazás csomagolására, hogy elszigetelje azt a környezettől.

Egy alkalmazás konténerbe csomagolásához szükséges Dockerfile. Dockerfile — ez egy szöveges fájl, amely tartalmazza az alkalmazás forráskódjának és annak függőségeinek összeállítására vonatkozó parancsokat egy Docker képre. Az összeállítás után a képet fel kell tölteni egy konténerregistry-be, például a Docker Hub-ba vagy a Container Registry.

A példában már megtalálhatóak Dockerfile a server és loadgen minden szükséges parancs a képek összeszereléséhez. Lent látható: Dockerfile a 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/*

# Engedélyezze a puffertelen naplózást
FROM base as final
ENV PYTHONUNBUFFERED=1

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

WORKDIR /helloserver

# Csomagok átvétele a builderből
COPY --from=builder /usr/local/lib/python3.7/ /usr/local/lib/python3.7/

# Az alkalmazás hozzáadása
COPY . .

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

A parancs FROM python:3-slim as base a Docker engedélyezi a legújabb Python 3 alapként.
A parancs COPY. . a forrásterületeket másolja a jelenlegi munkakönyvtárba (esetünkben csak server.py) a konténer fájlrendszerébe.
ENTRYPOINT meghatározza azt a parancsot, amelyet a konténer indításához használnak. Esetünkben ez a parancs majdnem megegyezik azzal, amit a server.py forráskódból indított.
A parancs EXPOSE jelzi, hogy server adatokat vár a 8080porton keresztül. Ez a parancs nem nyújt portokat. Ez valami olyan, mint a dokumentáció, amely a port megnyitásához szükséges 8080 a konténer futtatásakor.

Az alkalmazás konténerizálásának előkészítése

1) Állítsa be a következő környezeti változókat. Cserélje le PROJECT_ID a GCP projekt azonosítójára.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

A értékek segítségével PROJECT_ID és GCR_REPO a Docker képet címkézi, amikor összegyűjti és elküldi a privát Container Registry-be.

2) Állítsa be az alapértelmezett GCP projektet a parancssori eszközhöz gcloud.

gcloud config set project $PROJECT_ID

3) Állítsa be az alapértelmezett zónát a parancssori eszközhöz gcloud.

gcloud config set compute/zone us-central1-b

4) Győződjön meg róla, hogy a Container Registry szolgáltatás engedélyezve van a GCP projektben.

gcloud services enable containerregistry.googleapis.com

Konténerizációs szerver

Lépjen be abba a könyvtárba, ahol a példa található server:

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

Készítse el a képet ezzel Dockerfile és a korábban meghatározott környezeti változókkal:
```
docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1 .
```

A parameter - folyamatosan „pingelni” (a leállításhoz nyomjuk meg a Ctrl+C kombinációt) megjeleníti a Docker címkét. Ez az a név, amelyet a konténer telepítésekor használ.

Töltse fel a képet a Container Registry-be:

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

Konténerizációs loadgen

1) Lépjen be abba a könyvtárba, ahol a példa található loadgen:

cd ../loadgen

2) Készítse el a képet:

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

3) Töltse fel a képet a Container Registry-be:

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

A képek listájának megtekintése

Tekintse meg a képek listáját a tárolóban, és győződjön meg róla, hogy a képek fel lettek tölve:

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

A parancs csak a frissen feltöltött képek neveit adja vissza:

NÉV
gcr.io/PROJECT_ID/preparing-istio/helloserver
gcr.io/PROJECT_ID/preparing-istio/loadgen

GKE klaszter létrehozása.

Ezek a konténerek futtathatók a Cloud Shell virtuális gépén vagy a gépen a következő parancs segítségével docker run. De a termelési környezethez központilag kell orkestrálni a konténereket. Például olyan rendszerre van szükség, amely figyelemmel kíséri, hogy a konténerek mindig működjenek, és szükség van egy módra, hogy növelni lehessen a létszámot és további konténer példányokat indítani, ha a forgalom növekszik.

Konténer alkalmazások futtatásához használható GKE. A GKE egy konténer orkestrációs platform, amely virtuális gépeket egy klaszterbe integrál. Minden virtuális gép csomópontnak nevezhető. A GKE klaszterek a Kubernetes nyílt forráskódú klaszterkezelő rendszerén alapulnak. A Kubernetes mechanizmusokat biztosít a klaszterrel való interakcióhoz.

GKE klaszter létrehozása:

1) Hozzon létre egy klasztert:

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

A parancs gcloud létrehozza az istioready klasztert a GCP projektben, és az alapértelmezett zónában, amelyet megadott. Az Istio futtatásához ajánlott legalább 4 csomópont és virtuális gép n1-standard-2.

A parancs néhány perc alatt létrehozza a klasztert. Amikor a klaszter készen áll, a parancs hasonlót ad vissza üzenet.

2) Adja meg a hitelesítő adatokat a parancssori eszközben kubectl, hogy ezzel irányíthassa a klasztert:

gcloud container clusters get-credentials istioready

3) Most már összekapcsolódhat a Kubernetes-szel a kubectl. Például a következő paranccsal ellenőrizheti a csomópontok állapotát:

kubectl get nodes

A parancs kiad egy csomópontok listáját:

NÉV                                       ÁLLAPOT   SZEREPEK    ÉLETTARTAM    VERZIÓ
gke-istoready-default-pool-dbeb23dc-1vg0   Kész    <none>   99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-36z5   Kész    <none>   100s   v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-fj7s   Kész    <none>   99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-wbjw   Kész    <none>   99s    v1.13.6-gke.13

Kubernetes kulcsszavak

A diagram a GKE-n futó alkalmazást mutatja:

A konténerek GKE-ben való telepítése előtt érdemes megismerni a Kubernetes kulcsszavakat. A végén találhatók linkek, ha többet szeretne megtudni.

Csomópontok és klaszterek. A GKE-ben a csomópont egy virtuális gép. Más Kubernetes-platformokon a csomópont lehet számítógép vagy virtuális gép. A klaszter egy csomópontokból álló halmaz, amelyet egy egységnek tekinthetünk, és ahol a konténerizált alkalmazást telepítjük.
Pod-ok. A Kubernetesben a konténerek pod-okban futnak. A pod a Kubernetesben egy oszthatatlan egység. A pod egy vagy több konténert tartalmaz. A konténereket a server és loadgen különálló pod-okban telepíti. Amikor több konténer van egy pod-ban (például az alkalmazás szervere és proxy-szerver), a konténereket egyetlen objektumként kezelik, és közösen osztoznak a pod erőforrásain.
Telepítések. A Kubernetesben a telepítés egy objektum, amely az azonos pod-ok egy csoportját reprezentálja. A telepítés több példányt indít el a pod-ból, amelyeket a klaszter csomópontjai között osztanak el. A telepítés automatikusan helyettesíti azokat a pod-okat, amelyek meghibásodtak vagy nem válaszolnak.
Kubernetes szolgáltatás. Amikor alkalmazás kódot futtatunk a GKE-ben, megváltozik a kapcsolat a loadgen és server-vel. Amikor szolgáltatásokat indított a Cloud Shell virtuális gépen vagy a számítógépén, kéréseket küldött a server címen localhost:8080. A GKE telepítése után a pod-ok a hozzáférhető csomópontokon futnak. Alapértelmezés szerint nincs lehetősége arra, hogy szabályozza, melyik csomóponton fut a pod, tehát a pod-ok nem rendelkeznek állandó IP-címekkel.
Az IP-cím megszerzéséhez server, egy hálózati absztrakciót kell meghatározni a pod-ok fölött. Ez a Kubernetes szolgáltatás. A Kubernetes szolgáltatás állandó végpontot biztosít egy csoport pod számára. Számos szolgáltatástípus van. server használja LoadBalancer, amely külső IP-címet biztosít, hogy kapcsolatba léphessen a server -val a klaszteren kívülről.
A Kubernetes-ben található egy beépített DNS-rendszer is, amely DNS-neveket rendel (például helloserver.default.cluster.local) szolgáltatásoknak. Ennek köszönhetően a podok a klaszteren belül tartós címmel más podokkal kapcsolódnak. A DNS neve nem használható a klaszteren kívül, például a Cloud Shell-en vagy a számítógépen.

Kubernetes manifestek

Amikor az alkalmazást forráskódból indítottad, imperatív parancsot használtál. python3

server.py

Az imperativitás igei formát jelent: „tedd ezt”.

A Kubernetes a deklaratív modell. Ez azt jelenti, hogy nem mondjuk a Kubernetesnek, hogy mit kell pontosan tennie, hanem leírjuk a kívánt állapotot. Például a Kubernetes szükség szerint indítja és állítja le a podokat, hogy a rendszer aktuális állapota megfeleljen a kívántnak.

A kívánt állapotot a manifestekben, vagy fájlokban határozod meg. YAML. A YAML fájl tartalmazza egy vagy több Kubernetes objektum specifikációit.

A példában egy YAML fájl található server és loadgen. Minden YAML fájl megszabja a Kubernetes deploy és service objektumok kívánt állapotát.

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 meghatározza az objektum típusát.
metadata.name meghatározza a deploy nevét.
Az első mező spec tartalmazza a kívánt állapot leírását.
spec.replicas megadja a kívánt podok számát.
Rész spec.template meghatározza a pod sablonját. A podok specifikációjában található egy mező, kép, ahol a konténerregiszterből kinyerendő kép nevét adjuk meg.

A szolgáltatás a következőképpen van meghatározva:

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

LoadBalancer: az ügyfelek a terheléselosztó állandó IP-címére küldenek kéréseket, amely a klaszteren kívül is elérhető.
targetPort: ahogy emlékszel, a parancs EXPOSE 8080 be. Dockerfile nem adott ki portokat. Megadod a portot 8080, hogy kapcsolatba léphess a konténerrel server a klaszteren kívül. Az esetünkben hellosvc.default.cluster.local:80 (rövid név: hellosvc) a portot jelöli. 8080 A pod IP-címe helloserver.
port: ez a port száma, ahova a klaszteren belüli többi szolgáltatás küldi a kéréseket.

loadgen.yaml

A deploy objektum a loadgen.yaml hasonlít, mint server.yaml. A különbség az, hogy a deploy objektum tartalmaz egy szakaszt, env. Ez definiálja a szükséges környezeti változókat, loadgen amelyeket beállítottál az alkalmazás forráskódból való indításakor.

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

Egyszer loadgen nem fogad el bejövő kéréseket, a mezőben type meg van adva ClusterIP. Ez a típus egy állandó IP-címet biztosít, amelyet a klaszter szolgáltatásai használhatnak, de ez az IP-cím nem érhető el külső ügyfelek számára.

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

Konténerek telepítése GKE-ben

1) Lépjen be abba a könyvtárba, ahol a példa található server:

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

2) Nyissa meg server.yaml egy szövegszerkesztőben.
3) Cserélje ki a nevet a mezőben kép a Docker-képe neve.

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

Cserélje PROJECT_ID a GCP projektazonosítójára.
4) Mentse el és zárja be server.yaml.
5) Telepítse a YAML fájlt Kubernetesben:

kubectl apply -f server.yaml

A sikeres végrehajtás után a parancs az alábbi kódot adja vissza:

deployment.apps/helloserver created
service/hellosvc created

6) Lépjen abba a könyvtárba, ahol található loadgen:

cd ../loadgen

7) Nyissa meg loadgen.yaml egy szövegszerkesztőben.
8) Cserélje ki a nevet a mezőben kép a Docker-képe neve.

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

Cserélje PROJECT_ID a GCP projektazonosítójára.
9) Mentse el és zárja be loadgen.yaml, zárja be a szövegszerkesztőt.
10) Telepítse a YAML fájlt Kubernetesben:

kubectl apply -f loadgen.yaml

A sikeres végrehajtás után a parancs az alábbi kódot adja vissza:

deployment.apps/loadgenerator created
service/loadgensvc created

11) Ellenőrizze a podok állapotát:

kubectl get pods

A parancs az alábbi állapotot mutatja:

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

12) Nyomja ki az alkalmazás naplóit a podból loadgen. Cserélje POD_ID az előző válaszból származó azonosítóra.

kubectl logs loadgenerator-POD_ID

13) Szerezze meg a külső IP-címeket hellosvc:

kubectl get service

A parancs válasza körülbelül így néz ki:

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) Küldjön kérést a hellosvc: cserélje EXTERNAL_IP a külső IP-címre hellosvc.

curl http://EXTERNAL_IP

Fogjunk bele az Istióba

Már van egy alkalmazása telepítve a GKE-ben. loadgen használhatja a Kubernetes DNS-t (hellosvc:80), hogy kéréseket küldjön a server, és küldhet kéréseket a server külső IP-címen. Bár a Kubernetes sok lehetőséget kínál, néhány információ hiányzik a szolgáltatásokról:

Hogyan lépnek kapcsolatba a szolgáltatások? Mik a kapcsolatok a szolgáltatások között? Hogyan áramlik a forgalom a szolgáltatások között? Tudja, hogy loadgen kérdéseket küld server, de képzelje el, hogy semmit sem tud az alkalmazásról. Ezekre a kérdésekre válaszolva nézze meg az GKE-ben futó podok listáját.
Metrikák. Mennyi ideig server válaszol egy bejövő kérdésre? Hány kérdés érkezik másodpercenként a szerverhez? Hibáinformációkat ad ki?
Biztonsági információk. A forgalom a loadgen és server egyszerűen -kérések) hatalmas terheléssel — 6 millió esemény másodpercenként. Minden keresztül halad a vagy mTLS?

megy. Mindezekre a kérdésekre az Istio válaszol. Ehhez az Istio sidecar proxy-t helyez el Envoy minden podban. Az Envoy proxy kiszűri az összes bejövő és kimenő forgalmat az alkalmazás tartályaiba. Ez azt jelenti, hogy server és loadgen az Envoy sidecar proxy-n keresztül jutnak el, és a forgalom a loadgen refs server az Envoy proxy-n keresztül halad át.

A proxyk közötti kapcsolatok szolgáltatási hálózatot alkotnak. A szolgáltatási hálózati architektúra további ellenőrzési réteget biztosít a Kubernetes fölött.

Mivel az Envoy proxyk a saját konténerükben futnak, az Istio-t a GKE klaszter fölé telepítheti anélkül, hogy jelentősen módosítaná az alkalmazás kódját. De némi munkát el kellett végeznie, hogy előkészítse az alkalmazást az Istio általi kezelésre:

Szolgáltatások minden konténerhez. A telepítésekhez server és loadgen egy Kubernetes szolgáltatás van csatolva. Még ha van is loadgen, amely nem kap bejövő kéréseket, van egy szolgáltatása.
A szolgáltatások portjainak nevének kell lennie. Bár a GKE-ben a szolgáltatások portjait névtelenül is hagyhatja, az Istio megköveteli, hogy a port neve a protokolljának megfelelően legyen. A YAML fájlban a port neve server nevezi http, mert a szerver a -kérések) hatalmas terheléssel — 6 millió esemény másodpercenként. Minden keresztül halad aprotokollt használja. Ha a SystemD inicializálási rendszer számára: a gRPCprotokollt használná, akkor a port nevét grpc.
jelölni kell. A telepítéseket meg kell címkézni. Ezért használhatja az Istio forgalomkezelő funkcióit, például megoszthatja a forgalmat egy szolgáltatás verziói között.

Istio telepítése

Az Istio-t kétféleképpen lehet telepíteni. Lehet engedélyezni az Istio kiterjesztést a GKE-n vagy telepíteni az open-source Istio verziót a klaszterre. Az Istio a GKE-n lehetővé teszi az Istio telepítésének és frissítésének egyszerű kezelését a GKE klaszter életciklusa alatt. Ha szüksége van a legújabb Istio verzióra vagy nagyobb ellenőrzésre van szüksége az Istio vezérlőpult konfigurációjában, inkább az open-source verziót telepítse a GKE Istio kiterjesztés helyett. Az útmutató kiválasztásához olvassa el a cikket: Szükségem van az Istio-ra a GKE-n?.

Válassza ki a lehetőséget, tanulmányozza a megfelelő útmutatót, és kövesse az utasításokat az Istio telepítéséhez a klaszteren. Ha Istio-t szeretne használni egy frissen telepített alkalmazással, engedélyezze a sidecar-ok beillesztését. Névtér alapértelmezett.

Tisztítás

Annak érdekében, hogy a Google Cloud Platform fiókjából ne vonjanak le díjat az ebben az útmutatóban használt erőforrásokért, törölje a konténer klasztert, amikor telepítette az Istio-t és játszott az alkalmazás példával. Ekkor az összes klaszter-erőforrás, például számítási példányok, lemezek és hálózati erőforrások törlésre kerülnek.

Mi következik?

Tanulmányozza a következő technológiákat:
Tanulmányozza a következő eszközöket:
Tanulmányozza a Kubernetes fogalmait:

Forrás: habr.com