🥇Ruošiame paraišką Istio

Istio yra patogus įrankis paskirstytoms programoms prijungti, apsaugoti ir stebėti. „Istio“ naudoja įvairias technologijas programinei įrangai paleisti ir valdyti dideliu mastu, įskaitant konteinerius, skirtus programos kodui supakuoti, ir diegimo priklausomybes, ir „Kubernetes“ tiems konteineriams valdyti. Todėl norėdami dirbti su Istio turite žinoti, kaip veikia programa su keliomis paslaugomis, pagrįsta šiomis technologijomis be Istio. Jei šie įrankiai ir sąvokos jums jau žinomi, nedvejodami praleiskite šią mokymo programą ir eikite tiesiai į skyrių „Istio“ diegimas „Google Kubernetes Engine“ (GKE) arba įdiegti plėtinį Istio apie GKE.

Tai yra žingsnis po žingsnio vadovas, kuriame apžvelgsime visą procesą nuo šaltinio kodo iki GKE konteinerio, kad pateikdami pavyzdį suprastumėte šias technologijas. Taip pat pamatysite, kaip „Istio“ išnaudoja šių technologijų galią. Tai reiškia, kad nieko nežinote apie konteinerius, „Kubernetes“, paslaugų tinklelius ar „Istio“.

užduotys

Šioje pamokoje atliksite šias užduotis:

Mokymasis paprastos „Hello world“ programos su keliomis paslaugomis.
Paleiskite programą iš šaltinio kodo.
Programos pakavimas į konteinerius.
„Kubernetes“ klasterio kūrimas.
Konteinerių išdėstymas į klasterį.

Prieš tau pradedant

Vykdykite instrukcijas, kad įgalintumėte Kubernetes Engine API:

Eik į „Kubernetes Engine“ puslapis „Google Cloud Platform“ pulte.
Sukurkite arba pasirinkite projektą.
Palaukite, kol bus įjungta API ir susijusios paslaugos. Tai gali užtrukti kelias minutes.
Įsitikinkite, kad jūsų „Google Cloud Platform“ projekto atsiskaitymas nustatytas. Sužinokite, kaip įgalinti atsiskaitymą.

Šioje pamokoje galite naudoti „Cloud Shell“, kuri paruošia virtualią mašiną g1-small Google Compute Engine su Debian pagrindu veikiančiu Linux arba Linux arba MacOS kompiuteriu.

A parinktis: „Cloud Shell“ naudojimas

„Cloud Shell“ naudojimo pranašumai:

Python 2 ir Python 3 kūrimo aplinkos (įskaitant virtualenv) yra visiškai sukonfigūruoti.
Komandinės eilutės įrankiai gdebesis, dokininkas, Git и kubectl, kurias naudosime, jau įdiegtos.
Galite rinktis iš kelių teksto redaktoriai:
1. Kodo redaktorius, kuris atsidaro su redagavimo piktograma „Cloud Shell“ lango viršuje.
2. „Emacs“, „Vim“ arba „Nano“, kurios atidaromos iš „Cloud Shell“ komandinės eilutės.

Naudoti Debesų kriauklė:

Eikite į GCP konsolę.
Spustelėkite mygtuką Suaktyvinkite „Cloud Shell“. (Suaktyvinti „Cloud Shell“) GCP konsolės lango viršuje.

Apatinėje dalyje GCP konsolė Cloud Shell sesija su komandine eilute bus atidaryta naujame lange.

B parinktis: vietinis komandinės eilutės įrankių naudojimas

Jei dirbsite kompiuteriu, kuriame veikia „Linux“ arba „MacOS“, turėsite sukonfigūruoti ir įdiegti šiuos komponentus:

Pritaikyti Python 3 ir Python 2 kūrimo aplinka.
Įdiekite „Cloud SDK“. su komandinės eilutės įrankiu gdebesis.
Nustatyti kubectl - komandinės eilutės įrankis darbui su Kubernetes.
```
gcloud components install kubectl
```
Nustatyti Docker Community Edition (CE). Naudosite komandinės eilutės įrankį dokininkasnorėdami sukurti pavyzdinės programos konteinerio vaizdus.
Įdiekite įrankį Git versijos valdymasNorėdami gauti programos pavyzdį iš „GitHub“.

Atsisiųsti kodo pavyzdį

Atsisiųskite šaltinio kodą helloserver:

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

Eikite į pavyzdinį kodo katalogą:

cd istio-samples/sample-apps/helloserver

Programos su keliomis paslaugomis tyrinėjimas

Pavyzdinė programa yra parašyta Python ir susideda iš dviejų komponentų, kurie sąveikauja naudojant POILSIO:

serveris: paprastas serveris su vienu galutiniu tašku GAUTI, /, kuris į pultą atspausdina „hello world“.
loadgen: scenarijus, kuris siunčia srautą į serveris, su konfigūruojamu užklausų skaičiumi per sekundę.

Programos paleidimas iš šaltinio kodo

Norėdami ištirti programos pavyzdį, paleiskite ją „Cloud Shell“ arba kompiuteryje.
1) Kataloge istio-samples/sample-apps/helloserver paleisti serveris:

python3 server/server.py

Paleidus serveris rodoma:

INFO:root:Starting server...

2) Atidarykite kitą terminalo langą, į kurį norite siųsti užklausas serveris. Jei naudojate „Cloud Shell“, spustelėkite pridėjimo piktogramą, kad atidarytumėte kitą seansą.
3) Siųsti prašymą serveris:

curl http://localhost:8080

serveris atsako:

Hello World!

4) Iš katalogo, kuriame atsisiuntėte pavyzdinį kodą, eikite į katalogą, kuriame yra loadgen:

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

5) Sukurkite šiuos aplinkos kintamuosius:

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

6) Bėk virtualenv:

virtualenv --python python3 env

7) Suaktyvinkite virtualią aplinką:

source env/bin/activate

8) Nustatyti reikalavimus loadgen:

pip3 install -r requirements.txt

9) Bėk loadgen:

python3 loadgen.py

Paleidus loadgen rodo kažką panašaus į šį pranešimą:

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

Kitame terminalo lange serveris į konsolę išveda šiuos pranešimus:

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

Žvelgiant iš tinklo perspektyvos, visa programa veikia viename pagrindiniame kompiuteryje (vietiniame kompiuteryje arba „Cloud Shell“ virtualioje mašinoje). Todėl galite naudoti localhostprašymus siųsti serveris.
10) Sustoti loadgen и serveris, įveskite Ctrl-c kiekviename terminalo lange.
11) Terminalo lange loadgen išjungti virtualią aplinką:

deactivate

Programos pakavimas į konteinerius

Norėdami paleisti programą GKE, turite supakuoti pavyzdinę programą − serveris и loadgen - į Konteineriai. Konteineris yra būdas supakuoti programą, kad būtų galima atskirti ją nuo aplinkos.

Norėdami supakuoti programą į konteinerį, jums reikia dockerfile. dockerfile yra tekstinis failas, kuriame apibrėžiamos programos šaltinio kodo ir jo priklausomybių kūrimo komandos Docker vaizdas. Sukūrę vaizdą įkeliate į konteinerio registrą, pvz., „Docker Hub“ arba Konteinerių registras.

Pavyzdys jau yra dockerfile už serveris и loadgen su visomis reikalingomis komandomis vaizdams rinkti. Žemiau - dockerfile už serveris:

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" ]

Komanda IŠ python: 3-slim kaip pagrindas liepia „Docker“ naudoti naujausią Python 3 vaizdas kaip pagrindas.
Komanda KOPIJUOT. . nukopijuoja šaltinio failus į dabartinį darbo katalogą (tik mūsų atveju serveris.py) į sudėtinio rodinio failų sistemą.
ĮEJIMAS apibrėžia komandą, kuri naudojama konteineriui paleisti. Mūsų atveju ši komanda yra beveik tokia pati kaip ta, kurią anksčiau paleidote serveris.py iš šaltinio kodo.
Komanda POVEIKIS tai rodo serveris laukia duomenų per prievadą 8080. Ši komanda nėra suteikia prievadus. Tai tam tikra dokumentacija, reikalinga norint atidaryti prievadą 8080 paleidžiant konteinerį.

Ruošiamasi sudėti jūsų programą

1) Nustatykite šiuos aplinkos kintamuosius. Pakeiskite PROJECT_ID į savo GSP projekto ID.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

Naudojant vertybes PROJECT_ID и GCR_REPO žymite „Docker“ vaizdą, kai jį kuriate, ir perkeliate jį į privatų konteinerių registrą.

2) Nustatykite numatytąjį GCP projektą komandų eilutės įrankiui gdebesis.

gcloud config set project $PROJECT_ID

3) Nustatykite numatytąją komandų eilutės įrankio zoną gdebesis.

gcloud config set compute/zone us-central1-b

4) Įsitikinkite, kad GCP projekte įjungta konteinerių registro paslauga.

gcloud services enable containerregistry.googleapis.com

Konteinerių serveris

Eikite į katalogą, kuriame yra pavyzdys serveris:

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

Surinkite vaizdą naudodami dockerfile ir aplinkos kintamieji, kuriuos apibrėžėte anksčiau:
```
docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1 .
```

Parametras -t reiškia Docker žymą. Tai vaizdo, kurį naudojate diegdami sudėtinį rodinį, pavadinimas.

Įkelkite vaizdą į konteinerių registrą:

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

Krovinio talpinimas į konteinerius

1) Eikite į katalogą, kuriame yra pavyzdys loadgen:

cd ../loadgen

2) Surinkite paveikslėlį:

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

3) Įkelkite vaizdą į konteinerių registrą:

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

Peržiūrėkite vaizdų sąrašą

Peržiūrėkite saugykloje esančių vaizdų sąrašą ir patikrinkite, ar vaizdai buvo įkelti:

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

Komanda rodo naujai įkeltų vaizdų pavadinimus:

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

GKE klasterio kūrimas.

Šiuos konteinerius galima paleisti virtualioje „Cloud Shell“ mašinoje arba kompiuteryje su komanda Docker paleisti. Tačiau gamybinėje aplinkoje jums reikia būdo centralizuotai organizuoti konteinerius. Pavyzdžiui, jums reikia sistemos, kuri užtikrintų, kad sudėtiniai rodiniai visada veiktų, ir jums reikia būdo padidinti ir išplėsti papildomus sudėtinių rodinių egzempliorius, jei srautas didėja.

Norėdami paleisti konteinerines programas, galite naudoti G.K.E.. GKE yra konteinerių orkestravimo platforma, kuri sujungia virtualias mašinas į klasterį. Kiekviena virtuali mašina vadinama mazgu. GKE klasteriai yra pagrįsti atvirojo kodo Kubernetes klasterių valdymo sistema. „Kubernetes“ suteikia sąveikos su grupe mechanizmus.

GKE klasterio kūrimas:

1) Sukurkite grupę:

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

Komanda gdebesis sukuria istioready klasterį GCP projekte ir numatytoje zonoje, kurią nurodėte. Norint paleisti „Istio“, rekomenduojame turėti bent 4 mazgus ir virtualią mašiną n1-standartas-2.

Komanda sukuria grupę per kelias minutes. Kai klasteris bus paruoštas, komanda išves kažką panašaus Pranešimas.

2) Komandinės eilutės įrankyje pateikite kredencialus kubectlNorėdami jį naudoti klasteriui valdyti:

gcloud container clusters get-credentials istioready

3) Dabar galite bendrauti su Kubernetes per kubectl. Pavyzdžiui, ši komanda gali sužinoti mazgų būseną:

kubectl get nodes

Komanda sukuria mazgų sąrašą:

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

Pagrindinės Kubernetes sąvokos

Diagramoje parodyta programa GKE:

Prieš diegdami konteinerius GKE, išmokite pagrindines Kubernetes sąvokas. Jei norite sužinoti daugiau, pačioje pabaigoje yra nuorodos.

Mazgai ir klasteriai. GKE mazgas yra virtuali mašina. Kitose Kubernetes platformose mazgas gali būti kompiuteris arba virtuali mašina. Klasteris yra mazgų rinkinys, kurį galima laikyti vienu vienetu, kuriame diegiate konteinerinę programą.
Ankštys. Kubernetes konteineriai važiuoja ankštimis. Pod Kubernetes yra nedalomas vienetas. Pod talpina vieną ar daugiau talpyklų. Diegiate serverio konteinerius ir loadgen atskirose ankštyse. Kai grupėje yra keli konteineriai (pavyzdžiui, programų serveris ir tarpinis serveris), konteineriai tvarkomi kaip vienas subjektas ir dalijasi pod ištekliais.
Diegimai. „Kubernetes“ diegimas yra objektas, kuris yra identiškų rinkinių rinkinys. Diegiant paleidžiamos kelios rinkinių kopijos, paskirstytos tarp grupių mazgų. Diegimas automatiškai pakeičia blokus, kurie sugedo arba nereaguoja.
Kubernetes paslauga. Vykdant programos kodą GKE, ryšys tarp loadgen и serveris. Kai pradėjote teikti paslaugas virtualioje „Cloud Shell“ mašinoje arba darbalaukyje, išsiuntėte užklausas į serveris pagal adresą localhost: 8080. Įdiegus GKE, blokai vykdomi turimuose mazguose. Pagal numatytuosius nustatymus jūs negalite valdyti, kuriame mazge veikia blokas, todėl jūs ankštys nėra nuolatinių IP adresų.
Norėdami gauti IP adresą serveris, turite apibrėžti tinklo abstrakciją ankščių viršuje. Štai kas yra Kubernetes paslauga. „Kubernetes“ paslauga suteikia nuolatinį blokų rinkinio galutinį tašką. Yra keli paslaugų rūšys. serveris naudoja „LoadBalancer“, kuris suteikia išorinį IP adresą, kuriuo galima susisiekti serveris iš už klasterio ribų.
„Kubernetes“ taip pat turi integruotą DNS sistemą, kuri priskiria DNS vardus (pvz., helloserver.default.cluster.local) paslaugos. Dėl šios priežasties klasterio ankštys bendrauja su kitomis klasterio ankštimis nuolatiniu adresu. DNS pavadinimo negalima naudoti už klasterio ribų, pvz., „Cloud Shell“ arba kompiuteryje.

Kubernetes pasireiškia

Kai paleidote programą iš šaltinio, naudojote imperatyviąją komandą python3

serveris.py

Imperatyvas reiškia veiksmažodį: „daryk tai“.

Kubernetes naudoja deklaratyvus modelis. Tai reiškia, kad „Kubernetes“ tiksliai nenurodome, ką daryti, o aprašome norimą būseną. Pvz., „Kubernetes“ paleidžia ir sustabdo blokus pagal poreikį, kad įsitikintų, jog tikroji sistemos būsena atitinka norimą būseną.

Norimą būseną nurodote manifestuose arba failuose YAML. YAML faile yra vieno ar kelių „Kubernetes“ objektų specifikacijos.

Pavyzdyje yra YAML failas, skirtas serveris и loadgen. Kiekviename YAML faile nurodoma norima diegimo objekto ir „Kubernetes“ paslaugos būsena.

serveris.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

natūra nurodo objekto tipą.
metaduomenys.vardas nurodo diegimo pavadinimą.
Pirmas laukas spec yra norimos būsenos aprašymas.
spec.replicos nurodo norimą ankščių skaičių.
Skyrius spec.šablonas apibrėžia pod šabloną. Ankšties specifikacijoje yra laukas vaizdas, kuris nurodo vaizdo, kurį reikia ištraukti iš konteinerio registro, pavadinimą.

Paslauga apibrėžiama taip:

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

„LoadBalancer“: klientai siunčia užklausas apkrovos balansavimo priemonės IP adresu, kuris turi nuolatinį IP adresą ir yra pasiekiamas iš klasterio ribų.
targetPort: kaip pamenate, komanda POVEIKIS 8080 в dockerfile uostų nesuteikė. Jūs suteikiate uostą 8080kad galėtumėte susisiekti su konteineriu serveris už klasterio ribų. Mūsų atveju hellosvc.default.cluster.local:80 (trumpas vardas: hellosvc) atitinka uostą 8080 Pod IP adresai helloserver.
uostas: tai prievado numeris, kuriuo kitos grupės paslaugos siųs užklausas.

loadgen.yaml

Diegimo objektas loadgen.yaml atrodyti kaip serveris.yaml. Skirtumas tas, kad diegimo objekte yra skyrius env. Jis apibrėžia reikalingus aplinkos kintamuosius loadgen ir kuriuos įdiegėte paleisdami programą iš šaltinio.

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

Kartą loadgen nepriima įeinančių užklausų, už lauką tipas nurodyta „ClusterIP“. Šis tipas suteikia nuolatinį IP adresą, kurį gali naudoti klasterio paslaugos, tačiau šis IP adresas nerodomas išoriniams klientams.

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

Konteinerių diegimas GKE

1) Eikite į katalogą, kuriame yra pavyzdys serveris:

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

2) Atidaryti serveris.yaml teksto rengyklėje.
3) Pakeiskite pavadinimą lauke vaizdas į jūsų Docker vaizdo pavadinimą.

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

Pakeiskite PROJECT_ID į savo GSP projekto ID.
4) Išsaugoti ir uždaryti serveris.yaml.
5) Įdiekite YAML failą į Kubernetes:

kubectl apply -f server.yaml

Sėkmingai užbaigus, komanda sukuria šį kodą:

deployment.apps/helloserver created
service/hellosvc created

6) Eikite į katalogą, kuriame loadgen:

cd ../loadgen

7) Atidaryti loadgen.yaml teksto rengyklėje.
8) Pakeiskite pavadinimą lauke vaizdas į jūsų Docker vaizdo pavadinimą.

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

Pakeiskite PROJECT_ID į savo GSP projekto ID.
9) Išsaugoti ir uždaryti loadgen.yaml, uždarykite teksto rengyklę.
10) Įdiekite YAML failą į Kubernetes:

kubectl apply -f loadgen.yaml

Sėkmingai užbaigus, komanda sukuria šį kodą:

deployment.apps/loadgenerator created
service/loadgensvc created

11) Patikrinkite ankščių būseną:

kubectl get pods

Komanda rodo būseną:

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

12) Ištraukite programų žurnalus iš rinkinio loadgen. Pakeiskite POD_ID į identifikatorių iš ankstesnio atsakymo.

kubectl logs loadgenerator-POD_ID

13) Gaukite išorinius IP adresus hellosvc:

kubectl get service

Komandos atsakymas atrodo maždaug taip:

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) Siųsti prašymą hellosvc: pakeisti EXTERNAL_IP į išorinį IP adresą hellosvc.

curl http://EXTERNAL_IP

Imkime Istio

Jau turite programą, įdiegtą GKE. loadgen gali naudoti Kubernetes DNS (hellosvc:80) siųsti užklausas serverisir galite siųsti užklausas serveris pagal išorinį IP adresą. Nors Kubernetes turi daug funkcijų, trūksta informacijos apie paslaugas:

Kaip paslaugos sąveikauja? Kokie yra paslaugų santykiai? Kaip srautas vyksta tarp paslaugų? Ar žinote, kad loadgen siunčia prašymus serveris, bet įsivaizduokite, kad nieko nežinote apie programą. Norėdami atsakyti į šiuos klausimus, pažvelkime į GKE bėgimo ankšties sąrašą.
Metrika. Kiek ilgai serveris atsako į gaunamą užklausą? Kiek užklausų per sekundę gauna serveris? Ar duoda klaidų pranešimus?
Saugumo informacija. Eismas tarp loadgen и serveris tik praeina HTTP arba iki mTLS?

Istio atsako į visus šiuos klausimus. Norėdami tai padaryti, Istio įdeda šoninės priekabos įgaliotąjį serverį pasiuntinys kiekvienoje ankštyje. „Envoy“ įgaliotasis serveris perima visą įeinantį ir išeinantį srautą į programų konteinerius. Tai reiškia kad serveris и loadgen gauti per šoninio priekabos įgaliotąjį pasiuntinį ir visą srautą iš loadgen к serveris eina per pasiuntinio įgaliotinį.

Ryšiai tarp pasiuntinio tarpinių serverių sudaro paslaugų tinklą. Paslaugų tinklo architektūra suteikia valdymo sluoksnį „Kubernetes“ viršuje.

Kadangi „Envoy“ įgaliotieji serveriai veikia savo konteineriuose, „Istio“ gali būti įdiegtas GKE klasterio viršuje beveik nepakeitus programos kodo. Tačiau atlikote tam tikrą darbą, kad jūsų programa būtų paruošta valdyti „Istio“:

Visų konteinerių paslaugos. Į dislokavimus serveris и loadgen susieta su Kubernetes paslauga. Netgi loadgen, kuris negauna įeinančių užklausų, yra paslauga.
Paslaugų prievadai turi turėti pavadinimus. Nors GKE paslaugų prievadai gali būti neįvardinti, „Istio“ reikalauja nurodyti uosto pavadinimas pagal jo protokolą. YAML faile prievadas, skirtas serveris ji paragino httpnes serveris naudoja protokolą HTTP... Jei tarnyba naudojamas grRPC, pavadintumėte uostą grpc.
Diegimai yra pažymėti. Todėl galite naudoti „Istio“ srauto valdymo funkcijas, pvz., srauto padalijimą tarp tos pačios paslaugos versijų.

„Istio“ diegimas

Yra du būdai įdiegti „Istio“. Gali įgalinkite „Istio“ GKE plėtinyje arba įdiekite atvirojo kodo Istio versiją ant klasterio. Naudodami „Istio“ GKE galite lengvai valdyti „Istio“ diegimus ir atnaujinimus per visą GKE klasterio gyvavimo ciklą. Jei norite naujausios „Istio“ versijos ar daugiau valdyti „Istio“ valdymo pulto konfigūraciją, įdiekite atvirojo kodo versiją, o ne „Istio on GKE“ plėtinį. Norėdami nuspręsti dėl požiūrio, perskaitykite straipsnį Ar man reikia Istio GKE?.

Pasirinkite parinktį, peržiūrėkite atitinkamą vadovą ir vadovaukitės instrukcijomis, kad įdiegtumėte „Istio“ savo klasteryje. Jei norite naudoti „Istio“ su naujai įdiegta programa, įgalinti šoninių priekabų diegimą vardų erdvei numatytasis.

Valymas

Kad nebūtumėte apmokestinti iš „Google Cloud Platform“ paskyros už išteklius, kuriuos naudojote šioje mokymo programoje, įdiegę „Istio“ ir paleidę su pavyzdine programa ištrinkite sudėtinių rodinių grupę. Taip bus pašalinti visi klasterio ištekliai, pvz., skaičiavimo egzemplioriai, diskai ir tinklo ištekliai.

Kas toliau?

Ištirkite šias technologijas:
Ištirkite šiuos įrankius:
Sužinokite Kubernetes sąvokas:
1. Klasteriai
2. Mazgai
3. Ankštys
4. Paslaugos
5. Diegimas

Šaltinis: www.habr.com

Istio paraiškos ruošimas