🥇Avalduse koostamine Istio

Istio on mugav tööriist hajutatud rakenduste ühendamiseks, turvamiseks ja jälgimiseks. Istio kasutab tarkvara mastaabis käitamiseks ja haldamiseks mitmesuguseid tehnoloogiaid, sealhulgas konteinereid rakenduse koodi ja sõltuvuste pakkimiseks juurutamiseks ning Kubernetesi nende konteinerite haldamiseks. Seetõttu peate Istioga töötamiseks teadma, kuidas nendel tehnoloogiatel põhineva mitme teenusega rakendus töötab ilma Istio. Kui need tööriistad ja mõisted on teile juba tuttavad, jätke see õpetus vabalt vahele ja minge otse jaotisesse Istio installimine Google Kubernetes Engine'i (GKE) või laienduse installimine Istio GKE-s.

See on samm-sammuline juhend, kus me käime läbi kogu protsessi lähtekoodist GKE konteinerini, et anda teile näite kaudu põhiteadmised nendest tehnoloogiatest. Samuti näete, kuidas Istio nende tehnoloogiate võimsust ära kasutab. See eeldab, et te ei tea konteinerite, Kubernetese, teenindusvõrkude ega Istio kohta midagi.

ülesanded

Selles õpetuses täidate järgmised ülesanded.

Mitme teenusega lihtsa teremaailma rakenduse õppimine.
Käivitage rakendus lähtekoodist.
Rakenduse pakendamine konteineritesse.
Kubernetese klastri loomine.
Konteinerite juurutamine klastrisse.

Enne alustamist

Kubernetes Engine API lubamiseks järgige juhiseid.

Mine Kubernetes Engine'i leht Google Cloud Platformi konsoolis.
Looge või valige projekt.
Oodake, kuni API ja sellega seotud teenused on lubatud. Selleks võib kuluda mõni minut.
Veenduge, et teie Google Cloud Platformi projekti jaoks oleks arveldamine seadistatud. Vaadake, kuidas arveldamine lubada.

Selles õpetuses saate kasutada Cloud Shelli, mis valmistab ette virtuaalse masina g1-small Google Compute Engine'is Debianil põhineva Linuxiga või Linuxi või macOS-i arvutiga.

Valik A: Cloud Shelli kasutamine

Cloud Shelli kasutamise eelised:

Python 2 ja Python 3 arenduskeskkonnad (sh virtualenv) on täielikult konfigureeritud.
Käsurea tööriistad gpilv, sadamatööline, git и kubectl, mida kasutame, on juba installitud.
Valida on mitme vahel tekstiredaktorid:
1. Koodiredaktor, mis avaneb Cloud Shelli akna ülaosas redigeerimisikooniga.
2. Emacs, Vim või Nano, mis avanevad Cloud Shelli käsurealt.

Kasutada Pilvkest:

Minge GCP-konsooli.
press Aktiveerige Cloud Shell (Aktiveeri Cloud Shell) GCP-konsooli akna ülaosas.

Alumises osas GCP konsool Cloud Shelli seanss käsureaga avaneb uues aknas.

Valik B: käsurea tööriistade kasutamine kohapeal

Kui töötate arvutis, kus töötab Linux või macOS, peate konfigureerima ja installima järgmised komponendid:

Kohanda Python 3 ja Python 2 arenduskeskkond.
Installige Cloud SDK käsurea tööriistaga gpilv.
Komplekt kubectl - käsurea tööriist töötamiseks Kubernetes.
```
gcloud components install kubectl
```
Komplekt Docker Community Edition (CE). Kasutate käsurea tööriista sadamatöölineet luua näidisrakenduse jaoks konteineri kujutisi.
Paigaldage tööriist Giti versioonikontrollet hankida GitHubist näidisrakendus.

Laadige alla näidiskood

Laadige alla lähtekood helloserver:

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

Minge näidiskoodikataloogi:

cd istio-samples/sample-apps/helloserver

Mitme teenusega rakenduse uurimine

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

server: lihtne server ühe lõpp-punktiga SAADA, /, mis prindib konsooli "tere maailm".
loadgen: skript, mis saadab liiklust server, konfigureeritava taotluste arvuga sekundis.

Rakenduse käivitamine lähtekoodist

Näidisrakenduse uurimiseks käivitage see Cloud Shellis või arvutis.
1) Kataloogis istio-samples/sample-apps/helloserver jooksma server:

python3 server/server.py

Käivitamisel server kuvatakse järgmine:

INFO:root:Starting server...

2) Avage päringute saatmiseks teine terminaliaken server. Kui kasutate Cloud Shelli, klõpsake uue seansi avamiseks lisamise ikoonil.
3) Saatke päring aadressile server:

curl http://localhost:8080

server vastab:

Hello World!

4) Minge kataloogist, kust näidiskoodi alla laadisite, kataloogi, mis sisaldab loadgen:

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

5) Looge järgmised keskkonnamuutujad:

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

6) Käivitage virtualenv:

virtualenv --python python3 env

7) Aktiveerige virtuaalne keskkond:

source env/bin/activate

8) Seadke nõuded loadgen:

pip3 install -r requirements.txt

9) Käivitage loadgen:

python3 loadgen.py

Käivitamisel loadgen kuvab midagi sellist nagu järgmine teade:

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

Teises terminali aknas server väljastab konsooli järgmised teated:

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

Võrgustiku vaatenurgast töötab kogu rakendus ühes hostis (kohalikus arvutis või Cloud Shelli virtuaalmasinas). Seetõttu võite kasutada localhosttaotluste saatmiseks server.
10) Peatada loadgen и server, sisenema Ctrl-c igas terminali aknas.
11) Terminali aknas loadgen deaktiveerige virtuaalne keskkond:

deactivate

Rakenduse pakendamine konteineritesse

Rakenduse käivitamiseks GKE-s peate pakkima näidisrakenduse − server и loadgen - sisse Konteinerid. Konteiner on viis rakenduse pakendamiseks, et isoleerida see keskkonnast.

Rakenduse konteinerisse pakkimiseks vajate dockerfile. dockerfile on tekstifail, mis määratleb käsud rakenduse lähtekoodi ja selle sõltuvuste loomiseks Dockeri pilt. Pärast loomist laadite pildi üles konteineriregistrisse, nagu Docker Hub või Konteinerite register.

Näidis on juba olemas dockerfile eest server и loadgen koos kõigi piltide kogumiseks vajalike käskudega. Allpool - dockerfile eest 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" ]

Meeskond pythonist: 3-slim alusena käsib Dockeril kasutada uusimat Python 3 pilt alusena.
Meeskond KOPERI. . kopeerib lähtefailid praegusesse töökataloogi (ainult meie puhul server.py) konteineri failisüsteemi.
SISENEMISPUNKT määrab konteineri käivitamiseks kasutatava käsu. Meie puhul on see käsk peaaegu sama, mida varem käivitasite server.py lähtekoodist.
Meeskond KOKKUPUUDE viitab sellele server ootab pordi kaudu andmeid 8080. See meeskond ei ole pakub sadamaid. See on mingi dokumentatsioon, mida on vaja pordi avamiseks 8080 konteineri käivitamisel.

Teie rakenduse konteinerisse paigutamise ettevalmistamine

1) Määrake järgmised keskkonnamuutujad. Asenda PROJEKTI_ID oma GCP projekti ID-le.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

Väärtuste kasutamine PROJEKTI_ID и GCR_REPO märgite Dockeri pildi selle loomisel ja lükkate selle privaatsesse konteineriregistrisse.

2) Määrake käsureatööriista jaoks GCP vaikeprojekt gpilv.

gcloud config set project $PROJECT_ID

3) Määrake käsurea tööriista vaiketsoon gpilv.

gcloud config set compute/zone us-central1-b

4) Veenduge, et konteineriregistri teenus on GCP projektis lubatud.

gcloud services enable containerregistry.googleapis.com

Konteinerserver

Minge kataloogi, kus näide asub server:

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

Koguge pilt kasutades dockerfile ja varem määratletud keskkonnamuutujad:
```
docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1 .
```

Parameeter -t tähistab Dockeri silti. See on konteineri juurutamisel kasutatava pildi nimi.

Laadige pilt konteineriregistrisse üles:

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

Loadgeni konteineriseerimine

1) Minge kataloogi, kus näide asub loadgen:

cd ../loadgen

2) Koguge pilt:

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

3) Laadige pilt konteineriregistrisse üles:

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

Vaadake piltide loendit

Vaadake hoidlas olevate piltide loend üle ja veenduge, et pildid on üles laaditud:

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

Käsk kuvab äsja üleslaaditud piltide nimed:

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

GKE klastri loomine.

Neid konteinereid saab käsuga käivitada Cloud Shelli virtuaalmasinas või arvutis dock käivitada. Kuid tootmiskeskkonnas on teil vaja võimalust konteinerite tsentraalseks orkestreerimiseks. Näiteks vajate süsteemi, mis tagab, et konteinerid töötaksid alati, ning teil on vaja viisi, kuidas liikluse suurenemise korral suurendada ja luua täiendavaid konteinerite eksemplare.

Konteinerrakenduste käitamiseks saate kasutada G.K.E.. GKE on konteinerite orkestreerimisplatvorm, mis koondab virtuaalsed masinad klastriks. Iga virtuaalmasinat nimetatakse sõlmeks. GKE klastrid põhinevad avatud lähtekoodiga Kubernetes klastrite haldussüsteemil. Kubernetes pakub mehhanisme klastriga suhtlemiseks.

GKE klastri loomine:

1) Looge klaster:

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

Meeskond gpilv loob GCP projektis ja teie määratud vaikevööndis istioready klastri. Istio käitamiseks soovitame omada vähemalt 4 sõlme ja virtuaalset masinat n1-standard-2.

Meeskond loob klastri mõne minutiga. Kui klaster on valmis, väljastab käsk midagi sellist Teade.

2) Sisestage käsurea tööriistas mandaadid kubectlselle kasutamiseks klastri haldamiseks tehke järgmist.

gcloud container clusters get-credentials istioready

3) Nüüd saate Kubernetesega suhelda kaudu kubectl. Näiteks saab sõlmede oleku teada saada järgmise käsuga:

kubectl get nodes

Käsk loob sõlmede loendi:

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

Kubernetese põhikontseptsioonid

Diagramm näitab rakendust GKE-s:

Enne konteinerite juurutamist GKE-s tutvuge Kubernetese põhikontseptsioonidega. Kui soovite rohkem teada saada, on lõpus lingid.

Sõlmed ja klastrid. GKE-s on sõlm virtuaalne masin. Teistel Kubernetese platvormidel võib sõlmeks olla arvuti või virtuaalmasin. Klaster on sõlmede kogum, mida võib pidada üheks üksuseks, kus juurutate konteinerrakenduse.
Kaunad. Kubernetes jooksevad konteinerid kaunades. Pod Kubernetesis on jagamatu üksus. Pod mahutab ühte või mitut konteinerit. Juurutate serverikonteinerid ja loadgen eraldi kaunades. Kui kaustas on mitu konteinerit (näiteks rakendusserver ja puhverserver), hallatakse konteinereid ühe üksusena ja need jagavad pod-ressursse.
Kasutuselevõtt. Kubernetesis on juurutus objekt, mis on identsete kaustade kogum. Juurutamine käivitab mitu koopiat kaustadest, mis on jaotatud klastri sõlmede vahel. Juurutamine asendab automaatselt katsid, mis on ebaõnnestunud või ei reageeri.
Kubernetese teenus. Rakenduse koodi käivitamisel GKE-s on ühendus vahel loadgen и server. Kui alustasite teenuseid Cloud Shelli virtuaalmasinas või töölaual, saatsite päringud aadressile server kell localhost: 8080. Pärast GKE-sse juurutamist käivitatakse kaustad saadaolevates sõlmedes. Vaikimisi pole teil kontrolli selle üle, millises sõlmes pod töötab, nii et teie kaunad püsivaid IP-aadresse pole.
IP-aadressi saamiseks server, peate kaunade peal määratlema võrguabstraktsiooni. Seda see on Kubernetese teenus. Teenus Kubernetes pakub kaustade komplektile püsivat lõpp-punkti. Neid on vähe teenuste liigid. server kasutab Koormuse tasakaalustaja, mis annab ühenduse võtmiseks välise IP-aadressi server väljastpoolt klastrit.
Kubernetesil on ka sisseehitatud DNS-süsteem, mis määrab DNS-nimed (näiteks helloserver.default.cluster.local) teenuseid. Tänu sellele suhtlevad klastris olevad kaunad konstantsel aadressil klastri teiste kaunadega. DNS-nime ei saa kasutada väljaspool klastrit, näiteks Cloud Shellis või arvutis.

Kubernetes avaldub

Kui käivitasite rakenduse allikast, kasutasite kohustuslikku käsku python3

server.py

Imperatiiv tähendab tegusõna: "tee seda".

Kubernetes kasutab deklaratiivne mudel. See tähendab, et me ei ütle Kubernetesile täpselt, mida teha, vaid pigem kirjeldame soovitud olekut. Näiteks Kubernetes käivitab ja peatab kaustasid vastavalt vajadusele, et hoida süsteemi tegelik olek soovitud olekuga kooskõlas.

Soovitud oleku näitate manifestides või failides YAML. YAML-fail sisaldab ühe või mitme Kubernetese objekti spetsifikatsioone.

Näide sisaldab YAML-faili server и loadgen. Iga YAML-fail määrab juurutusobjekti ja Kubernetese 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

lahke näitab objekti tüüpi.
metaandmed.nimi määrab juurutuse nime.
Esimene väli spec sisaldab soovitud oleku kirjeldust.
spec.replicas näitab soovitud kaunade arvu.
Lõik spec.template määratleb kausta malli. Podi spetsifikatsioonis on väli pilt, mis määrab konteineriregistrist ekstraktitava pildi nime.

Teenus on määratletud järgmiselt:

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

Koormuse tasakaalustaja: Kliendid saadavad päringuid koormuse tasakaalustaja IP-aadressile, millel on püsiv IP-aadress ja millele pääseb juurde väljastpoolt klastrit.
sihtport: nagu mäletate, meeskond KOKKUPUUDE 8080 в dockerfile ei andnud sadamaid. Teie pakute sadamat 8080et saaksite konteineriga ühendust võtta server väljaspool klastrit. Meie puhul hellosvc.default.cluster.local:80 (lühike nimi: hellosvc) vastab sadamale 8080 Podi IP-aadressid helloserver.
port: see on pordi number, kuhu teised klastri teenused päringuid saadavad.

loadgen.yaml

Juurutamise objekt loadgen.yaml välja nägema server.yaml. Erinevus seisneb selles, et juurutusobjekt sisaldab jaotist env. See määratleb vajalikud keskkonnamuutujad loadgen ja mille installisite rakenduse allikast 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

aeg loadgen ei võta vastu sissetulevaid päringuid väljale tüüp näidatud KlastriIP. See tüüp pakub püsivat IP-aadressi, mida klastri teenused saavad kasutada, kuid see IP-aadress ei avaldata 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-s

1) Minge kataloogi, kus näide asub server:

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

2) Avatud server.yaml tekstiredaktoris.
3) Asendage väljal olev nimi pilt teie Dockeri pildi nimele.

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

Asenda PROJEKTI_ID oma GCP projekti ID-le.
4) Salvestage ja sulgege server.yaml.
5) Juurutage YAML-fail Kubernetesesse:

kubectl apply -f server.yaml

Pärast edukat lõpetamist loob käsk järgmise koodi:

deployment.apps/helloserver created
service/hellosvc created

6) Minge kataloogi, kus loadgen:

cd ../loadgen

7) Avatud loadgen.yaml tekstiredaktoris.
8) Asendage väljal olev nimi pilt teie Dockeri pildi nimele.

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

Asenda PROJEKTI_ID oma GCP projekti ID-le.
9) Salvestage ja sulgege loadgen.yaml, sulgege tekstiredaktor.
10) Juurutage YAML-fail Kubernetesesse:

kubectl apply -f loadgen.yaml

Pärast edukat lõpetamist loob käsk järgmise koodi:

deployment.apps/loadgenerator created
service/loadgensvc created

11) Kontrollige kaunade olekut:

kubectl get pods

Käsk näitab olekut:

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

12) Ekstraktige kaustast rakenduste logid loadgen. Asenda POD_ID eelmise vastuse identifikaatorile.

kubectl logs loadgenerator-POD_ID

13) Hankige välised IP-aadressid hellosvc:

kubectl get service

Käsu vastus näeb välja umbes selline:

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) Saatke päring aadressile hellosvc: asendada EXTERNAL_IP välisele IP-aadressile hellosvc.

curl http://EXTERNAL_IP

Võtame Istio

Teil on juba rakendus GKE-sse juurutatud. loadgen saab kasutada Kubernetes DNS-i (hellosvc:80) taotluste saatmiseks serverja saate saata päringuid aadressile server välise IP-aadressi järgi. Kuigi Kubernetesil on palju funktsioone, puudub teenuste kohta teave:

Kuidas teenused omavahel suhtlevad? Millised on teenustevahelised suhted? Kuidas liiklus teenuste vahel liigub? Kas olete sellest teadlik loadgen saadab päringud aadressile server, kuid kujutage ette, et te ei tea rakendusest midagi. Nendele küsimustele vastamiseks vaatame GKE jooksvate kaunade loendit.
Mõõdikud. Kui kaua server vastab sissetulevale päringule? Mitu päringut sekundis server võtab? Kas see annab veateateid?
Turvateave. Liiklus vahel loadgen и server lihtsalt läheb läbi HTTP või poolt mTLS?

Istio vastab kõigile neile küsimustele. Selleks paneb Istio külgkorvi puhverserveri saadik igas kaunas. Envoy puhverserver peatab kogu sissetuleva ja väljamineva liikluse rakenduste konteineritesse. See tähendab et server и loadgen vastu võtma külgkorvi puhverserveri kaudu ja kogu liiklust loadgen к server läbib Envoy volikirja.

Ühendused Envoy puhverserverite vahel moodustavad teenindusvõrgu. Teenindusvõrgu arhitektuur pakub Kubernetese peal juhtimiskihti.

Kuna Envoy puhverserverid töötavad oma konteinerites, saab Istio installida GKE klastri peale ilma rakenduse koodi peaaegu muutmata. Kuid olete oma rakenduse Istio haldamiseks ette valmistanud:

Teenused kõikidele konteineritele. Lähetuste juurde server и loadgen seotud Kubernetese teenusega. Isegi loadgen, mis ei võta vastu sissetulevaid päringuid, on olemas teenus.
Teenuste pordidel peavad olema nimed. Kuigi teeninduspordid võib GKE-s jätta nimetamata, nõuab Istio täpsustamist sadama nimi vastavalt tema protokollile. YAML-failis port server kutsutud httpsest server kasutab protokolli HTTP. Kui teenus kasutatud gRPC, nimetaksite sadamat grpc.
Juurutused on märgistatud. Seetõttu saate kasutada Istio liikluse haldamise funktsioone, näiteks liikluse jagamist sama teenuse versioonide vahel.

Paigaldamine

Istio installimiseks on kaks võimalust. Saab lubage Istio GKE laiendis või installige Istio avatud lähtekoodiga versioon klastri peal. GKE Istio abil saate hõlpsalt hallata Istio installimisi ja täiendusi kogu GKE klastri elutsükli jooksul. Kui soovite Istio uusimat versiooni või rohkem kontrolli oma Istio juhtpaneeli konfiguratsiooni üle, installige GKE laienduse Istio asemel avatud lähtekoodiga versioon. Lähenemisviisi üle otsustamiseks lugege artiklit Kas ma vajan GKE-s Istiot?.

Valige suvand, vaadake üle sobiv juhend ja järgige Istio klastrisse installimiseks juhiseid. Kui soovite kasutada Istiot oma äsja juurutatud rakendusega, võimaldada külgkorvi rakendamist nimeruumi jaoks vaikimisi.

Puhastamine

Kui soovite vältida selles õpetuses kasutatud ressursside eest tasu võtmist Google Cloud Platformi kontolt, kustutage konteinerite klaster pärast Istio installimist ja näidisrakendusega mängimist. See eemaldab kõik klastri ressursid, nagu arvutuseksemplarid, kettad ja võrguressursid.

Mis edasi?

Tutvuge järgmiste tehnoloogiatega:
Tutvuge järgmiste tööriistadega:
Õppige Kubernetese kontseptsioone:
1. Klastrid
2. Sõlmed
3. Kaunad
4. Teenused
5. Juurutamine

Allikas: www.habr.com

Istiole avalduse koostamine