Percorso di apprendimento: trasforma un monolite in un'app GKE - Esegui il deployment dell'app in un cluster GKE

Questo è il quinto e ultimo tutorial di un percorso di apprendimento che ti insegna a modularizzare e containerizzare un'app monolitica.

Il percorso di apprendimento è costituito dai seguenti tutorial:

  1. Panoramica
  2. Informazioni sul monolite
  3. Modularizza il monolite
  4. Preparare l'app modulare per la containerizzazione
  5. Containerizzare l'app modulare
  6. Esegui il deployment dell'app in un cluster GKE (questo tutorial)

Nel tutorial precedente, Containerizza l'app modulare, hai preparato l'app modulare Cymbal Books per il deployment. Hai inserito i moduli dell'app in container, hai testato i container risultanti e hai eseguito il push delle immagini container in Artifact Registry.

In questo tutorial, esegui il deployment dell'app containerizzata in un cluster Google Kubernetes Engine. Questo passaggio completa la trasformazione dell'app Cymbal Books in un sistema modulare e scalabile che viene eseguito su un cluster Kubernetes.

Costi

Se segui i passaggi descritti in questo tutorial, al tuo account Google Cloudverranno addebitati costi. I costi iniziano quando abiliti GKE e esegui il deployment dell'app di esempio Cymbal Books. Questi costi includono addebiti per cluster per GKE, come descritto nella pagina dei prezzi, e addebiti per l'esecuzione di VM Compute Engine.

Per evitare addebiti non necessari, assicurati di disabilitare GKE o eliminare il progetto al termine di questo tutorial.

Prima di iniziare

Prima di iniziare questo tutorial, assicurati di aver completato i tutorial precedenti della serie. Per una panoramica dell'intera serie e per i link a tutorial specifici, consulta Percorso di apprendimento: trasforma un monolite in un'app GKE - Panoramica.

In particolare, devi aver eseguito i passaggi del tutorial precedente, ovvero Containerizzare l'app modulare.

Configura il cluster GKE

Prima di poter eseguire il deployment dell'app modulare Cymbal Books, devi prima creare un cluster GKE. Questo cluster fornisce l'infrastruttura in cui verranno eseguiti i container della tua app.

In questo tutorial utilizzerai gcloud CLI per creare il cluster. In alternativa, puoi utilizzare la consoleGoogle Cloud , che fornisce una Graphic User Interface (GUI) per la creazione e la gestione di risorse Google Cloud come i cluster GKE.

Crea e verifica un cluster GKE

Un cluster GKE fornisce le risorse di calcolo necessarie per eseguire i container in Kubernetes. Segui questi passaggi per creare un cluster utilizzando la CLI gcloud.

  1. Vai alla Google Cloud console.

  2. Nella console, fai clic sul pulsante Attiva Cloud Shell: Attiva Cloud Shell

    Una sessione di Cloud Shell si apre in un frame nella parte inferiore della console.

  3. Imposta il progetto predefinito in Google Cloud CLI:

    gcloud config set project PROJECT_ID

    Sostituisci PROJECT_ID con l'ID del progetto che hai creato o selezionato nella sezione Seleziona o crea un progetto Google Cloud del tutorial precedente. Un ID progetto è una stringa univoca che distingue il tuo progetto da tutti gli altri progetti in Google Cloud. Per individuare l'ID progetto, vai al selettore dei progetti. In questa pagina puoi visualizzare gli ID progetto di ciascuno dei tuoi Google Cloud progetti.

  4. Crea un cluster GKE:

    gcloud container clusters create CLUSTER_NAME \
    --zone=ZONE \
    --num-nodes=2

    Sostituisci quanto segue:

    • CLUSTER_NAME: un nome per il cluster, ad esempio cymbal-cluster.

    • ZONE: la zona in cui vuoi creare il cluster, ad esempio us-central1-a o europe-west1-b. Per un elenco completo delle zone disponibili, consulta Regioni e zone.

  5. Recupera le credenziali del cluster in modo che la CLI kubectl possa connettersi al cluster:

    gcloud container clusters get-credentials CLUSTER_NAME \
    --zone=ZONE

    Questo comando aggiorna il file di configurazione di Kubernetes, che per impostazione predefinita è archiviato in ~/.kube/config. Questo file di configurazione contiene le credenziali richieste da kubectl per interagire con il tuo cluster GKE.

  6. Verifica che kubectl sia connesso al cluster elencando i nodi del cluster:

    kubectl get nodes

    Se la configurazione va a buon fine, questo comando elenca i nodi nel tuo cluster GKE. Poiché hai creato il cluster con --num-nodes=2, dovresti visualizzare informazioni su due nodi, simili a quelle seguenti:

    NAME                                         STATUS    ROLES    AGE    VERSION
gke-nov18-default-pool-6a8f9caf-bryg   Ready     <none>   30s    v1.30.8-gke.1128000
gke-nov18-default-pool-6a8f9caf-ut0i   Ready     <none>   30s    v1.30.8-gke.1128000

    In questo esempio, entrambi i nodi si trovano nello stato Ready. Questo stato indica che il cluster GKE è pronto per ospitare i tuoi workload containerizzati.

Esegui il deployment dell'app

Ora che hai creato un cluster GKE, puoi eseguirvi il deployment dell'app Cymbal Books. Per eseguire il deployment di un'app in un cluster, applica il manifest Kubernetes al cluster.

Applica il manifest Kubernetes

In Cloud Shell, esegui il deployment dell'app nel cluster GKE eseguendo i seguenti comandi:

  1. Vai alla directory radice dell'applicazione containerizzata:

    cd kubernetes-engine-samples/quickstarts/monolith-to-microservices/containerized/

  2. Applica il manifest Kubernetes:

    kubectl apply -f kubernetes_manifest.yaml

Il comando precedente indica a Kubernetes di creare le risorse specificate nel file kubernetes-manifest.yaml. Queste risorse includono servizi, un deployment e pod.

Hai incontrato per la prima volta i servizi nella sezione Modifica il codice modulare nell'esercitazione Prepara l'app modulare per la containerizzazione. In quel tutorial, hai aggiornato il codice dell'app per utilizzare i nomi dei servizi anziché localhost. Questo aggiornamento consente a Kubernetes di instradare le richieste tra i moduli e garantisce che i moduli possano comunicare tra loro all'interno di un cluster. Ora, quando applichi il manifest, Kubernetes crea i servizi all'interno del cluster.

Un deployment è un oggetto API Kubernetes che consente di eseguire più repliche di pod distribuite tra i nodi di un cluster. La sezione successiva spiega cosa sono i pod.

Che cos'è un pod Kubernetes?

Nel tutorial precedente, hai creato un'immagine container per ogni modulo dell'app Cymbal Books. Ad esempio, hai creato immagini container basate sui moduli home_app e book_details_app.

Quando utilizzi il comando kubectl apply per eseguire il deployment del manifest Kubernetes, Kubernetes estrae le immagini container da Artifact Registry nel cluster. Nel cluster, le immagini container diventano container e i container vengono eseguiti all'interno dei pod.

Un pod è un ambiente isolato in cui vengono eseguiti i container e svolge le seguenti attività:

  • Alloca CPU e memoria: un pod fornisce le risorse necessarie ai container per funzionare.
  • Fornisce il networking: ogni pod ha il proprio indirizzo IP. In questo modo, il pod può comunicare con gli altri pod.

I pod vengono eseguiti sui nodi, ovvero le macchine che forniscono potenza di calcolo per il cluster. Kubernetes assegna automaticamente i pod ai nodi e li distribuisce tra i nodi del cluster per ridurre il rischio di sovraccarico di un singolo nodo. Questa distribuzione aiuta il cluster a utilizzare in modo efficiente le risorse di calcolo e memoria.

Verifica il deployment

Dopo aver applicato il manifest Kubernetes con il comando kubectl apply, verifica che il deployment dell'app sia stato eseguito correttamente nel cluster. Per verificare la deploymente, controlla che i pod e i servizi siano in esecuzione correttamente.

Controllare i pod

Per visualizzare i pod nel cluster, esegui questo comando:

kubectl get pods

Questo comando elenca i pod e il loro stato attuale. Cerca la colonna STATO per verificare che tutti i pod siano contrassegnati come Running, il che indica che sono in esecuzione e pronti a gestire le richieste. L'output previsto è simile al seguente:

NAME                             READY   STATUS    RESTARTS   AGE
home-app-67d59c6b6d-abcde        1/1     Running   0          30s
book-details-app-6d8bcbc58f-xyz  1/1     Running   0          30s
book-reviews-app-75db4c4d7f-def  1/1     Running   0          30s
images-app-7f8c75c79c-ghi        1/1     Running   0          30s

Lo stato di un pod inizialmente viene visualizzato come Pending durante la creazione e l'avvio dei relativi container. Se un pod rimane Pending per un periodo prolungato, il cluster potrebbe non disporre di risorse sufficienti per consentire al pod di entrare in uno stato Running integro. Se un pod ha lo stato CrashLoopBackOff, potrebbe esserci un problema con il contenitore. I passaggi per la risoluzione dei problemi sono forniti più avanti nel tutorial.

Controllare i servizi

I servizi consentono la comunicazione tra i pod e consentono a client esterni (ad esempio utenti, script automatizzati o strumenti di monitoraggio) di accedere all'app. Per visualizzare i servizi nel cluster, esegui questo comando:

kubectl get services

L'output di questo comando è simile al seguente:

NAME               TYPE           CLUSTER-IP      EXTERNAL-IP       PORT(S)        AGE
home-app-service   LoadBalancer   10.12.3.4       35.185.1.2        80:30837/TCP   30s
details-service    ClusterIP      10.12.3.5       <none>            80/TCP         30s
reviews-service    ClusterIP      10.12.3.6       <none>            80/TCP         30s
images-service     LoadBalancer   10.12.3.7       34.125.6.3        80:32014/TCP   30s

I campi chiave da osservare nell'output sono i seguenti:

  • TYPE: questo campo indica come viene esposto il servizio. I servizi di tipo LoadBalancer forniscono l'accesso esterno all'app.
  • EXTERNAL-IP: per un servizio di tipo LoadBalancer, il campo EXTERNAL-IP mostra l'indirizzo IP pubblico che gli utenti possono inserire nel browser web per accedere all'app. Per un servizio di tipo ClusterIP, questo campo è vuoto perché i servizi ClusterIP sono accessibili solo all'interno del cluster.

Testa il deployment

Dopo aver eseguito il deployment dell'app Cymbal Books nel cluster GKE, verifica che l'app sia accessibile e che i container possano comunicare tra loro.

Accedere all'app

Verifica che l'app sia accessibile seguendo questi passaggi:

  1. Recupera l'indirizzo IP esterno per home-app-service:

    kubectl get services

    Cerca la colonna **EXTERNAL-IP** nell'output e prendi nota dell'indirizzo IP associato a home-app-service.

  2. Apri un browser web e inserisci il seguente URL:

    http://EXTERNAL-IP

    Sostituisci EXTERNAL-IP con l'indirizzo IP che hai trovato nel passaggio precedente.

  3. Verifica che la home page dell'app Cymbal Books venga caricata correttamente.

Verificare la comunicazione tra i servizi

I contenitori nell'app Cymbal Books si basano sui servizi per lo scambio di informazioni. Assicurati che i container possano comunicare in modo efficace seguendo questi passaggi:

  1. Recupera l'indirizzo IP esterno per home-app-service come descritto in precedenza.

  2. Utilizza l'interfaccia dell'app per testare le interazioni tra i contenitori. Per farlo, verifica che le seguenti funzionalità funzionino facendo clic su tutti i link disponibili nell'interfaccia dell'app:

    • Controlla le immagini di copertina dei libri: verifica che le immagini di copertina dei libri vengano caricate correttamente sia nella home page che nella pagina dei dettagli del libro. In caso affermativo, i container home_app e book_details_app comunicano correttamente con il container images_app.
    • Visualizza dettagli del libro: vai alla pagina dei dettagli di un libro dalla home page. Se vedi i dettagli di un libro, il contenitore home_app comunica correttamente con book_details_app.
    • Visualizza le recensioni dei libri: fai clic su un link di recensione di un libro per verificare che il contenitore home_app possa comunicare con il contenitore book_reviews_app.

La tua app è ora in esecuzione su un cluster GKE.

Complimenti! Hai visto come trasformare un'app monolitica in un sistema modulare e containerizzato che viene eseguito su un cluster GKE live. Durante il percorso, hai imparato a dividere il codice strettamente accoppiato in moduli indipendenti, a creare ed eseguire il push di immagini container in un repository, a definire i manifest Kubernetes e a eseguire il deployment dell'app dal registro a GKE. Si tratta di un risultato importante, che riflette i passaggi reali che i team intraprendono per modernizzare le applicazioni per il cloud.

Risoluzione dei problemi

Se l'app non risponde o i container non comunicano, utilizza i seguenti passaggi per la risoluzione dei problemi per diagnosticare e risolvere i problemi comuni.

Controllare lo stato dei tuoi Pod

Inizia elencando tutti i pod nel cluster per determinare se sono in esecuzione come previsto:

kubectl get pods

Esamina l'output per verificare che ogni pod si trovi nello stato Running. Se un pod non è in esecuzione, annota il suo nome per un'ispezione più approfondita.

Esaminare i log dei pod

Se un pod non gestisce correttamente le richieste, controlla i log per verificare la presenza di eventuali messaggi di errore:

kubectl logs POD_NAME

Sostituisci POD_NAME con il nome del pod che vuoi ispezionare. Questo comando è utile per identificare problemi di avvio o errori di runtime.

Descrivere un pod per informazioni dettagliate

Se un pod rimane in uno stato diverso da Running per più di cinque minuti, ad esempio si trova nello stato Pending, ContainerCreating o CrashLoopBackOff, puoi visualizzare informazioni dettagliate sullo stato e sugli eventi del pod utilizzando il seguente comando:

kubectl describe pod POD_NAME

Sostituisci POD_NAME con il nome del pod per cui vuoi visualizzare informazioni dettagliate.

La sezione Events nell'output potrebbe indicare che i vincoli delle risorse o i problemi con i pull delle immagini impediscono l'avvio corretto del pod.

Verificare la configurazione del servizio

Assicurati che i tuoi servizi siano configurati correttamente, in particolare il servizio che espone il modulo della casa con un indirizzo IP esterno. Elenca i servizi con il seguente comando:

kubectl get services

Se noti che il modulo Servizio per la casa ha un indirizzo EXTERNAL-IP indicato come Pending, esegui questo comando:

kubectl describe service SERVICE_NAME

Sostituisci SERVICE_NAME con il nome del servizio del modulo della casa.

Questo comando fornisce maggiori dettagli sulla configurazione del servizio e ti aiuta a identificare ritardi nell'assegnazione dell'indirizzo IP esterno o altri problemi di configurazione.

Controllare gli eventi del cluster

Puoi esaminare gli eventi del cluster per determinare se un problema interessa più componenti del cluster:

kubectl get events

Questo comando può determinare se problemi più ampi di risorse o di rete influiscono sul tuo deployment.

Esegui la pulizia delle risorse

L'esecuzione di un cluster GKE comporta dei costi. Dopo aver completato questo tutorial, esegui la pulizia delle risorse per evitare addebiti aggiuntivi. Segui questi passaggi per rimuovere il cluster e, facoltativamente, l'intero progetto.

Elimina il cluster GKE

Per eliminare il cluster GKE, utilizza questo comando:

gcloud container clusters delete CLUSTER_NAME
    --zone=ZONE

Sostituisci quanto segue:

  • CLUSTER_NAME: il nome del cluster che hai creato, ad esempio cymbal-cluster.

  • ZONE: la zona in cui è stato creato il cluster, ad esempio us-central1-a.

Quando ti viene chiesto, conferma l'eliminazione.

Verifica che il cluster sia stato eliminato.

Per assicurarti che il cluster sia stato eliminato, esegui questo comando:

gcloud container clusters list

Il cluster non dovrebbe più essere visualizzato nell'output. In questo caso, attendi qualche istante e riprova.

(Facoltativo) Elimina il Google Cloud progetto

Se hai creato un Google Cloud progetto specifico per questo tutorial e non ne hai più bisogno, puoi eliminare l'intero Google Cloud progetto. L'eliminazione del progetto rimuove tutte le risorse e interrompe la fatturazione per il progetto:

  1. Nella console Google Cloud , apri la pagina Gestisci risorse.
  2. Seleziona il progetto da eliminare.
  3. Fai clic su Elimina progetto e segui le istruzioni per confermare.

Riepilogo della serie

Complimenti! Completando questo percorso di apprendimento, hai appreso le nozioni di base per convertire un'app monolitica in un'app modulare e containerizzata che viene eseguita su un cluster Kubernetes. I passaggi seguenti riepilogano la procedura:

  1. Informazioni sul monolite

    • Esplorare la struttura dell'app monolitica Cymbal Books.
    • Configura un ambiente Python locale per eseguire il monolite e testarne gli endpoint.
    • Ha acquisito una comprensione del codebase dell'app per prepararlo alla modularizzazione.

  2. Modularizza il monolite

    • Ho imparato a dividere il codice monolitico in moduli separati. Ogni modulo gestisce una funzionalità distinta, ad esempio la visualizzazione dei dettagli o delle recensioni di un libro.
    • Abbiamo visto come questi moduli vengono implementati come app Flask indipendenti in esecuzione su porte diverse.
    • Testato l'app modularizzata.

  3. Prepara il codice modulare per la containerizzazione

    • È stato scoperto che per utilizzare i nomi dei servizi anziché localhost, devi aggiornare gli URL in home.py.
    • Hai imparato come il manifest Kubernetes definisce i servizi che consentono ai moduli dell'app, che comunicano già tra loro, di trovarsi l'un l'altro nel contesto di un cluster Kubernetes.

  4. Containerizzare l'app modulare

    • Configura un progetto Google Cloud e clona l'app da GitHub in Cloud Shell.
    • Immagini container create per ogni modulo utilizzando Docker e testate localmente.
    • Eseguito il push delle immagini container in Artifact Registry per preparare l'app per il deployment in un cluster.
    • È stato aggiornato il manifest di Kubernetes in modo che faccia riferimento ai percorsi delle immagini container in Artifact Registry.

  5. Esegui il deployment dell'app in un cluster GKE (il tutorial che stai seguendo ora):

    • È stato creato un cluster GKE.
    • È stato eseguito il deployment delle immagini container da Artifact Registry al cluster GKE.
    • Testata la versione finale dell'app, ora scalabile e in esecuzione in un ambiente Kubernetes.

Passaggi successivi

Per ulteriore formazione pratica su come creare cluster, consulta la nostra serie Learning Path: Scalable applications.