🥇Preparazione della domanda per Istio

Istio è uno strumento utile per connettere, proteggere e monitorare le applicazioni distribuite. Istio utilizza una varietà di tecnologie per eseguire e gestire software su larga scala, inclusi contenitori per assemblare il codice dell'applicazione e le dipendenze per la distribuzione, e Kubernetes per gestire tali contenitori. Pertanto, per lavorare con Istio devi sapere come funziona un'applicazione con più servizi basati su queste tecnologie без Istio. Se questi strumenti e concetti ti sono già familiari, sentiti libero di saltare questo tutorial e andare direttamente alla sezione Installazione di Istio su Google Kubernetes Engine (GKE) o installare un'estensione Istio su GKE.

Questa è una guida passo passo in cui analizzeremo l'intero processo, dal codice sorgente al contenitore GKE, per fornirti una conoscenza di base di queste tecnologie attraverso un esempio. Vedrai anche come Istio sfrutta la potenza di queste tecnologie. Ciò presuppone che tu non sappia nulla di contenitori, Kubernetes, mesh di servizi o Istio.

compiti

In questo tutorial completerai le seguenti attività:

Imparare una semplice applicazione Hello World con più servizi.
Esegui l'applicazione dal codice sorgente.
Packaging dell'applicazione in contenitori.
Creazione di un cluster Kubernetes.
Distribuzione di contenitori in un cluster.

Prima di iniziare

Segui le istruzioni per abilitare l'API Kubernetes Engine:

Vai a Pagina Kubernetes Engine nella console di Google Cloud Platform.
Crea o seleziona un progetto.
Attendi finché l'API e i servizi correlati non saranno abilitati. Questo potrebbe richiedere alcuni minuti.
Assicurati che la fatturazione sia configurata per il tuo progetto Google Cloud Platform. Scopri come abilitare la fatturazione.

In questo tutorial puoi utilizzare Cloud Shell, che prepara la macchina virtuale g1-small in Google Compute Engine con Linux basato su Debian o un computer Linux o macOS.

Opzione A: utilizzo di Cloud Shell

Vantaggi dell'utilizzo di Cloud Shell:

Ambienti di sviluppo Python 2 e Python 3 (inclusi virtualenv) sono completamente configurati.
Strumenti della riga di comando gcloud, scaricatore di porto, git и kubectl, che utilizzeremo sono già installati.
Ne hai diversi tra cui scegliere editori di testo:
1. Editor di codice, che si apre con l'icona di modifica nella parte superiore della finestra di Cloud Shell.
2. Emacs, Vim o Nano, che si aprono dalla riga di comando in Cloud Shell.

Usare Cloud Shell:

Vai alla console GCP.
Fare clic sul pulsante Attiva Cloud Shell (Attiva Cloud Shell) nella parte superiore della finestra della console GCP.

Nella parte inferiore Console GCP Una sessione di Cloud Shell con una riga di comando si aprirà in una nuova finestra.

Opzione B: utilizzo degli strumenti da riga di comando localmente

Se lavorerai su un computer con Linux o macOS, dovrai configurare e installare i seguenti componenti:

personalizzare Ambiente di sviluppo Python 3 e Python 2.
Installa Cloud SDK con lo strumento da riga di comando gcloud.
Set kubectl - Strumento da riga di comando con cui lavorare kubernetes.
```
gcloud components install kubectl
```
Set Docker Community Edition (CE). Utilizzerai lo strumento da riga di comando scaricatore di portoper creare immagini contenitore per l'applicazione di esempio.
Installa lo strumento Controllo della versione Gitper ottenere l'applicazione di esempio da GitHub.

Scarica il codice di esempio

Scarica il codice sorgente ciaoserver:

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

Vai alla directory del codice di esempio:
```
cd istio-samples/sample-apps/helloserver
```

Esplorare un'applicazione con più servizi

L'applicazione di esempio è scritta in Python ed è composta da due componenti che interagiscono utilizzando REST:

server: server semplice con un endpoint OTTENERE, /, che stampa "ciao mondo" sulla console.
carico: script a cui invia il traffico server, con un numero configurabile di richieste al secondo.

Esecuzione di un'applicazione dal codice sorgente

Per esplorare l'applicazione di esempio, eseguila in Cloud Shell o sul tuo computer.
1) Nel catalogo istio-samples/sample-apps/helloserver correre server:

python3 server/server.py

Quando si esegue server viene visualizzato quanto segue:

INFO:root:Starting server...

2) Aprire un'altra finestra del terminale a cui inviare le richieste server. Se utilizzi Cloud Shell, fai clic sull'icona Aggiungi per aprire un'altra sessione.
3) Invia una richiesta a server:

curl http://localhost:8080

il server risponde:

Hello World!

4) Dalla directory in cui hai scaricato il codice di esempio, vai alla directory che contiene carico:

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

5) Creare le seguenti variabili d'ambiente:

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

6) Corri virtualenv:

virtualenv --python python3 env

7) Attiva l'ambiente virtuale:

source env/bin/activate

8) Stabilire i requisiti per carico:

pip3 install -r requirements.txt

9) Corri carico:

python3 loadgen.py

Quando si esegue carico visualizza qualcosa di simile al seguente messaggio:

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

In un'altra finestra del terminale server restituisce i seguenti messaggi alla console:

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

Dal punto di vista della rete, l'intera applicazione viene eseguita su un singolo host (computer locale o macchina virtuale Cloud Shell). Pertanto è possibile utilizzare localhosta cui inviare richieste server.
10) Fermarsi carico и server, accedere Ctrl-c in ogni finestra del terminale.
11) Nella finestra del terminale carico disattivare l'ambiente virtuale:

deactivate

Creazione del pacchetto di un'applicazione in contenitori

Per eseguire l'applicazione su GKE, è necessario creare il pacchetto dell'applicazione di esempio − server и carico - in contenitori. Un contenitore è un modo per comprimere un'applicazione per isolarla dal suo ambiente.

Per comprimere un'applicazione in un contenitore, è necessario Dockerfile. Dockerfile è un file di testo che definisce i comandi per creare il codice sorgente dell'applicazione e le sue dipendenze Immagine Docker. Una volta creata, carica l'immagine in un registro contenitori come Docker Hub o Registro dei container.

L'esempio lo ha già fatto Dockerfile per server и carico con tutti i comandi necessari per raccogliere immagini. Sotto - Dockerfile per 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" ]

Squadra DA pitone:3-slim come base dice a Docker di usare l'ultima versione Immagine Python3 come base.
Squadra COPIA. . copia i file sorgente nella directory di lavoro corrente (solo nel nostro caso server.py) nel file system del contenitore.
PUNTO D'ENTRATA definisce il comando utilizzato per avviare il contenitore. Nel nostro caso, questo comando è quasi uguale a quello che hai utilizzato per eseguire server.py dal codice sorgente.
Squadra ESPORRE indica che server attende i dati attraverso la porta 8080. Questa squadra no fornisce porti. Questa è una sorta di documentazione necessaria per aprire la porta 8080 quando si avvia il contenitore.

Preparazione alla containerizzazione dell'applicazione

1) Imposta le seguenti variabili di ambiente. Sostituire PROGETTO_ID al tuo ID progetto GCP.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

Usare i valori PROGETTO_ID и GCR_REPO tagghi l'immagine Docker quando la crei e la invii a un Container Registry privato.

2) Imposta il progetto GCP predefinito per lo strumento da riga di comando gcloud.

gcloud config set project $PROJECT_ID

3) Imposta la zona predefinita per lo strumento da riga di comando gcloud.

gcloud config set compute/zone us-central1-b

4) Assicurati che il servizio Container Registry sia abilitato nel progetto GCP.

gcloud services enable containerregistry.googleapis.com

Server di containerizzazione

Vai alla directory in cui si trova l'esempio server:

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

Assemblare l'immagine utilizzando Dockerfile e le variabili d'ambiente che hai definito in precedenza:
```
docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1 .
```

Parametro -t rappresenta il tag Docker. Questo è il nome dell'immagine che utilizzi durante la distribuzione del contenitore.

Carica l'immagine nel Container Registry:

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

Containerizzazione del carico

1) Vai alla directory in cui si trova l'esempio carico:

cd ../loadgen

2) Raccogli l'immagine:

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

3) Carica l'immagine nel Container Registry:

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

Visualizza un elenco di immagini

Esamina l'elenco delle immagini nel repository e verifica che le immagini siano state caricate:

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

Il comando visualizza i nomi delle immagini appena caricate:

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

Creazione di un cluster GKE.

Questi contenitori possono essere eseguiti su una macchina virtuale Cloud Shell o su un computer con il comando run docker. Ma in un ambiente di produzione è necessario un modo per orchestrare i contenitori a livello centrale. Ad esempio, hai bisogno di un sistema che assicuri che i container siano sempre in esecuzione e di un modo per aumentare e aumentare le istanze di container aggiuntive se il traffico aumenta.

Per eseguire applicazioni containerizzate è possibile utilizzare G.K.E.. GKE è una piattaforma di orchestrazione dei container che aggrega le macchine virtuali in un cluster. Ogni macchina virtuale è chiamata nodo. I cluster GKE si basano sul sistema di gestione dei cluster Kubernetes open source. Kubernetes fornisce meccanismi per interagire con il cluster.

Creazione di un cluster GKE:

1) Crea un cluster:

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

Squadra gcloud crea un cluster istioready nel progetto GCP e nella zona predefinita specificata. Per eseguire Istio, ti consigliamo di avere almeno 4 nodi e una macchina virtuale n1-standard-2.

Il team crea il cluster in pochi minuti. Quando il cluster è pronto, il comando restituisce qualcosa di simile сообщение.

2) Fornire le credenziali nello strumento da riga di comando kubectlper usarlo per gestire il cluster:

gcloud container clusters get-credentials istioready

3) Ora puoi comunicare con Kubernetes tramite kubectl. Ad esempio, il seguente comando può scoprire lo stato dei nodi:

kubectl get nodes

Il comando produce un elenco di nodi:

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

Concetti chiave di Kubernetes

Il diagramma mostra un'applicazione su GKE:

Prima di distribuire i contenitori in GKE, apprendi i concetti chiave di Kubernetes. Alla fine ci sono i link se vuoi saperne di più.

Nodi e cluster. In GKE, un nodo è una macchina virtuale. Su altre piattaforme Kubernetes, un nodo può essere un computer o una macchina virtuale. Un cluster è una raccolta di nodi che può essere considerata una singola unità in cui si distribuisce un'applicazione containerizzata.
Baccelli. In Kubernetes, i contenitori vengono eseguiti in pod. Un pod in Kubernetes è un'unità indivisibile. Un Pod contiene uno o più contenitori. Distribuisci contenitori server e carico in baccelli separati. Quando sono presenti diversi contenitori in un pod (ad esempio, un server delle applicazioni e server proxy), i contenitori vengono gestiti come una singola entità e condividono le risorse del pod.
Distribuzioni. In Kubernetes, una distribuzione è un oggetto che è una raccolta di pod identici. La distribuzione avvia più repliche di pod distribuiti tra i nodi del cluster. La distribuzione sostituisce automaticamente i pod che non hanno funzionato o che non rispondono.
Servizio Kubernetes. Quando si esegue il codice dell'applicazione in GKE, la connessione tra carico и server. Quando hai avviato i servizi su una macchina virtuale o un desktop Cloud Shell, hai inviato richieste a server per favore localhost: 8080. Una volta distribuiti su GKE, i pod vengono eseguiti sui nodi disponibili. Per impostazione predefinita, non hai alcun controllo su quale nodo è in esecuzione il pod, quindi tu baccelli nessun indirizzo IP permanente.
Per ottenere un indirizzo IP per server, devi definire un'astrazione di rete sopra i pod. Questo è quello che è Servizio Kubernetes. Il servizio Kubernetes fornisce un endpoint persistente per una serie di pod. Ci sono alcuni tipi di servizi. server usi Load Balancer, che fornisce un indirizzo IP esterno da contattare server dall'esterno del cluster.
Kubernetes dispone anche di un sistema DNS integrato che assegna nomi DNS (ad esempio, ciaoserver.default.cluster.local) Servizi. Grazie a ciò, i pod all'interno del cluster comunicano con altri pod nel cluster tramite un indirizzo permanente. Il nome DNS non può essere utilizzato all'esterno del cluster, ad esempio in Cloud Shell o su un computer.

Kubernetes si manifesta

Quando hai eseguito l'applicazione dal sorgente, hai utilizzato il comando imperativo python3

server.py

L’imperativo implica un verbo: “fai questo”.

Utilizza Kubernetes modello dichiarativo. Ciò significa che non stiamo dicendo a Kubernetes esattamente cosa fare, ma piuttosto descriviamo lo stato desiderato. Ad esempio, Kubernetes avvia e arresta i pod secondo necessità per mantenere lo stato effettivo del sistema coerente con lo stato desiderato.

Indichi lo stato desiderato nei manifest o nei file Yamla. Un file YAML contiene le specifiche per uno o più oggetti Kubernetes.

L'esempio contiene un file YAML per server и carico. Ogni file YAML specifica lo stato desiderato dell'oggetto di distribuzione e del servizio 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

tipo indica il tipo dell'oggetto.
nome.metadati specifica il nome della distribuzione.
Primo campo spec contiene una descrizione dello stato desiderato.
spec.repliche indica il numero di cialde desiderato.
Sezione modello spec definisce un modello di pod. C'è un campo nelle specifiche del pod Immagine, che specifica il nome dell'immagine che deve essere estratta dal Container Registry.

Il servizio è così definito:

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

Load Balancer: i client inviano richieste all'indirizzo IP del sistema di bilanciamento del carico, che ha un indirizzo IP persistente ed è accessibile dall'esterno del cluster.
porta di destinazione: come ricorderete, la squadra ESPOSI 8080 в Dockerfile non ha fornito porti. Fornisci il porto 8080in modo da poter contattare il contenitore server fuori dal cluster. Nel nostro caso ciaosvc.default.cluster.local:80 (nome corto: ciaosvc) corrisponde al porto 8080 Indirizzi IP dei pod ciaoserver.
porto: questo è il numero di porta a cui altri servizi nel cluster invieranno le richieste.

loadgen.yaml

Oggetto di distribuzione a loadgen.yaml sembra server.yaml. La differenza è che l'oggetto di distribuzione contiene una sezione ENV. Definisce le variabili di ambiente necessarie carico e che hai installato durante l'esecuzione dell'applicazione dal sorgente.

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

Tempo carico non accetta richieste in arrivo, per il campo Digitare sconosciuto IP cluster. Questo tipo fornisce un indirizzo IP permanente che i servizi nel cluster possono utilizzare, ma questo indirizzo IP non è esposto a client esterni.

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

Distribuzione dei container in GKE

1) Vai alla directory in cui si trova l'esempio server:

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

2) Apri server.yaml in un editor di testo.
3) Sostituisci il nome nel campo Immagine al nome della tua immagine Docker.

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

Sostituire PROGETTO_ID al tuo ID progetto GCP.
4) Salva e chiudi server.yaml.
5) Distribuisci il file YAML a Kubernetes:

kubectl apply -f server.yaml

Una volta completato con successo, il comando produce il seguente codice:

deployment.apps/helloserver created
service/hellosvc created

6) Vai alla directory dove carico:

cd ../loadgen

7) Apri loadgen.yaml in un editor di testo.
8) Sostituisci il nome nel campo Immagine al nome della tua immagine Docker.

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

Sostituire PROGETTO_ID al tuo ID progetto GCP.
9) Salva e chiudi loadgen.yaml, chiudi l'editor di testo.
10) Distribuisci il file YAML a Kubernetes:

kubectl apply -f loadgen.yaml

Una volta completato con successo, il comando produce il seguente codice:

deployment.apps/loadgenerator created
service/loadgensvc created

11) Controlla lo stato dei pod:

kubectl get pods

Il comando mostra lo stato:

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

12) Estrarre i log dell'applicazione dal pod carico. Sostituire POD_ID all'identificatore della risposta precedente.

kubectl logs loadgenerator-POD_ID

13) Ottieni indirizzi IP esterni ciaosvc:

kubectl get service

La risposta al comando è simile alla seguente:

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) Invia una richiesta a ciaosvc: sostituire IP_ESTERNO all'indirizzo IP esterno ciaosvc.

curl http://EXTERNAL_IP

Affrontiamo Istio

Hai già distribuito un'applicazione su GKE. carico può utilizzare il DNS Kubernetes (ciaosvc:80) a cui inviare richieste servere puoi inviare richieste a server tramite indirizzo IP esterno. Sebbene Kubernetes abbia molte funzionalità, mancano alcune informazioni sui servizi:

Come interagiscono i servizi? Quali sono i rapporti tra i servizi? Come scorre il traffico tra i servizi? Ne sei consapevole? carico invia richieste a server, ma immagina di non sapere nulla dell'applicazione. Per rispondere a queste domande, diamo un'occhiata all'elenco dei pod in esecuzione in GKE.
Metrica. Per quanto server risponde ad una richiesta in arrivo? Quante richieste al secondo vengono ricevute dal server? Dà messaggi di errore?
Informazioni sulla sicurezza. Traffico tra carico и server passa e basta HTTP o da mTLS?

Istio risponde a tutte queste domande. Per fare ciò, Istio inserisce un proxy sidecar Inviato in ogni baccello. Il proxy Envoy intercetta tutto il traffico in entrata e in uscita verso i contenitori delle applicazioni. Significa che server и carico ricevere tramite proxy sidecar Envoy e tutto il traffico da carico к server passa attraverso il proxy Envoy.

Le connessioni tra i proxy Envoy formano una rete di servizi. L'architettura mesh di servizi fornisce un livello di controllo sopra Kubernetes.

Poiché i proxy Envoy vengono eseguiti nei propri contenitori, Istio può essere installato su un cluster GKE quasi senza modifiche al codice dell'applicazione. Ma hai lavorato un po' per preparare la tua applicazione alla gestione di Istio:

Servizi per tutti i contenitori. Alle implementazioni server и carico legato al servizio Kubernetes. Anche carico, che non riceve richieste in arrivo, esiste un servizio.
Le porte nei servizi devono avere nomi. Sebbene le porte di servizio possano essere lasciate senza nome in GKE, Istio richiede che tu le specifichi nome del porto secondo il suo protocollo. Nel file YAML la porta per server detto httpperché il server utilizza il protocollo HTTP. Se servizio usato gRPC, chiameresti il porto grpc.
Le distribuzioni sono contrassegnate. Pertanto, puoi utilizzare le funzionalità di gestione del traffico di Istio, come la suddivisione del traffico tra versioni dello stesso servizio.

Installazione

Esistono due modi per installare Istio. Potere abilita Istio sull'estensione GKE o installare la versione open source di Istio sul grappolo. Con Istio su GKE, puoi gestire facilmente le installazioni e gli aggiornamenti di Istio durante l'intero ciclo di vita del cluster GKE. Se desideri la versione più recente di Istio o un maggiore controllo sulla configurazione del pannello di controllo Istio, installa la versione open source anziché l'estensione Istio su GKE. Per decidere l'approccio, leggere l'articolo Ho bisogno di Istio su GKE?.

Seleziona un'opzione, consulta la guida appropriata e segui le istruzioni per installare Istio sul tuo cluster. Se desideri utilizzare Istio con la tua applicazione appena distribuita, abilitare l'implementazione del sidecar per lo spazio dei nomi difetto.

pulizia

Per evitare che ti vengano addebitati sul tuo account Google Cloud Platform le risorse utilizzate in questo tutorial, elimina il cluster contenitore dopo aver installato Istio e giocato con l'applicazione di esempio. Ciò rimuoverà tutte le risorse del cluster, come istanze di calcolo, dischi e risorse di rete.

Quali sono le prospettive?

Esplora le seguenti tecnologie:
Esplora i seguenti strumenti:
Impara i concetti di Kubernetes:
1. Cluster
2. Nodi
3. Baccelli
4. Servizi
5. Distribuzione

Fonte: habr.com

Preparazione di un'applicazione per Istio