🥇Pregătirea unei aplicații pentru Istio

Istio este un instrument convenabil pentru conectarea, securizarea și monitorizarea aplicațiilor distribuite. Istio folosește o varietate de tehnologii pentru a rula și gestiona software-ul la scară, inclusiv containere pentru a împacheta codul aplicației și dependențele pentru implementare, iar Kubernetes pentru a gestiona acele containere. Prin urmare, pentru a lucra cu Istio trebuie să știți cum funcționează o aplicație cu servicii multiple bazate pe aceste tehnologii fără Istio. Dacă aceste instrumente și concepte vă sunt deja familiare, nu ezitați să omiteți acest tutorial și să mergeți direct la secțiune Instalarea Istio pe Google Kubernetes Engine (GKE) sau instalarea unei extensii Istio pe GKE.

Acesta este un ghid pas cu pas în care vom parcurge întregul proces, de la codul sursă la containerul GKE, astfel încât să obțineți o înțelegere de bază a acestor tehnologii cu un exemplu. Veți vedea, de asemenea, cum Istio valorifică puterea acestor tehnologii. Aceasta presupune că nu știți nimic despre containere, Kubernetes, rețele de servicii sau Istio.

sarcini

În acest tutorial, veți îndeplini următoarele sarcini:

Învățarea unei aplicații simple hello world cu mai multe servicii.
Rulați aplicația din codul sursă.
Ambalarea aplicației în containere.
Crearea unui cluster Kubernetes.
Implementarea containerelor într-un cluster.

Înainte de a începe

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

Mergeți la Pagina Kubernetes Engine în consola Google Cloud Platform.
Creați sau selectați un proiect.
Așteptați până când API-ul și serviciile asociate sunt activate. Aceasta s-ar putea sa dureze cateva minute.
Asigurați-vă că facturarea este configurată pentru proiectul dvs. Google Cloud Platform. Aflați cum să activați facturarea.

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

Opțiunea A: Utilizarea Cloud Shell

Beneficiile utilizării Cloud Shell:

Mediile de dezvoltare Python 2 și Python 3 (inclusiv virtualenv) sunt complet configurate.
Instrumente de linie de comandă gcloud, docher, merge и kubectl, pe care le vom folosi sunt deja instalate.
Ai mai multe din care să alegi editori de text:
1. Editor de coduri, care se deschide cu pictograma de editare în partea de sus a ferestrei Cloud Shell.
2. Emacs, Vim sau Nano, care se deschid din linia de comandă în Cloud Shell.

A folosi Cloud Shell:

Accesați consola GCP.
presa Activați Cloud Shell (Activați Cloud Shell) în partea de sus a ferestrei consolei GCP.

În partea inferioară Consola GCP O sesiune Cloud Shell cu o linie de comandă se va deschide într-o fereastră nouă.

Opțiunea B: Utilizarea instrumentelor de linie de comandă local

Dacă veți lucra pe un computer care rulează Linux sau macOS, va trebui să configurați și să instalați următoarele componente:

Personalizați Mediul de dezvoltare Python 3 și Python 2.
Instalați Cloud SDK cu instrument de linie de comandă gcloud.
Set kubectl - instrument de linie de comandă pentru a lucra cu Kubernetes.
```
gcloud components install kubectl
```
Set Docker Community Edition (CE). Veți folosi instrumentul de linie de comandă docherpentru a crea imagini container pentru aplicația eșantion.
Instalați instrumentul Controlul versiunii Gitpentru a obține exemplul de aplicație din GitHub.

Descărcați exemplu de cod

Descărcați codul sursă helloserver:

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

Accesați exemplul de director de cod:

cd istio-samples/sample-apps/helloserver

Explorarea unei aplicații cu mai multe servicii

Exemplul de aplicație este scris în Python și constă din două componente care interacționează folosind REST:

serverul: server simplu cu un punct final OBȚINE, /, care imprimă „hello world” pe consolă.
loadgen: script care trimite trafic către serverul, cu un număr configurabil de solicitări pe secundă.

Rularea unei aplicații din codul sursă

Pentru a explora aplicația exemplu, rulați-o în Cloud Shell sau pe computer.
1) În catalog istio-samples/sample-apps/helloserver alerga serverul:

python3 server/server.py

La pornire serverul este afisat urmatorul:

INFO:root:Starting server...

2) Deschideți o altă fereastră de terminal pentru a trimite cereri serverul. Dacă utilizați Cloud Shell, faceți clic pe pictograma de adăugare pentru a deschide o altă sesiune.
3) Trimiteți o cerere către serverul:

curl http://localhost:8080

serverul raspunde:

Hello World!

4) Din directorul de unde ați descărcat codul exemplu, mergeți la directorul care conține loadgen:

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

5) Creați următoarele variabile de mediu:

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

6) Fugi virtualenv:

virtualenv --python python3 env

7) Activați mediul virtual:

source env/bin/activate

8) Stabiliți cerințe pentru loadgen:

pip3 install -r requirements.txt

9) Fugi loadgen:

python3 loadgen.py

La pornire loadgen afișează ceva de genul următor mesaj:

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

Într-o altă fereastră de terminal serverul transmite următoarele mesaje către 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 perspectiva rețelei, întreaga aplicație rulează pe o singură gazdă (calculator local sau mașină virtuală Cloud Shell). Prin urmare, puteți utiliza localhostpentru a trimite cereri către serverul.
10) A opri loadgen и serverul, introduce Ctrl-c în fiecare fereastră de terminal.
11) În fereastra terminalului loadgen dezactivați mediul virtual:

deactivate

Ambalarea unei aplicații în containere

Pentru a rula aplicația pe GKE, trebuie să împachetați aplicația exemplu − serverul и loadgen - în Containere. Un container este o modalitate de a împacheta o aplicație pentru a o izola de mediul său.

Pentru a împacheta o aplicație într-un container, aveți nevoie Dockerfile. Dockerfile este un fișier text care definește comenzile pentru construirea codului sursă al aplicației și dependențele sale în Imagine Docker. Odată construită, încărcați imaginea într-un registru de containere, cum ar fi Docker Hub sau Registrul containerelor.

Exemplul are deja Dockerfile pentru serverul и loadgen cu toate comenzile necesare pentru a colecta imagini. Mai jos - Dockerfile pentru serverul:

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

Echipă DIN python:3-subțire ca bază îi spune lui Docker să folosească cea mai recentă Imagine Python 3 ca bază.
Echipă COPIE. . copiază fișierele sursă în directorul de lucru curent (doar în cazul nostru server.py) în sistemul de fișiere al containerului.
PUNCT DE INTRARE definește comanda care este utilizată pentru a porni containerul. În cazul nostru, această comandă este aproape aceeași cu cea pe care o executați server.py din codul sursă.
Echipă EXPUNE indică faptul că serverul așteaptă date prin port 8080. Această echipă nu este oferă porturi. Acesta este un fel de documentație care este necesară pentru a deschide portul 8080 la pornirea recipientului.

Pregătirea pentru containerizarea aplicației dvs

1) Setați următoarele variabile de mediu. A inlocui PROJECT_ID la ID-ul proiectului dvs. GCP.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

Utilizarea valorilor PROJECT_ID и GCR_REPO etichetați imaginea Docker când o creați și o trimiteți într-un Container Registry privat.

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

Server de containerizare

Accesați directorul în care se află exemplul serverul:

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

Asamblaț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. Acesta este numele imaginii pe care o utilizați la implementarea containerului.

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

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

Containerizarea loadgen

1) Accesați directorul în care se află exemplul loadgen:

cd ../loadgen

2) Colectaț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

Vizualizați o listă de imagini

Examinați lista de imagini din depozit și verificați dacă imaginile au fost încărcate:

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

Comanda afișează numele imaginilor nou încărcate:

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

Crearea unui cluster GKE.

Aceste containere ar putea fi rulate pe o mașină virtuală Cloud Shell sau pe un computer cu comanda docker alerga. Dar într-un mediu de producție, aveți nevoie de o modalitate de a orchestra central containerele. De exemplu, aveți nevoie de un sistem care să se asigure că containerele rulează întotdeauna și aveți nevoie de o modalitate de a extinde și de a crea instanțe de container suplimentare dacă traficul crește.

Pentru a rula aplicații containerizate, puteți utiliza G.K.E.. GKE este o platformă de orchestrare a containerelor care agregează mașinile virtuale într-un cluster. Fiecare mașină virtuală se numește nod. Clusterele GKE se bazează pe sistemul de management al clusterelor cu sursă deschisă 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

Echipă gcloud creează un cluster gata în proiectul GCP și în zona implicită pe care le-ați specificat. Pentru a rula Istio, vă recomandăm să aveți cel puțin 4 noduri și o mașină virtuală n1-standard-2.

Echipa creează clusterul în câteva minute. Când clusterul este gata, comanda scoate ceva de genul acesta сообщение.

2) Furnizați acreditări în instrumentul de linie de comandă kubectlpentru a-l folosi pentru a gestiona clusterul:

gcloud container clusters get-credentials istioready

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

kubectl get nodes

Comanda produce o listă de noduri:

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

Concepte cheie Kubernetes

Diagrama arată o aplicație pe GKE:

Înainte de a implementa containere în GKE, aflați conceptele cheie ale Kubernetes. Există link-uri la sfârșit, dacă doriți să aflaț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 o colecție de noduri care pot fi considerate o singură unitate în care implementați o aplicație containerizată.
Păstăi. În Kubernetes, containerele rulează în pod-uri. Un pod în Kubernetes este o unitate indivizibilă. Un Pod conține unul sau mai multe containere. Implementați containere de server și loadgen în păstăi separate. Când există mai multe containere într-un pod (de exemplu, un server de aplicații și server proxy), containerele sunt gestionate ca o singură entitate și partajează resurse pod.
Implementări. În Kubernetes, o implementare este un obiect care este o colecție de poduri identice. Implementarea lansează mai multe replici ale podurilor distribuite pe nodurile clusterului. Implementarea înlocuiește automat podurile care au eșuat sau nu răspund.
Serviciul Kubernetes. Când rulați codul aplicației în GKE, conexiunea dintre loadgen и serverul. Când ați pornit servicii pe o mașină virtuală sau pe un desktop Cloud Shell, ați trimis solicitări către serverul la localhost: 8080. Odată implementate în GKE, podurile sunt executate pe nodurile disponibile. În mod implicit, nu aveți control asupra nodului pe care rulează podul, așa că dvs păstăi fără adrese IP permanente.
Pentru a obține o adresă IP pentru serverul, trebuie să definiți o abstractizare a rețelei deasupra podurilor. Asta e Serviciul Kubernetes. Serviciul Kubernetes oferă un punct final persistent pentru un set de pod-uri. Sunt cateva tipuri de servicii. serverul utilizări Echilibrarea greutății, care oferă o adresă IP externă de contact serverul din afara clusterului.
Kubernetes are, de asemenea, un sistem DNS încorporat care atribuie nume DNS (de exemplu, helloserver.default.cluster.local) Servicii. Datorită acestui fapt, podurile din cluster comunică cu alte poduri din cluster la o adresă permanentă. Numele DNS nu poate fi folosit în afara clusterului, cum ar fi în Cloud Shell sau pe un computer.

Kubernetes se manifestă

Când ați rulat aplicația de la sursă, ați folosit comanda imperativă python3

server.py

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

Utilizează Kubernetes model declarativ. Aceasta înseamnă că nu îi spunem lui Kubernetes exact ce să facă, ci mai degrabă descriem starea dorită. De exemplu, Kubernetes pornește și oprește podurile după cum este necesar pentru a menține starea actuală a sistemului în concordanță cu starea dorită.

Indicați starea dorită în manifeste sau fișiere YAML. Un fișier YAML conține specificații pentru unul sau mai multe obiecte Kubernetes.

Exemplul conține un fișier YAML pentru serverul и loadgen. Fiecare fișier YAML specifică starea dorită a obiectului de implementare ș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

natural indică tipul obiectului.
metadate.nume specifică numele implementării.
Primul câmp spec. conține o descriere a stării dorite.
spec.replici indică numărul dorit de păstăi.
Secțiune spec.şablon definește un șablon de pod. Există un câmp în specificația podului imagine, care specifică numele imaginii care trebuie extrasă din Container Registry.

Serviciul este definit după cum urmează:

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

Echilibrarea greutății: Clienții trimit cereri către adresa IP a echilibratorului de încărcare, care are o adresă IP persistentă și este accesibilă din afara clusterului.
targetPort: după cum vă amintiți, echipa EXPUNE 8080 в Dockerfile nu a oferit porturi. Tu oferi portul 8080astfel încât să puteți contacta containerul serverul în afara clusterului. În cazul nostru hellosvc.default.cluster.local:80 (nume scurt: hellosvc) corespunde portului 8080 Adresele IP ale podului helloserver.
port: Acesta este numărul portului unde alte servicii din cluster vor trimite cereri.

loadgen.yaml

Obiect de implementare la loadgen.yaml arată ca server.yaml. Diferența este că obiectul de implementare conține o secțiune env. Acesta definește variabilele de mediu care sunt necesare loadgen și pe care le-ați instalat când rulați aplicația din 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

timp loadgen nu acceptă cereri primite, pentru domeniu tip necunoscut ClusterIP. Acest tip oferă o adresă IP persistentă pe care serviciile din cluster o pot folosi, dar această adresă IP nu este expusă clienților externi.

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

Implementarea containerelor în GKE

1) Accesați directorul în care se află exemplul serverul:

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

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

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

A inlocui PROJECT_ID la ID-ul proiectului dvs. GCP.
4) Salvați și închideți server.yaml.
5) Implementați fișierul YAML pe Kubernetes:

kubectl apply -f server.yaml

După finalizarea cu succes, comanda produce următorul cod:

deployment.apps/helloserver created
service/hellosvc created

6) Accesați directorul unde loadgen:

cd ../loadgen

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

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

A inlocui PROJECT_ID la ID-ul proiectului dvs. GCP.
9) Salvați și închideți loadgen.yaml, închideți editorul de text.
10) Implementați fișierul YAML pe Kubernetes:

kubectl apply -f loadgen.yaml

După finalizarea cu succes, comanda produce următorul cod:

deployment.apps/loadgenerator created
service/loadgensvc created

11) Verificați starea podurilor:

kubectl get pods

Comanda arată starea:

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 de aplicații din pod loadgen. A inlocui POD_ID la identificatorul din răspunsul anterior.

kubectl logs loadgenerator-POD_ID

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

kubectl get service

Răspunsul la comandă arată cam 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      <none>          443/TCP        93m
loadgensvc   ClusterIP      10.81.15.155   <none>          80/TCP         4m52s

14) Trimiteți o cerere către hellosvc: a inlocui EXTERNAL_IP la adresa IP externă hellosvc.

curl http://EXTERNAL_IP

Să-l luăm pe Istio

Aveți deja o aplicație implementată în GKE. loadgen poate folosi Kubernetes DNS (hellosvc:80) pentru a trimite cereri către serverulși puteți trimite cereri către serverul prin adresa IP externă. Deși Kubernetes are multe caracteristici, lipsesc câteva informații despre servicii:

Cum interacționează serviciile? Care sunt relațiile dintre servicii? Cum circulă traficul între servicii? Ești conștient de asta loadgen trimite cereri către serverul, dar imaginați-vă că nu știți nimic despre aplicație. Pentru a răspunde la aceste întrebări, să ne uităm la lista de poduri care rulează în GKE.
Metrici. Cât timp serverul răspunde la o solicitare primită? Câte solicitări pe secundă primesc serverul? Oferă mesaje de eroare?
Informații de securitate. Trafic între loadgen и serverul doar trece prin HTTP sau de mTLS?

Istio răspunde la toate aceste întrebări. Pentru a face acest lucru, Istio plasează un proxy sidecar trimis în fiecare păstaie. Proxy-ul Envoy interceptează tot traficul de intrare și de ieșire către containerele de aplicații. Înseamnă că serverul и loadgen primiți prin proxy sidecar Envoy și tot traficul de la loadgen к serverul trece prin proxy Envoy.

Conexiunile dintre proxy-urile Envoy formează o rețea de servicii. Arhitectura mesh de servicii oferă un nivel de control peste Kubernetes.

Deoarece proxy-urile Envoy rulează în propriile lor containere, Istio poate fi instalat deasupra unui cluster GKE fără aproape nicio modificare a codului aplicației. Dar ați lucrat pentru a pregăti aplicația pentru a fi gestionată de Istio:

Servicii pentru toate containerele. La implementări serverul и loadgen legat de serviciul Kubernetes. Chiar loadgen, care nu primește cereri primite, există un serviciu.
Porturile din servicii trebuie să aibă nume. Deși porturile de serviciu pot fi lăsate fără nume în GKE, Istio vă solicită să specificați numele portului în conformitate cu protocolul său. În fișierul YAML portul pentru serverul denumit httpdeoarece serverul folosește protocolul HTTP... Dacă serviciu folosit gRPC, ai denumi portul grpc.
Implementările sunt semnalate. Prin urmare, puteți utiliza funcțiile Istio de gestionare a traficului, cum ar fi împărțirea traficului între versiunile aceluiași serviciu.

Instalarea Istio

Există două moduri de a instala Istio. Poate sa activați Istio pe extensia GKE sau instalați versiunea open source a Istio pe cluster. Cu Istio pe GKE, puteți gestiona cu ușurință instalările și upgrade-urile Istio pe parcursul ciclului de viață al clusterului GKE. Dacă doriți cea mai recentă versiune de Istio sau mai mult control asupra configurației panoului de control Istio, instalați versiunea open source în locul extensiei Istio pe GKE. Pentru a decide asupra abordării, citiți articolul Am nevoie de Istio pe GKE?.

Selectați o opțiune, consultați ghidul corespunzător și urmați instrucțiunile pentru a instala Istio pe clusterul dvs. Dacă doriți să utilizați Istio cu aplicația dvs. nou implementată, permite implementarea sidecar pentru namespace lipsă.

curățenie

Pentru a evita taxarea din contul dvs. Google Cloud Platform pentru resursele pe care le-ați folosit în acest tutorial, ștergeți clusterul de containere după ce ați instalat Istio și ați jucat cu aplicația exemplu. Aceasta va elimina toate resursele clusterului, cum ar fi instanțe de calcul, discuri și resurse de rețea.

Ce urmeaza?

Explorați următoarele tehnologii:
Explorați următoarele instrumente:
Aflați conceptele Kubernetes:
1. Clustere
2. Noduri
3. Păstăi
4. Servicii
5. Implementare

Sursa: www.habr.com

Pregătirea unei cereri pentru Istio