🥇Rakenduse ettevalmistamine Istio jaoks

Istio on mugav tööriist jaotatud rakenduste ühendamiseks, kaitsmiseks ja jälgimiseks. Istios kasutatakse erinevaid tehnoloogiaid tarkvara skaleeritavaks käivitamiseks ja haldamiseks, sealhulgas rakenduskoodi ja sõltuvuste pakendamiseks konteinerites ning Kubernetes - nende konteinerite haldamiseks. Seetõttu peate Istio kasutamiseks teadma, kuidas mitme teenusega rakendus nende tehnoloogiate põhjal toimib. ilma Istio. Kui need tööriistad ja mõisted on teile juba tuttavad, jäänud juhised vahele ja minge otse jaotisesse. Istio paigaldamine Google Kubernetes Engine'is (GKE) või laienduse installimine Istio GKE-s.

See on samm-sammuline juhend, kus vaatleme kogu protsessi lähtekoodist kuni konteinerini GKE-s, et saaksite nende tehnoloogiate põhjal mugava ülevaate. Samuti näete, kuidas Istio kasutab nende tehnoloogiate võimalusi. Eeldatakse, et te ei tea midagi konteineritest, Kubernetesest, teenuste võrgustikest või Istio'st.

Ülesanded

Selles juhendis täidate järgmisi ülesandeid:

Lihtsa hello world rakenduse uurimine mitme teenusega.
Rakenduse käitamine lähtekoodist.
Rakenduse pakendamine konteineritesse.
Kubernetes klastri loomine.
Konteinerite juurutamine klastrisse.

Enne alustamist

Järgige juhiseid, et aktiveerida Kubernetes Engine API:

Minge Kubernetes Engine lehele 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 projekti jaoks on seadistatud arveldamine. Uurige, kuidas arveldamist lubada..

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

Variant A: kasutades Cloud Shell'i

Cloud Shell'i kasutamise eelised:

Python 2 ja Python 3 arenduskeskkonnad (sealhulgas virtualenv) on täiesti seadistatud.
Käsurea tööriistad gcloud, docker, git ja kubectl, mida me kasutame, on juba installitud.
Teil on valikus mitu redaktorit.:
1. Koodiredaktor, mis avatakse redigeerimise ikooniga Cloud Shell'i akna ülaosas.
2. Emacs, Vim või Nano, mis avanevad käsurealt Cloud Shell'is.

Cloud Shell'i kasutamiseks Minge GCP konsooli.:

Aktiveeri Cloud Shell
Klõpsake nuppu (Aktiveerida Cloud Shell) GCP konsooli akna ülaosas. (Aktiveeri Cloud Shell) GCP-i konsooli akna ülaosas.

All pool GCP console a Cloud Shell session with a command line will open in a new window.

Option B: using command line tools locally

If you are working on a computer with Linux or macOS, you need to set up and install the following components:

Seadistage the Python 3 and Python 2 development environment.
Install the Cloud SDK with the command line tool gcloud.
Installige kubectl — the command line tool for working with Kubernetes.
```
gcloud components install kubectl
```
Installige Docker Community Edition (CE). You will use the command line tool docker, to build container images for the sample application.
Install the version control tool Git, to get the sample application from GitHub.

Download the code sample

Download the source code helloserver:

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

Change to the code sample directory:

cd istio-samples/sample-apps/helloserver

Exploring the multi-service application

The sample application is written in Python and consists of two components that interact through REST:

server: a simple server with a single endpoint GET, /, which outputs "hello world" to the console.
loadgen: a script that sends traffic to server, with a configurable number of requests per second.

Running the application from the source code

To explore the sample application, run it in Cloud Shell or on your computer.
1) In the directory istio-samples/sample-apps/helloserver run server:

python3 server/server.py

Käivitamisel server the following will be displayed:

INFO:root:Starting server...

2) Open another terminal window to send requests to server. If you are using Cloud Shell, click the add icon to open another session.
3) Send a request to server:

curl http://localhost:8080

the server responds:

Tere maailm!

4) From the directory where you downloaded the code sample, change to the directory that contains loadgen:

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

5) Create the following environment variables:

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

6) Run virtualenv:

virtualenv --python python3 env

7) Activate the virtual environment:

source env/bin/activate

8) Install the requirements for loadgen:

pip3 install -r requirements.txt

9) Run loadgen:

python3 loadgen.py

Käivitamisel loadgen outputs approximately the following message:

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

In another terminal window server outputs approximately the following messages to the console:

127.0.0.1 - - [21/Jun/2019 14:22:01] "GET / HTTP/1.1" 200 -
INFO:root:GET request,
Path: /

Võrgu seisukohalt töötab kogu rakendus ühel serveril (kohalik arvuti või virtuaalne masin Cloud Shell). Seetõttu saab kasutada localhost, et saata päringud server.
10) Peatamiseks loadgen ja server, sisestage Ctrl-c iga terminaliaknas.
11) Terminaliaknas loadgen deaktiveerige virtuaalne keskkond:

deactivate

Rakenduse pakkimine konteineritesse

Et käivitada rakendus GKE-s, tuleb pakendada näidisrakendus — server ja loadgen — konteinerid. Konteiner on viis rakenduse pakkimiseks, et isoleerida see keskkonnast.

Rakenduse pakendamiseks konteinerisse on vajalik Dockerfile. Dockerfile — see on tekstifail, kus määratakse rakenduse lähtekoodi ja selle sõltuvuste koostamise käsklused Docker pildiks. Pärast koostamist laadite pildi konteinerite registrisse, näiteks Docker Hub või Container Registry.

Näites on juba olemas Dockerfile jaoks server ja loadgen koik vajalikud käsklused piltide koostamiseks. Allpool on Dockerfile jaoks 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/*

# Lülita sisse väljundlogimine
FROM base as final
ENV PYTHONUNBUFFERED=1

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

WORKDIR /helloserver

# Noppige paketid ehitajalt
COPY --from=builder /usr/local/lib/python3.7/ /usr/local/lib/python3.7/

# Lisage rakendus
COPY . .

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

Meeskond FROM python:3-slim as base käskleb Dockeril kasutada viimast Python 3 pildi kui baasi.
Meeskond COPY. . kopeerib lähtekoodid praegusesse töökausta (meie puhul ainult server.py) konteineri failisüsteemi.
ENTRYPOINT määrab käsu, mida kasutatakse konteineri käivitamiseks. Meie puhul on see käsk peaaegu sama, mis see, mida kasutasite lähtekoodist server.py käivitamiseks.
Meeskond EXPOSE näitab, et server ootab andmeid porti 8080. See käsk ei ava porte.See on midagi, mis sarnaneb dokumentatsiooniga, mis on vajalik uue porta avamiseks 8080 konteineri käivitamisel.

Rakenduse konteeneriseerimiseks ettevalmistamine

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

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

Kasutades väärtusi PROJECT_ID ja GCR_REPO märkite Docker pildi, kui koostate ja saadate selle eraldi Container Registry.

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

gcloud config set project $PROJECT_ID

3) Määrake vaikimisi ala käsurea tööriista jaoks gcloud.

gcloud config set compute/zone us-central1-b

4) Veenduge, et Container Registry teenus on GCP projektis lubatud.

gcloud services enable containerregistry.googleapis.com

Konteineriseerimine server

Liikuge katalooge, kus asub näidis server:

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

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

Parameeter -t esindab Docker'i silti. See on pildi nimi, mida kasutate konteineri juurutamisel.

Saatke pilt Container Registry'sse:

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

Konteineriseerimine loadgen

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

cd ../loadgen

2) Koguge pilt:

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

3) Saatke pilt Container Registry'sse:

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

Piltide loendi vaatamine

Vaadake piltide loendit hoidlas ja veenduge, et pildid on saadetud:

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

Käsk tagastab just saadetud piltide nimed:

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

GKE klastrite loomine.

Need konteinerid saaks toimida Cloud Shelli virtuaalses masinas või teie arvutis käsuga docker run. Kuid tootmisrežiimis on vaja keskselt orkestreerida konteinereid. Näiteks on vajalik süsteem, mis jälgib, et konteinerid töötaksid alati, ning on vajalik viis, kuidas suurendada ja käivitada täiendavaid konteineri eksemplare, kui liiklus suureneb.

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

GKE klastrite loomine:

1) Looge klaster:

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

Meeskond gcloud loob claster'i istioready GCP projektis ja vaikimisi piirkonnas, mille olete määranud. Istio käivitamiseks soovitame vähemalt 4 sõlme ja virtuaalmasinat n1-standard-2.

Käsk loob klastrit mõne minuti jooksul. Kui klaster on valmis, tagastab käsk sarnase teate.

2) Määrake volitused käsurea tööriistale kubectl, et hallata klastrit:

gcloud container clusters get-credentials istioready

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

kubectl get nodes

Käsk tagastab sõlmede loendi:

NIM                         STATUSE    ROLLID    VANUS    VERSIOON
gke-istoready-default-pool-dbeb23dc-1vg0   Valmis       99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-36z5   Valmis       100s   v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-fj7s   Valmis       99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-wbjw   Valmis       99s    v1.13.6-gke.13

Kubernetesi põhikontseptsioonid

Diagrammil on kujutatud rakendus GKE-s:

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

Sõlmed ja klastrid. GKE-s on sõlm virtuaalmasin. Teistel Kubernetes platvormidel võib sõlm olla arvuti või virtuaalmasin. Klaster on sõlmede kogum, mida saab pidada tervikuks ja kuhu te kärgitate konteineripõhiseid rakendusi.
Pod'id. Kuberneteses käivitatakse konteinerid pod'ides. Pod Kuberneteses on jagamatu üksus. Pod sisaldab ühte või mitut konteinerit. Te kärgitate konteinerid server ja loadgen erinevates pod'ides. Kui pod'is on mitu konteinerit (näiteks rakenduse server ja proksi-server), juhitakse konteinerid kui ühtset objekti ja nad jagavad pod'i ressursse.
Käivitamised. Kuberneteses on käitamine objekt, mis esindab identsete pod'ide kogumit. Käitamine käivitab mitu pod'i koopiat, mis jaotatakse klastris olevatele sõlmdele. Käitamine asendab automaatselt need pod'id, mis ebaõnnestuvad või ei vasta.
Kubernetesi teenus. Kui käivitate rakenduse koodi GKE-s, muutub ühendus loadgen ja server. Kui olete käivitanud teenused virtuaalses masinas Cloud Shellis või arvutis, saatsite päringud server aadressile localhost:8080. Pärast kärgimist GKE-s käivitatakse pod'id saadaval olevatel sõlmedel. Vaikimisi ei saa te kuidagi hallata, millisel sõlmel pod käivitub, seega ei pod'ide ole püsivaid IP-aadresse.
IP-aadressi saamiseks server, peate määratlema võrgu abstraktsiooni pod'ide kohal. See ongi Kubernetesi teenus. Kubernetesi teenus annab püsiva lõpp-punkti pod'ide kogumile. On mitmeid teenuse tüüpe. server kasutab LoadBalancer, mis pakuvad välist IP-aadressi, et ühenduda server klastrist väljaspool.
Kuberneteses on samuti sisseehitatud DNS-süsteem, mis määrab DNS-nimed (näiteks helloserver.default.cluster.local) teenustele. Selle tõttu suhtlevad pod’id klastris teiste pod’idega püsiva aadressi kaudu. DNS-i nime ei saa klastrist väljaspool kasutada, näiteks Cloud Shellis või teie arvutis.

Kubernetes’i manifestid

Kui käivitasite rakenduse lähtekoodist, kasutasite imperatiivset käsku python3

server.py

Imperatiivsuse mõiste hõlmab tegusõna: "tee seda".

Kubernetes kasutab deklareeritav mudel. See tähendab, et me ei ütle Kubernetes’ele, mida täpselt teha, vaid kirjeldame soovitud olekut. Näiteks käivitab Kubernetes ja peatab pod’id vastavalt vajadusele, et tõeline süsteemi seisund vastaks soovitule.

Soovitud oleku määrate manifestides või failides YAML. YAML-fail sisaldab spetsifikatsioonid ühe või mitme Kubernetes’i objekti jaoks.

Näites sisaldub YAML-fail server ja loadgen. Iga YAML-fail määratleb želу mесяся олиоobedмробкнезатором — у сервиса Kubernetes’ist.

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 väljalaskmise nime.
Esimene väli spec sisaldab soovitud oleku kirjeldust.
spec.replicas määrab soovitud pod’ide arvu.
Jaotis spec.template määratleb pod’i mall. Pod’ide spetsifikatsioonis on väli image, kus määratakse konteinerifaili nimi, mille tuleb Container Registry’st välja võtta.

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 koormusbalansi IP-aadressile, millel on püsiv IP-aadress ja mis on kergesti juurdepääsetav klastrist väljaspool.
targetPort: nagu mäletate, käsk EXPOSE 8080 ja Dockerfile ei pakkunud porte. Te määrate pordi 8080, et oleks võimalik suhelda konteineriga server klastrist väljaspool. Meie puhul hellosvc.default.cluster.local:80 (lühinimi: hellosvc) vastab pordile 8080 pod’i IP-aadress helloserver.
port: see on pordinumber, kuhu teised teenused klastris saadavad päringud.

loadgen.yaml

Käivitamisobjekt loadgen.yaml on server.yamlsarnane env. Erinevus seisneb selles, et käivitamisobjekt sisaldab jaotist loadgen . See määratleb keskkonnamuutujad, mis on vajalikud, ja mida te määrasite rakenduse käivitamisel lähtekoodist.

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

Üks loadgen ei võta sisenevaid päringuid, välja arvatud type märgitud ClusterIP. See tüüp pakub püsivat IP-aadressi, mida saavad kasutada klastris olevad teenused, kuid see IP-aadress ei ole välistele klientidele saadaval.

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) Liikuge katalooge, kus asub näidis server:

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

2) Avage server.yaml tekstiredaktoris.
3) Asendage nimi välja image oma Docker-pildiga nimega.

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

Asendage PROJECT_ID oma GCP projekti ID-ga.
4) Salvestage ja sulgege server.yaml.
5) Juurutage YAML-fail Kubernetesesse:

kubectl apply -f server.yaml

Pärast eduka käivitamise korral annab käsk järgmise koodi:

deployment.apps/helloserver created
service/hellosvc created

6) Minge kausta, kus asub loadgen:

cd ../loadgen

7) Avage loadgen.yaml tekstiredaktoris.
8) Asendage nimi välja image oma Docker-pildiga nimega.

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

Asendage PROJECT_ID oma GCP projekti ID-ga.
9) Salvestage ja sulgege loadgen.yaml, sulgege tekstiredaktor.
10) Juurutage YAML-fail Kubernetesesse:

kubectl apply -f loadgen.yaml

Pärast eduka käivitamise korral annab käsk järgmise koodi:

deployment.apps/loadgenerator created
service/loadgensvc created

11) Kontrollige pods'i 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 logisid podist loadgen. Asendage POD_ID eelnevalt saadud ID.

kubectl logs loadgenerator-POD_ID

13) Hankige välised IP-aadressid hellosvc:

kubectl get service

Käsk tagastab umbes järgmise:

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

curl http://EXTERNAL_IP

Tegeleme Istio'ga

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

Kuidas teenused omavahel suhtlevad? Millised on teenuste omavahelised suhted? Kuidas voolab liiklus teenuste vahel? Kas te olete teadlikud, et loadgen saab päringud server, kuid kujutage ette, et te ei tea rakendusest midagi. Nendele küsimustele vastamiseks vaatame GKE-s käivitatud podide loendit.
Mõõtmised. Kui kaua server vastab sissetulevale päringule? Kui palju päringuid sekundis serverisse jõuab? Kas ta annab veateateid?
Turvaandmed. Liiklus teenuste vahel loadgen ja server läbib lihtsalt HTTP või mTLS?

Kõigile nendele küsimustele vastab Istio. Selleks paigutab Istio igasse podi sidecar-proksi Envoy Proksi Envoy püüdab kinni kogu sissetuleva ja väljamineva liikluse rakenduse konteineritele. See tähendab, et server ja loadgen saadakse sidecar-proksi Envoy'i kaudu ja kogu liiklus loadgen aadressile server läbib proksi Envoy'i.

Proksi Envoy'de vahelised ühendused moodustavad teenuste võrgu. Teenuste võrgu arhitektuur annab Kubernetes'ile ülemise tasandi kontrolli.

Kuna proksi Envoy töötavad oma konteinerites, saab Istio paigaldada GKE klastrisse, peaaegu muutmata rakenduse koodi. Kuid te olete teinud mõningaid ettevalmistusi rakenduse tegemiseks Istio haldamiseks:

Teenused kõigi konteinerite jaoks. Iga rakendamine server ja loadgen on seotud Kubernetes'e teenusega. Isegi loadgen, kuhu ei tule sissetulevaid päringuid, on teenus.
Teenuste portidel peavad olema nimed. Kuigi GKE-s võib teenuste porte nimeta jätta, nõuab Istio pordil nime vastavalt tema protokollile. YAML-failis on port server kandideerib http, kuna server kasutab protokolli HTTP. Kui teenus kasutaks gRPC, siis nimetaksite porti grpc.
Rakendusi märgistatakse. Seetõttu saate kasutada Istio liikluse juhtimise funktsioone, näiteks jagada liiklust ühe teenuse versioonide vahel.

Istio installimine

Istio installimiseks on kaks meetodit. Võite aktiveerida Istio on GKE laienduse või installida avatud lähtekoodiga versiooni Istio klastrisse. Istio on GKE abil on lihtne hallata Istio paigaldamist ja uuendamist GKE klastro elutsükli raames. Kui vajate kõige uuemat Istio versiooni või rohkem kontrolli Istio juhtpaneeli seadistuse üle, installige avatud lähtekoodiga versioon, mitte Istio on GKE laiendus. Otsustamiseks lugege artiklit Kas mul on vaja Istio on GKE?.

Valige variant, uurige vastavat juhendit ja järgige juhiseid, et paigaldada Istio klastrisse. Kui soovite kasutada Istio just valminud rakendusega, aktiveerige sidecar'ide juurutamine nimeala Seejärel käivitame exec käsu ja ootame 5000 sekundit, et jätkata jälgimist:.

Puhastamine

Et vältida Google Cloud Platformi konto arveldamist nende ressursside eest, mida oled selles juhendis kasutanud, eemalda konteineriklaster pärast Istio installimist ja rakenduse näitega mängimist. Sellega eemaldatakse kõik klastriga seotud ressursid, näiteks arvutieksemplarid, kettad ja võrguressursid.

Mis edasi?

Uuri järgmisi tehnoloogiaid:
1. Docker
2. Konteinerid
3. Container Registry
4. Kubernetes
5. GKE
6. Teenusevõrk
7. Istio
Uuri järgmisi tööriistu:
Uuri Kubernetes'e kontseptsioone:

Allikas: habr.com