Questa pagina è stata tradotta dall'API Cloud Translation.

Percorso di apprendimento: trasforma un monolite in un'app GKE - Prepara l'app modulare per la containerizzazione

Standard

Questo è il terzo tutorial di un percorso di apprendimento che ti insegna come modularizzare e inserire in un container un'app monolitica.

Il percorso di apprendimento è costituito dai seguenti tutorial:

Panoramica
Informazioni sul monolite
Modularizza il monolite
Preparare l'app modulare per la containerizzazione (questo tutorial)
Containerizzare l'app modulare
Esegui il deployment dell'app in un cluster GKE

Nel tutorial precedente, Modularizzare il monolite, hai visto come dividere l'app Cymbal Books in moduli Flask indipendenti. In questo tutorial, scoprirai una singola modifica da apportare all'app modulare per prepararla alla containerizzazione.

Costi

Puoi completare questo tutorial senza incorrere in alcun addebito. Tuttavia, seguendo i passaggi descritti nell'ultimo tutorial di questa serie, verranno addebitati costi sul tuo accountGoogle Cloud . I costi iniziano quando abiliti GKE ed esegui il deployment dell'app Cymbal Books in un cluster GKE. Questi costi includono gli addebiti per cluster per GKE, come descritto nella pagina dei prezzi, e gli addebiti per l'esecuzione delle VM di 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.

Se hai già completato il primo tutorial, hai clonato un repository GitHub. Tutte e tre le versioni dell'app Cymbal Books si trovano in questo repository, all'interno delle seguenti cartelle:

monolith/
modular/
containerized/

Prima di continuare, controlla che queste cartelle siano presenti sul tuo computer.

Modificare il codice modulare

Nel tutorial precedente hai appreso che il modulo della home page comunica con gli altri moduli. Invia richieste agli endpoint degli altri moduli per recuperare dettagli, recensioni e immagini dei libri, quindi presenta questi dati in pagine HTML.

Nella cartella modular/, gli endpoint sono hardcoded in home.py, utilizzando localhost, come segue:

BOOK_SERVICE_URL = "http://localhost:8081"     # Book details module listens on port 8081
REVIEW_SERVICE_URL = "http://localhost:8082"   # Book reviews module listens on port 8082
IMAGE_SERVICE_URL = "http://localhost:8083"    # Image module listens on port 8083

Questi URL funzionano quando tutti i moduli vengono eseguiti sulla stessa macchina. Tuttavia, in un ambiente Kubernetes, i moduli possono essere spostati su macchine diverse per gestire gli errori o bilanciare il carico, il che significa che i loro indirizzi IP potrebbero cambiare.

Per assicurarsi che il modulo della home page possa ancora raggiungere gli altri moduli, gli URL devono utilizzare i nomi dei servizi Kubernetes anziché localhost. Un nome di servizio funge da alias che Kubernetes utilizza per indirizzare le richieste al modulo corretto, indipendentemente da dove viene eseguito. Ad esempio, quando il modulo della home page invia una richiesta a http://book-details-service/book/1, Kubernetes garantisce che la richiesta raggiunga il modulo dei dettagli del libro.

Non è necessario aggiornare manualmente questi URL. La versione dell'app nella cartella containerized/ include già questa modifica: gli URL localhost hardcoded sono stati sostituiti con i nomi dei servizi Kubernetes. Puoi visualizzare la versione aggiornata in containerized/home_app/home_app.py:

BOOK_SERVICE_URL = "http://book-details-service"
REVIEW_SERVICE_URL = "http://book-reviews-service"
IMAGE_SERVICE_URL = "http://images-service"

Questo aggiornamento garantisce il corretto funzionamento dell'app quando viene eseguita in un ambiente Kubernetes.

Il manifest Kubernetes

Nella sezione precedente hai visto come sono stati aggiornati gli endpoint dei moduli per utilizzare i nomi dei servizi Kubernetes. Definisci i nomi dei servizi nel manifest di Kubernetes.

Il manifest Kubernetes è un file di configurazione che definisce il tipo di cluster Kubernetes che vuoi creare per ospitare la tua app modulare. Il manifest è scritto in YAML o JSON. In questo file definisci elementi come i servizi (per il routing tra i moduli), il numero di repliche (istanze) di ciascun modulo e la quantità di CPU e memoria che ogni modulo può utilizzare.

Si potrebbe scrivere un'intera serie di tutorial sui manifest di Kubernetes. Il manifest è complesso perché definisce tutto ciò che riguarda il cluster Kubernetes: la sua struttura, il suo comportamento e le sue funzionalità. In questo tutorial, esamini solo in che modo i nomi dei servizi nel manifest corrispondono ai nomi utilizzati negli endpoint dei moduli. In un tutorial successivo, esegui il comando kubectl apply per creare il cluster GKE in base alla configurazione definita nel manifest, ma in questo tutorial esamini solo il manifest.

Visualizzare il manifest

In questa sezione, esaminerai come vengono definiti i servizi in un manifest Kubernetes che è stato scritto per te. Il file manifest, che è un file YAML, si trova nella cartella containerized/ del repository GitHub che hai clonato nel primo tutorial di questa serie. Segui questi passaggi per visualizzare una definizione di servizio:

Nel terminale, vai alla directory containerizzata nel repository clonato:
```
cd containerized
```
In un editor di testo, apri il file manifest Kubernetes:
```
cat kubernetes_manifest.yaml
```

Trova la definizione del servizio per il modulo book-details. Avrà un aspetto simile al seguente esempio:

apiVersion: v1
kind: Service
metadata:
name: book-details-service
spec:
selector:
    app: book-details-app
ports:
    - protocol: TCP
    port: 80  # External traffic on port 80
    targetPort: 8080  # Targeting container port 8080
type: ClusterIP

Il nome del servizio book-details-service nel manifest corrisponde al nome utilizzato nell'endpoint del modulo: http://book-details-service. Quando la tua app viene eseguita in Kubernetes, Kubernetes utilizza questi nomi di servizio per indirizzare le richieste ai moduli corretti.

Il manifest Kubernetes definisce le funzionalità del cluster Kubernetes, inclusi i servizi che gestiscono il routing delle richieste. Ogni modulo della tua app ha un servizio corrispondente definito nel manifest. Se aggiorni gli URL nel codice modulare in modo che corrispondano a questi nomi di servizio, ti assicuri che Kubernetes possa indirizzare le richieste ai moduli corretti quando l'app viene eseguita in un cluster.

Riepilogo

In questo tutorial hai visto come gli URL nel codice modulare sono stati aggiornati per utilizzare i nomi dei servizi Kubernetes, ad esempio http://book-details-service. Questi nomi di servizio consentono a Kubernetes di instradare le richieste tra i moduli anche quando le loro posizioni nel cluster cambiano. Hai anche esaminato il manifest di Kubernetes e hai visto come i nomi dei servizi nel codice modulare corrispondono ai nomi definiti nel manifest.

Passaggi successivi

Nel tutorial successivo, Containerizza l'app modulare, imparerai a containerizzare un modulo pacchettizzandolo in un elemento chiamato immagine container. Poi vedrai come eseguire un'immagine container come container, testarne le funzionalità ed eseguire il push dell'immagine container in Google Artifact Registry.

Percorso di apprendimento: trasforma un monolite in un'app GKE - Prepara l'app modulare per la containerizzazione Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.