🥇Pregătirea aplicației pentru Istio

Istio este un instrument convenabil pentru conectarea, protejarea și monitorizarea aplicațiilor distribuite. În Istio, se utilizează diferite tehnologii pentru rularea și gestionarea la scară a software-ului, inclusiv containere pentru ambalarea codului aplicației și a dependențelor pentru desfășurare și Kubernetes pentru gestionarea acestor containere. De aceea, pentru a lucra cu Istio, trebuie să știți cum funcționează o aplicație cu servicii multiple bazată pe aceste tehnologii. fără Istio. Dacă aceste instrumente și concepte vă sunt deja cunoscute, puteți să săriți peste acest ghid și să treceți direct la secțiunea. Instalarea Istio pe Google Kubernetes Engine (GKE) sau instalarea extensiei Istio pe GKE.

Acesta este un ghid pas cu pas în care vom explora întregul proces de la codul sursă până la container pe GKE, astfel încât să aveți o înțelegere de bază a acestor tehnologii printr-un exemplu. De asemenea, veți vedea cum Istio utilizează capabilitățile acestor tehnologii. Se presupune că nu știți nimic despre containere, Kubernetes, service mesh sau Istio.

Sarcini

În acest ghid, veți efectua următoarele sarcini:

Studiul unei aplicații simple hello world cu mai multe servicii.
Rularea aplicației din codul sursă.
Ambalarea aplicației în containere.
Crearea unui cluster Kubernetes.
Desfășurarea containerelor în cluster.

Înainte de a începe

Urmați instrucțiunile pentru a activa API-ul Kubernetes Engine:

Accesați pagina Kubernetes Engine din consola Google Cloud Platform.
Creați sau selectați un proiect.
Așteptați ca API-ul și serviciile asociate să fie activate. Acest lucru poate dura câteva minute.
Asigurați-vă că facturarea este activată pentru proiectul Google Cloud Platform. Aflați cum să activați facturarea.

În acest ghid, puteți utiliza Cloud Shell, care pregătește o mașină virtuală g1-small în Google Compute Engine cu Linux bazat pe Debian sau un computer care rulează Linux sau macOS.

Opțiunea A: utilizarea Cloud Shell

Avantajele utilizării Cloud Shell:

Mediile de dezvoltare Python 2 și Python 3 (inclusiv virtualenv) sunt complet configurate.
Instrumentele de linie de comandă gcloud, docker, git și kubectl, pe care le vom utiliza, sunt deja instalate.
Aveți la dispoziție mai multe editori de text:
1. Editorul de cod, care se deschide cu pictograma de editare din partea de sus a ferestrei Cloud Shell.
2. Emacs, Vim sau Nano, care se deschid din linia de comandă în Cloud Shell.

Pentru a utiliza Cloud Shell:

Accesați consola GCP.
Apăsați butonul Activate Cloud Shell (Activare Cloud Shell) în partea de sus a ferestrei consolei GCP.

În partea de jos a consolei GCP se va deschide o sesiune Cloud Shell cu linia de comandă într-o fereastră nouă.

Variantă B: utilizarea instrumentelor de linie de comandă local

Dacă vei lucra pe un computer cu Linux sau macOS, trebuie să configurezi și să instalezi următoarele componente:

Configurare mediu de dezvoltare Python 3 și Python 2.
Instalează Cloud SDK cu instrumentul de linie de comandă gcloud.
Instalați kubectl — instrument de linie de comandă pentru lucru cu Kubernetes.
```
gcloud components install kubectl
```
Instalați Docker Community Edition (CE). Vei folosi instrumentul de linie de comandă docker, pentru a crea imagini de containere pentru aplicația exemplu.
Instalează instrumentul de control al versiunilor Git, pentru a obține aplicația exemplu de pe GitHub.

Descărcarea exemplelor de cod

Descarcă codul sursă helloserver:

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

Navighează în directorul exemplului de cod:
```
cd istio-samples/sample-apps/helloserver
```

Explorarea aplicației cu mai multe servicii

Aplicația exemplu este scrisă în Python și constă din două componente care interacționează prin REST:

server: un server simplu cu un singur punct final GET, /, care afișează „hello world” în consolă.
loadgen: un script care trimite trafic către server, cu un număr configurabil de cereri pe secundă.

Rularea aplicației din codul sursă

Pentru a explora aplicația exemplu, rulează-o în Cloud Shell sau pe computerul tău.
1) În directorul istio-samples/sample-apps/helloserver rulează server:

python3 server/server.py

La pornire server se va afișa următoarele:

INFO:root:Starting server...

2) Deschide o altă fereastră de terminal pentru a trimite cereri către server. Dacă utilizezi Cloud Shell, apasă pe pictograma de adăugare pentru a deschide o altă sesiune.
3) Trimite o cerere către server:

curl http://localhost:8080

serverul răspunde:

Hello World!

4) Din directorul în care ai descărcat exemplele de cod, navighează în directorul care conține loadgen:

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

5) Creează următoarele variabile de mediu:

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

6) Rulează virtualenv:

virtualenv --python python3 env

7) Activează mediul virtual:

source env/bin/activate

8) Instalează cerințele pentru loadgen:

pip3 install -r requirements.txt

9) Rulează loadgen:

python3 loadgen.py

La pornire loadgen afişează un mesaj de aproximativ următorul conținut:

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

Într-o altă fereastră de terminal server afişează aproximativ următoarele mesaje în consolă:

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

Din punct de vedere al rețelei, întreaga aplicație rulează pe un singur host (computer local sau mașină virtuală Cloud Shell). Prin urmare, este posibil să utilizați localhost, pentru a trimite cereri către server.
10) Pentru a opri loadgen și server, introduceți Ctrl-c în fiecare fereastră de terminal.
11) În fereastra de terminal loadgen dezactivați mediul virtual:

deactivate

Ambalarea aplicației în containere

Pentru a rula aplicația pe GKE, trebuie să ambalați exemplarul aplicației — server și loadgen — în containere. Un container este un mod de a ambala aplicația pentru a o izola de mediu.

Pentru a ambala aplicația într-un container, este nevoie de Dockerfile. Dockerfile — acesta este un fișier text care definește comenzi pentru a construi codul sursă al aplicației și dependențele sale în imagine Docker. După ce ați construit imaginea, o încărcați în registrul containerelor, cum ar fi Docker Hub sau Container Registry.

Exemplul conține deja Dockerfile pentru server și loadgen cu toate comenzile necesare pentru a construi imaginile. Mai jos — Dockerfile pentru 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/*

# Permiteţi logarea fără buffer
FROM base as final
ENV PYTHONUNBUFFERED=1

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

WORKDIR /helloserver

# Preiați pachetele din builder
COPY --from=builder /usr/local/lib/python3.7/ /usr/local/lib/python3.7/

# Adăugați aplicația
COPY . .

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

Comanda FROM python:3-slim as base permite Docker să folosească cea mai recentă imagine Python 3 ca bază.
Comanda COPY . . copiază fișierele sursă în directorul de lucru curent (în cazul nostru doar server.py) în sistemul de fișiere al containerului.
ENTRYPOINT definește comanda care este folosită pentru a porni containerul. În cazul nostru, această comandă este aproape identică cu cea pe care ați folosit-o pentru a rula server.py din codul sursă.
Comanda EXPOSE indică că server așteaptă date pe portul 8080. Această comandă nu oferă porturile. Este ceva similar cu documentația necesară pentru a deschide portul 8080 la pornirea containerului.

Pregătirea pentru containerizarea aplicației

1) Setați următoarele variabile de mediu. Înlocuiți PROJECT_ID cu identificatorul proiectului dvs. GCP.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

Utilizând valorile PROJECT_ID și GCR_REPO marcați imaginea Docker atunci când o construiți și o trimiteți în registrul privat Container Registry.

2) Setați proiectul GCP implicit pentru instrumentul de linie de comandă gcloud.

gcloud config set project $PROJECT_ID

3) Setați zona implicită pentru instrumentul de linie de comandă gcloud.

gcloud config set compute/zone us-central1-b

4) Asigurați-vă că serviciul Container Registry este activat în proiectul GCP.

gcloud services enable containerregistry.googleapis.com

Containere server

Accesați catalogul unde se află exemplul server:

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

Construiți imaginea folosind Dockerfile și variabilele de mediu pe care le-ați definit mai devreme:
```
docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1 .
```

Parametru -t reprezintă eticheta Docker. Este numele imaginii pe care o folosiți la desfășurarea containerului.

Încărcați imaginea în Container Registry:

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

Containere loadgen

1) Accesați catalogul unde se află exemplul loadgen:

cd ../loadgen

2) Construiți imaginea:

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

3) Încărcați imaginea în Container Registry:

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

Vizualizarea listei imaginilor

Vizualizați lista imaginilor din depozit și asigurați-vă că imaginile au fost încărcate:

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

Comanda returnează numele imaginilor recent încărcate:

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

Crearea unui cluster GKE.

Aceste containere ar putea fi lansate pe o mașină virtuală Cloud Shell sau pe computer prin comanda docker run. Dar în medii de producție este nevoie de un mod de a orchestra centralizat containerele. De exemplu, este necesar un sistem care să se asigure că containerele funcționează întotdeauna și este nevoie de un mod de a scala și de a porni instanțe suplimentare de containere dacă traficul crește.

Pentru a rula aplicațiile de containere, se poate folosi GKE. GKE este o platformă de orchestrare a containerelor care grupează mașinile virtuale într-un cluster. Fiecare mașină virtuală se numește nod. Clusterele GKE se bazează pe sistemul open-source de gestionare a clusterelor Kubernetes. Kubernetes oferă mecanisme de interacțiune cu clusterul.

Crearea unui cluster GKE:

1) Creați un cluster:

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

Comanda gcloud creează clusterul istioready în proiectul GCP și zona implicită pe care ați specificat-o. Pentru a rula Istio, este recomandat să aveți cel puțin 4 noduri și o mașină virtuală. n1-standard-2.

Comanda creează clusterul în câteva minute. Când clusterul este gata, comanda returnează un mesaj similar privind descoperirea unei vulnerabilități în versiunile mai vechi ale firmware-ului dongle-urilor USB Logitech. Aceasta permite atacatorilor cu acces fizic la dispozitive să obțină cheile de criptare ale canalului radio și să injecteze apăsările de taste (CVE-2019-13054)..

2) Specificați acreditivele în instrumentul de linie de comandă kubectl, pentru a gestiona clusterul:

gcloud container clusters get-credentials istioready

3) Acum puteți comunica cu Kubernetes prin kubectl. De exemplu, cu următoarea comandă puteți verifica starea nodurilor:

kubectl get nodes

Comanda returnează lista nodurilor:

NUME                                       STATUS   ROLURI    VÂRSTĂ    VERSIUNE
gke-istoready-default-pool-dbeb23dc-1vg0   Gata       99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-36z5   Gata       100s   v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-fj7s   Gata       99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-wbjw   Gata       99s    v1.13.6-gke.13

Concepturi cheie Kubernetes

Schema ilustrează aplicația pe GKE:

Înainte de a desfășura containere în GKE, studiați conceptele cheie Kubernetes. La final sunt linkuri dacă doriți să învățați mai multe.

Noduri și clustere. În GKE, un nod este o mașină virtuală. Pe alte platforme Kubernetes, un nod poate fi un computer sau o mașină virtuală. Un cluster este un set de noduri, care poate fi considerat un întreg și unde desfășurați aplicația containerizată.
Pod-uri. În Kubernetes, containerele rulează în pod-uri. Un pod în Kubernetes este o unitate indivizibilă. Pod-ul conține unul sau mai multe containere. Desfășurați containerele server și loadgen în pod-uri separate. Când în pod există mai multe containere (de exemplu, serverul aplicației și proxy server), containerele sunt gestionate ca un obiect unic și împărtășesc resursele pod-ului.
Desfășurări. În Kubernetes, o desfășurare este un obiect care reprezintă un set de pod-uri identice. Desfășurarea lansează mai multe replici de pod-uri, distribuite pe noduri ale cluster-ului. Desfășurarea înlocuiește automat pod-urile care au eșuat sau nu răspund.
Serviciul Kubernetes. Atunci când lansați codul aplicației în GKE, conexiunea se schimbă între loadgen și server. Când ați lansat servicii pe mașina virtuală Cloud Shell sau pe computer, ați trimis cereri la server la adresa localhost:8080. După desfășurarea în GKE, pod-urile rulează pe nodurile disponibile. În mod implicit, nu puteți gestiona pe ce nod rulează un pod, astfel încât pod-urile nu au adrese IP permanente.
Pentru a obține o adresă IP pentru server, trebuie să definiți o abstracție de rețea deasupra pod-urilor. Acesta este serviciul Kubernetes. Serviciul Kubernetes oferă un punct final permanent pentru un set de pod-uri. Există mai multe tipuri de servicii. server folosește LoadBalancer, care oferă o adresă IP externă pentru a comunica cu server din afara cluster-ului.
De asemenea, în Kubernetes există un sistem DNS încorporat care alocă nume DNS (de exemplu, helloserver.default.cluster.local) serviciilor. Datorită acestui lucru, podurile din interiorul clusterului se conectează cu alte poduri din cluster folosind o adresă permanentă. Numele DNS nu poate fi utilizat în afara clusterului, de exemplu în Cloud Shell sau pe un computer.

Manifestele Kubernetes

Când ai rulat aplicația din codul sursă, ai folosit o comandă imperativă python3

server.py

Imperativitatea implică un verb: „fă asta”.

Kubernetes utilizează modelul declarațional. Asta înseamnă că nu îi spunem lui Kubernetes ce trebuie să facă, ci descriem starea dorită. De exemplu, Kubernetes pornește și oprește podurile după necesitate, astfel încât starea reală a sistemului să corespundă dorinței.

Starea dorită este specificată în manifeste sau fișiere YAML. Fișierul YAML conține specificații pentru unul sau mai multe obiecte Kubernetes.

Exemplul conține un fișier YAML pentru server și loadgen. Fiecare fișier YAML specifică starea dorită a obiectului de desfășurare și a serviciului 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

kind specifică tipul obiectului.
metadata.name specifică numele desfășurării.
Primul câmp spec conține descrierea stării dorite.
spec.replicas specifică numărul dorit de poduri.
Secțiunea spec.template defineste șablonul podului. În specificația podurilor există un câmp imagine, unde se specifică numele imaginii care trebuie extrasă din Container Registry.

Serviciul este definit astfel:

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

LoadBalancer: clienții trimit cereri la adresa IP a balansorului de încărcare, care are o adresă IP permanentă și care este accesibil din afara clusterului.
targetPort: după cum îți amintești, comanda EXPOSE 8080 în Dockerfile nu a oferit porturi. Tu oferi un port 8080, pentru a te putea conecta la container server din afara clusterului. În cazul nostru hellosvc.default.cluster.local:80 (numele scurt: hellosvc) corespunde portului 8080 Adresa IP a podului helloserver.
port: acesta este numărul portului, către care celelalte servicii din cluster vor trimite cereri.

loadgen.yaml

Obiectul de desfășurare în loadgen.yaml se aseamănă cu server.yaml. Diferența este că obiectul de desfășurare conține secțiunea env. Aceasta definește variabilele de mediu de care ai nevoie loadgen și pe care le-ai setat când ai rulat aplicația din codul sursă.

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

Unu loadgen nu acceptă cereri de intrare pentru câmpul type specificat ClusterIP. Acest tip oferă o adresă IP statică care poate fi utilizată de serviciile din cluster, dar această adresă IP nu este oferită clienților externi.

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

Desfășurarea containerelor în GKE

1) Accesați catalogul unde se află exemplul server:

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

2) Deschideți server.yaml într-un editor de text.
3) Înlocuiți numele din câmpul imagine cu numele imaginii dvs. Docker.

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

Înlocuiește PROJECT_ID cu identificatorul proiectului dvs. GCP.
4) Salvați și închideți server.yaml.
5) Desfășurați fișierul YAML în Kubernetes:

kubectl apply -f server.yaml

După o execuție reușită, comanda returnează următorul cod:

deployment.apps/helloserver created
service/hellosvc created

6) Navigați în directorul în care se află loadgen:

cd ../loadgen

7) Deschideți loadgen.yaml într-un editor de text.
8) Înlocuiți numele din câmpul imagine cu numele imaginii dvs. Docker.

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

Înlocuiește PROJECT_ID cu identificatorul proiectului dvs. GCP.
9) Salvați și închideți loadgen.yaml, închideți editorul de text.
10) Desfășurați fișierul YAML în Kubernetes:

kubectl apply -f loadgen.yaml

După o execuție reușită, comanda returnează următorul cod:

deployment.apps/loadgenerator created
service/loadgensvc created

11) Verificați statusul podurilor:

kubectl get pods

Comanda arată statusul:

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

12) Extrageți jurnalele aplicației din pod loadgen. Înlocuiți POD_ID cu identificatorul din răspunsul anterior.

kubectl logs loadgenerator-POD_ID

13) Obțineți adresele IP externe hellosvc:

kubectl get service

Răspunsul comenzii arată aproximativ așa:

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) Trimiteți o cerere la hellosvc: înlocuiți EXTERNAL_IP cu adresa IP externă hellosvc.

curl http://EXTERNAL_IP

Să ne ocupăm de Istio

Aveți deja o aplicație desfășurată în GKE. loadgen poate utiliza DNS Kubernetes (hellosvc:80), pentru a trimite cereri către server, iar dumneavoastră puteți trimite cereri către server prin intermediul adresei IP externe. Deși Kubernetes are multe capacități, lipsesc unele informații despre servicii:

Cum interacționează serviciile? Care sunt relațiile dintre servicii? Cum trece traficul între servicii? Știți că loadgen trimite cereri către server, dar imaginați-vă că nu știți nimic despre aplicație. Pentru a răspunde la aceste întrebări, ne uităm la lista de pod-uri active în GKE.
Metrici. Cât durează server să răspundă la o cerere de intrare? Câte cereri pe secundă sosesc pe server? Oferă mesaje de eroare?
Informații de securitate. Traficul între loadgen și server trece pur și simplu prin HTTP sau prin mTLS?

Toate aceste întrebări sunt răspunse de Istio. Pentru aceasta, Istio plasează un proxy sidecar Envoy în fiecare pod. Proxy-ul Envoy intercepta întregul trafic de intrare și de ieșire către containerele aplicației. Asta înseamnă că server și loadgen primește prin proxy-ul sidecar Envoy, iar tot traficul de la loadgen la server trece prin proxy-ul Envoy.

Conexiunile între proxy-urile Envoy formează un service mesh. Arhitectura service mesh oferă un nivel de control deasupra Kubernetes-ului.

Deoarece proxy-urile Envoy rulează în containerele lor, Istio poate fi instalat peste clusterul GKE, fără a schimba aproape deloc codul aplicației. Dar ați făcut unele lucruri pentru a pregăti aplicația pentru gestionarea prin Istio:

Servicii pentru toate containerele. La desfășurări server și loadgen este legat un serviciu Kubernetes. Chiar și loadgen, la care nu sosesc cereri de intrare, are un serviciu.
Porturile în servicii trebuie să aibă nume. Deși în GKE porturile serviciilor pot fi lăsate fără nume, Istio necesită specificarea numele portului conform protocolului său. În fișierul YAML, portul pentru server se numește http, deoarece serverul folosește protocolul HTTP. Dacă service ar folosi gRPC, ați numi portul grpc.
Sfârșiturile sunt etichetate. Așadar, puteți utiliza funcțiile de gestionare a traficului Istio, cum ar fi împărțirea traficului între versiunile unui serviciu.

Instalarea Istio

Istio poate fi instalat în două moduri. Puteți activa extensia Istio on GKE sau instala versiunea open source de Istio pe cluster. Cu Istio on GKE, puteți gestiona cu ușurință instalarea și actualizarea Istio în cadrul ciclului de viață al clusterului GKE. Dacă aveți nevoie de cea mai recentă versiune de Istio sau de mai mult control asupra configurației interfeței de gestionare Istio, instalați versiunea open source în loc de extensia Istio on GKE. Pentru a decide ce abordare să alegeți, citiți articolul Am nevoie de Istio on GKE?.

Selectați opțiunea, consultați ghidul corespunzător și urmați instrucțiunile pentru a instala Istio pe cluster. Dacă doriți să utilizați Istio cu o aplicație recent desfășurată, activați implementarea sidecar-urilor pentru spațiul de nume default.

Curățare

Pentru a evita perceperea costurilor pentru resursele utilizate în acest ghid de pe contul Google Cloud Platform, ștergeți clusterul de containere după ce ați instalat Istio și ați testat aplicația exemplu. Acest lucru va elimina toate resursele clusterului, cum ar fi instanțele de calcul, discurile și resursele de rețea.

Ce urmează?

Explorați următoarele tehnologii:
Explorați următoarele instrumente:
Studiați conceptele Kubernetes:
1. Clustere.
2. Noduri
3. Pod-uri
4. Servicii
5. Implementare

Sursa: habr.com