Cloud Service Mesh è un potente strumento per la gestione e il monitoraggio delle applicazioni distribuite. Per ottenere il massimo da Cloud Service Mesh, è utile comprendere dalle astrazioni sottostanti, tra cui container e Kubernetes. Questo tutorial spiega come preparare un'applicazione per Cloud Service Mesh dal codice sorgente a un contenitore in esecuzione su GKE, fino al punto immediatamente precedente all'installazione di Cloud Service Mesh.
Se hai già familiarità con i concetti di Kubernetes e service mesh, puoi saltare questo tutorial e andare direttamente alla guida all'installazione di Cloud Service Mesh.
Obiettivi
- Esplora una semplice applicazione "Hello World" multiservizio.
- Esegui l'applicazione dall'origine
- Containerizza l'applicazione.
- Creare un cluster Kubernetes.
- Esegui il deployment dei container nel cluster.
Prima di iniziare
Per abilitare l'API Cloud Service Mesh, segui questi passaggi:- Visita la pagina di Kubernetes Engine nella console Google Cloud.
- Crea o seleziona un progetto.
- Attendi che l'API e i relativi servizi siano abilitati. L'operazione può richiedere diversi minuti.
-
Make sure that billing is enabled for your Google Cloud project.
Questo tutorial utilizza Cloud Shell, che esegue il provisioning di una macchina virtuale (VM) Compute Engine g1-small che esegue un sistema operativo Linux basato su Debian.
Prepara Cloud Shell
I vantaggi dell'utilizzo di Cloud Shell sono:
- Gli ambienti di sviluppo Python 2 e Python 3 (incluso
virtualenv
) sono configurati. - Gli strumenti a riga di comando
gcloud
,docker
,git
ekubectl
utilizzati in questa tutorial sono già installati. Puoi scegliere tra editor di testo:
Editor di codice, a cui puoi accedere facendo clic su nella parte superiore della finestra di Cloud Shell.
Emacs, Vim o Nano, a cui si accede dalla riga di comando in Cloud Shell.
In the Google Cloud console, activate Cloud Shell.
At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Scarica il codice campione
Scarica il codice sorgente di
helloserver
:git clone https://github.com/GoogleCloudPlatform/anthos-service-mesh-samples
Passa alla directory codice campione:
cd anthos-service-mesh-samples/docs/helloserver
Esplora l'applicazione multiservizio
L'applicazione di esempio è scritta in Python e ha due componenti comunicare tramite REST:
server
: un semplice server con un endpointGET
,/
, che stampa "hello world" nella console.loadgen
: uno script che invia traffico aserver
, con un numero configurabile di richieste al secondo (RPS).
Esegui l'applicazione dall'origine
Per acquisire familiarità con l'applicazione di esempio, eseguila in Cloud Shell.
Dalla directory
sample-apps/helloserver
, eseguiserver
:python3 server/server.py
All'avvio,
server
mostra quanto segue:INFO:root:Starting server...
Apri un'altra finestra del terminale per inviare richieste al dispositivo
server
. Fai clic su per aprire un'altra sessione.Invia una richiesta al
server
:curl http://localhost:8080
server
risponde:Hello World!
Dalla directory in cui hai scaricato il codice di esempio, vai alla directory che contiene il file
loadgen
:cd YOUR_WORKING_DIRECTORY/anthos-service-mesh-samples/docs/helloserver/loadgen
Crea le seguenti variabili di ambiente:
export SERVER_ADDR=http://localhost:8080 export REQUESTS_PER_SECOND=5
Avvio
virtualenv
:virtualenv --python python3 env
Attiva l'ambiente virtuale:
source env/bin/activate
Installa i requisiti per
loadgen
:pip3 install -r requirements.txt
Esegui il
loadgen
:python3 loadgen.py
All'avvio,
loadgen
restituisce un messaggio simile al seguente:Starting loadgen: 2019-05-20 10:44:12.448415 5 request(s) complete to http://localhost:8080
Nell'altra finestra del terminale,
server
scrive messaggi nella console simili ai seguenti: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 ora è in esecuzione sullo stesso host. Per questo motivo puoi utilizzare
localhost
per inviare richieste aiserver
.Per interrompere
loadgen
eserver
, inserisciCtrl-c
in ogni finestra del terminale.Nella finestra del terminale
loadgen
, disattiva l'ambiente virtuale:deactivate
Containerizza l'applicazione
Per eseguire l'applicazione su GKE, devi pacchettizzare l'applicazione di esempio, sia server
che loadgen
, in container. Un
container è un modo per pacchettizzare un'applicazione in modo che sia isolata dall'ambiente di base.
Per containerizzare l'applicazione, è necessario un Dockerfile
. Un Dockerfile
è un file di testo che definisce i comandi necessari per assemblare il codice sorgente dell'applicazione e le relative dipendenze in un'immagine Docker. Dopo aver creato
un'immagine, la carichi in un Container Registry, come Docker Hub
Container Registry.
L'esempio include un valore Dockerfile
sia per server
che per loadgen
con tutti i comandi necessari per creare le immagini. Di seguito è riportato il
Dockerfile
per il server
:
- Il comando
FROM python:3-slim as base
indica a Docker di utilizzare l'ultima immagine Python 3 come l'immagine di base. - Il comando
COPY . .
copia i file di origine nell'ambiente di lavoro attuale (in questo caso, soloserver.py
) nel file del container di un sistema operativo completo. ENTRYPOINT
definisce il comando utilizzato per eseguire il container. In questo caso, il comando è quasi uguale a quello che hai utilizzato per eseguireserver.py
dal codice sorgente.- Il comando
EXPOSE
specifica cheserver
è in ascolto sulla porta8080
. Questo comando esporre eventuali porte, ma serve da documentazione che ti serve per aprire la porta8080
quando esegui containerizzato.
Prepararsi a containerizzare l'applicazione
Imposta le seguenti variabili di ambiente. Sostituisci
PROJECT_ID
con l'ID del tuo progetto Google Cloud.export PROJECT_ID="PROJECT_ID"
export GCR_REPO="asm-ready"
Utilizzerai i valori
PROJECT_ID
eGCR_REPO
per taggare l'immagine Docker quando crei ed esegui il push sul tuo Container Registry privato.Imposta il progetto Google Cloud predefinito per Google Cloud CLI.
gcloud config set project $PROJECT_ID
Imposta la zona predefinita per Google Cloud CLI.
gcloud config set compute/zone us-central1-b
Assicurati che il servizio Container Registry sia abilitato nel tuo progetto Google Cloud.
gcloud services enable containerregistry.googleapis.com
Containerizza server
Passa alla directory in cui si trova il campione
server
:cd YOUR_WORKING_DIRECTORY/anthos-service-mesh-samples/docs/helloserver/server/
Crea l'immagine utilizzando
Dockerfile
e le variabili di ambiente che hai definito in precedenza:docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1 .
Il flag
-t
rappresenta il tag Docker. Questo è il nome dell'immagine che utilizzi per il deployment del container.Esegui il push dell'immagine a Container Registry:
docker push gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1
Containerizza loadgen
Passa alla directory in cui si trova il campione
loadgen
:cd ../loadgen
Crea l'immagine:
docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/loadgen:v0.0.1 .
Esegui il push dell'immagine a Container Registry:
docker push gcr.io/$PROJECT_ID/$GCR_REPO/loadgen:v0.0.1
Elenca le immagini
Visualizza un elenco delle immagini nel repository per verificare che siano state pushate:
gcloud container images list --repository gcr.io/$PROJECT_ID/asm-ready
Il comando risponde con i nomi delle immagini che hai appena eseguito il push:
NAME gcr.io/PROJECT_ID/asm-ready/helloserver gcr.io/PROJECT_ID/asm-ready/loadgen
Crea un cluster GKE
Puoi eseguire questi container sulla VM Cloud Shell utilizzando
Comando docker run
. In fase di produzione, però, devi orchestrare i container
in modo più unificato. Ad esempio, hai bisogno di un sistema che garantisca
i container sono sempre in esecuzione e ti serve un modo per fare lo scale up
di istanze aggiuntive di un container per gestire l'aumento del traffico.
Puoi utilizzare la modalità GKE per eseguire applicazioni containerizzate. GKE è una piattaforma di orchestrazione dei container che funziona collegando le VM in un cluster. Ogni VM è indicata come nodo. I cluster GKE sono basati sul sistema di gestione dei cluster open source Kubernetes. Kubernetes fornisce meccanismi attraverso i quali interagisci con il cluster.
Per creare un cluster GKE:
Crea il cluster:
gcloud container clusters create asm-ready \ --cluster-version latest \ --machine-type=n1-standard-4 \ --num-nodes 4
Il comando
gcloud
crea un cluster in la zona e il progetto Google Cloud che hai impostato in precedenza. Per eseguire Cloud Service Mesh, consigliamo almeno 4 nodi e il tipo di macchina n1-standard-4.Il completamento del comando per la creazione del cluster richiede alcuni minuti. Quando il cluster è pronto, il comando restituisce un messaggio simile al seguente:
NAME LOCATION MASTER_VERSION MASTER_IP MACHINE_TYPE NODE_VERSION NUM_NODES STATUS asm-ready us-central1-b 1.13.5-gke.10 203.0.113.1 n1-standard-2 1.13.5-gke.10 4 RUNNING
Fornisci le credenziali al
kubectl
command- a riga di comando, in modo da poterlo utilizzare per gestire il cluster:gcloud container clusters get-credentials asm-ready
Ora puoi utilizzare
kubectl
per comunicare con Kubernetes. Ad esempio, puoi eseguire il seguente comando per ottenere lo stato dei nodi:kubectl get nodes
Il comando risponde con un elenco di nodi, simile al seguente:
NAME STATUS ROLES AGE VERSION gke-asm-ready-default-pool-dbeb23dc-1vg0 Ready <none> 99s v1.13.6-gke.13 gke-asm-ready-default-pool-dbeb23dc-36z5 Ready <none> 100s v1.13.6-gke.13 gke-asm-ready-default-pool-dbeb23dc-fj7s Ready <none> 99s v1.13.6-gke.13 gke-asm-ready-default-pool-dbeb23dc-wbjw Ready <none> 99s v1.13.6-gke.13
Comprendere i concetti chiave di Kubernetes
Il seguente diagramma mostra l'applicazione in esecuzione su GKE:
Prima di eseguire il deployment dei container in GKE, ti consigliamo di ripassa alcuni concetti chiave di Kubernetes. Alla fine di questo tutorial vengono forniti i link per poter conoscere meglio ogni concetto.
Nodi e cluster: in GKE, un nodo è una VM. Su altre piattaforme Kubernetes, un nodo può essere una macchina fisica o virtuale. Un cluster è un insieme di nodi che possono essere trattati insieme come una singola macchina, su cui eseguirai il deployment di un'applicazione containerizzata.
Pod: in Kubernetes, i container vengono eseguiti all'interno di un pod. Un pod è dell'unità atomica in Kubernetes. Un pod contiene uno o più container. Esegui il deployment dei container
server
eloadgen
ciascuno nel proprio pod. Quando viene eseguito un pod in più container (ad esempio, un server delle applicazioni server proxy), i container sono gestiti come una singola entità e condividono le risorse del pod.Deployment: un deployment è un oggetto Kubernetes che rappresenta un insieme di pod identici. Un oggetto Deployment esegue più repliche dei pod distribuiti tra i nodi di un cluster. Un deployment sostituisce automaticamente i pod che si arrestano in modo anomalo o non rispondono.
Servizio Kubernetes: esecuzione del codice dell'applicazione nelle modifiche GKE il networking tra
loadgen
eserver
. Quando eseguivi i servizi in una VM Cloud Shell, potevi inviare richieste aserver
utilizzando l'indirizzolocalhost:8080
. Dopo il deployment in GKE, i pod sono pianificati per essere eseguiti sui nodi disponibili. Per impostazione predefinita, non puoi controllare su quale nodo è in esecuzione il pod, pertanto i pod non hanno indirizzi IP stabili.Per ottenere un indirizzo IP per
server
, devi definire una rete in cima ai pod, chiamata Servizio Kubernetes. Un servizio Kubernetes fornisce un endpoint di networking stabile per un insieme di pod. Esistono diversi tipi di Servizi.server
utilizza unLoadBalancer
, che espone un indirizzo IP esterno che puoi raggiungereserver
dall'esterno del cluster.Kubernetes ha anche un sistema DNS integrato, che assegna nomi DNS (ad ad esempio
helloserver.default.cluster.local
) ai Servizi. Ciò permette ai pod per raggiungere altri pod del cluster con un indirizzo stabile. Non puoi utilizzare questo nome DNS all'esterno del cluster, ad esempio da in Cloud Shell.
Manifest di Kubernetes
Quando hai eseguito l'applicazione dal codice sorgente, hai utilizzato un comando imperativo: python3 server.py
Imperativo significa basato sui verbi: "fai questo".
Al contrario, Kubernetes opera su una modello dichiarativo. Ciò significa che, anziché dire a Kubernetes esattamente cosa fare, fornisci a Kubernetes uno stato desiderato. Ad esempio, Kubernetes avvia e termina i pod secondo necessità, in modo che lo stato effettivo del sistema corrisponda a quello desiderato.
Puoi specificare lo stato desiderato in un insieme di manifest. YAML. Un file YAML contiene la specifica per uno o più oggetti Kubernetes.
Il sample contiene un file YAML per server
e loadgen
. Ogni file YAML specifica lo stato desiderato per l'oggetto e il servizio Kubernetes Deployment.
Server
kind
indica il tipo di oggetto.metadata.name
specifica il nome del deployment.- Il primo campo
spec
contiene una descrizione dello stato desiderato. spec.replicas
specifica il numero di pod desiderati.- La sezione
spec.template
definisce un modello di pod. Incluso nel specifica per i pod è il campoimage
, ovvero il nome l'immagine di cui eseguire il pull da Container Registry.
Il Servizio è definito come segue:
LoadBalancer
: i client inviano richieste all'indirizzo IP di un bilanciatore del carico di rete, che ha un indirizzo IP stabile ed è raggiungibile dall'esterno del cluster.targetPort
: ricorda che il comandoEXPOSE 8080
inDockerfile
non espone effettivamente alcuna porta. Esponi la porta8080
in modo da poter raggiungere il contenitoreserver
all'esterno del cluster. In questo caso,hellosvc.default.cluster.local:80
(nome breve:hellosvc
) si mappa alla porta8080
dell'IP del podhelloserver
.port
: questo è il numero di porta utilizzato dagli altri servizi del cluster quando inviano richieste.
Generatore di carico
L'oggetto Deployment in loadgen.yaml
è simile a server.yaml
. Un elemento degno di nota
è che l'oggetto Deployment contiene una sezione denominata env
. Questa
sezione definisce le variabili di ambiente richieste da loadgen
, che hai impostato
in precedenza quando hai eseguito l'applicazione dal codice sorgente.
Poiché loadgen
non accetta richieste in arrivo, il campo type
è impostato su ClusterIP
. Questo tipo fornisce un indirizzo IP stabile che può essere utilizzato dai servizi nel
cluster, ma l'indirizzo IP non è esposto ai client esterni.
Esegui il deployment dei container in GKE
Passa alla directory in cui si trova l'esempio
server
:cd YOUR_WORKING_DIRECTORY/anthos-service-mesh-samples/docs/helloserver/server/
Apri
server.yaml
in un editor di testo.Sostituisci il nome nel campo
image
con il nome della tua immagine Docker.image: gcr.io/PROJECT_ID/asm-ready/helloserver:v0.0.1
Sostituisci
PROJECT_ID
con il tuo progetto Google Cloud ID.Salva e chiudi
server.yaml
.Esegui il deployment del file YAML in Kubernetes:
kubectl apply -f server.yaml
In caso di esito positivo, il comando risponde con quanto segue:
deployment.apps/helloserver created service/hellosvc created
Passa alla directory in cui si trova
loadgen
.cd ../loadgen
Apri
loadgen.yaml
in un editor di testo.Sostituisci il nome nel campo
image
con il nome della tua immagine Docker.image: gcr.io/PROJECT_ID/asm-ready/loadgen:v0.0.1
Sostituisci
PROJECT_ID
con l'ID del tuo progetto Google Cloud.Salva e chiudi
loadgen.yaml
, quindi chiudi l'editor di testo.Esegui il deployment del file YAML in Kubernetes:
kubectl apply -f loadgen.yaml
Se l'operazione riesce, il comando risponde con quanto segue:
deployment.apps/loadgenerator created service/loadgensvc created
Controlla lo stato dei pod:
kubectl get pods
Il comando risponde con uno stato simile al seguente:
NAME READY STATUS RESTARTS AGE helloserver-69b9576d96-mwtcj 1/1 Running 0 58s loadgenerator-774dbc46fb-gpbrz 1/1 Running 0 57s
Recupera i log dell'applicazione dal pod
loadgen
. SostituisciPOD_ID
con l'identificatore dell'output precedente.kubectl logs loadgenerator-POD_ID
Recupera gli indirizzi IP esterni di
hellosvc
:kubectl get service
La risposta del 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
Invia una richiesta al
hellosvc
. SostituisciEXTERNAL_IP
con l'indirizzo IP esterno del tuohellosvc
.curl http://EXTERNAL_IP
Pronti per Cloud Service Mesh
A questo punto hai eseguito il deployment dell'applicazione su GKE. loadgen
puoi utilizzare il DNS di Kubernetes (hellosvc:80
) per inviare richieste a server
e
puoi inviare richieste a server
con un indirizzo IP esterno. Sebbene
Kubernetes offre molte funzionalità. Alcune informazioni sui servizi
mancanti:
- In che modo i servizi interagiscono? Qual è il rapporto tra
servizi? Come scorre il traffico tra i servizi? Sai che
loadgen
invia richieste aserver
, ma immagina di non conoscere bene l'applicazione. Non puoi rispondere a queste domande guardando il dei pod in esecuzione su GKE. - Metriche: quanto tempo impiega
server
per rispondere alle richieste in arrivo? Quante richieste al secondo (RPS) vengono inviate aserver
? Ci sono risposte di errore? - Informazioni di sicurezza: traffico tra
loadgen
eserver
pianoHTTP
o mTLS?
Cloud Service Mesh può fornire risposte a queste domande. Cloud Service Mesh è una versione del progetto open source Istio gestita da Google Cloud. Cloud Service Mesh funziona inserendo un proxy sidecar Envoy in ogni pod. Il proxy Envoy
intercetta tutto il traffico in entrata e in uscita verso i container delle applicazioni. Questo
significa che server
e loadgen
ricevono ciascuno un proxy sidecar Envoy e tutti
il traffico da loadgen
a server
è mediato dai proxy Envoy. Le connessioni tra questi proxy Envoy costituiscono il mesh di servizi. Questo servizio
architettura mesh fornisce un livello di controllo su Kubernetes.
Poiché i proxy Envoy vengono eseguiti nei propri container, puoi installare Cloud Service Mesh su un cluster GKE senza modifiche sostanziali al codice dell'applicazione. Tuttavia, hai preparato alcune delle risorse principali da instrumentare con Cloud Service Mesh:
- Servizi per tutti i container: i deployment
server
eloadgen
hanno entrambi è collegato a un servizio Kubernetes. Ancheloadgen
, che non riceve richieste in entrata, ha un servizio. - Le porte nei servizi devono essere denominate: anche se GKE ti consente di
definire porte di servizio senza nome, Cloud Service Mesh richiede che tu fornisca un
nome per una porta
che corrisponda al protocollo della porta. Nel file YAML, la porta per
server
è denominatahttp
perchéserver
utilizza il protocollo di comunicazioneHTTP
. Seservice
utilizzavagRPC
, il nome della porta saràgrpc
. - I deployment sono etichettati: questo consente di utilizzare la gestione del traffico di Cloud Service Mesh come la suddivisione del traffico tra le versioni dello stesso servizio.
Installa Cloud Service Mesh
Consulta la guida all'installazione di Cloud Service Mesh e segui le istruzioni per installare Cloud Service Mesh sul cluster.
Esegui la pulizia
Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.
Per eseguire la pulizia, elimina il cluster GKE. L'eliminazione del cluster elimina tutti i alle risorse che compongono il cluster dei container, come le istanze di calcolo, dischi e risorse di rete.
gcloud container clusters delete asm-ready
Passaggi successivi
Scopri di più sulle tecnologie utilizzate in questo tutorial:
Scopri di più sugli strumenti:
Scopri di più sui concetti di base di Kubernetes: