Percorso di apprendimento: trasforma un monolite in un'app GKE - Comprendi il monolite

Standard

Ti diamo il benvenuto al primo tutorial di una serie che mostra come prendere un monolite (o un'app monolitica), separarlo in moduli, containerizzare i moduli ed eseguire il deployment delle immagini container in un cluster Google Kubernetes Engine (GKE). Non preoccuparti se non capisci alcuni di questi termini. Imparerai il loro significato man mano che avanzi nella serie.

Il percorso di apprendimento è composto dai seguenti tutorial:

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

In questo tutorial, imparerai a conoscere il monolite eseguendo i seguenti passaggi:

1. Configurare l'app sulla macchina locale.
2. Esplorare le sue funzionalità nel browser.
3. Esaminare il codice.

Che cos'è un monolite?

Prima di configurare ed eseguire il monolite di esempio di Cymbal Books, è importante capire cos'è un monolite.

Un monolite è un'app in cui tutti i componenti sono interconnessi e non possono essere scalati in modo indipendente. Ad esempio, se un numero di utenti visita improvvisamente la pagina di accesso dell'app, non puoi scalare solo il componente di accesso in modo indipendente. Devi invece scalare l'intera applicazione, inclusi i componenti non correlati, come il catalogo dei prodotti o il sistema di elaborazione degli ordini.

Al contrario, quando un'applicazione viene suddivisa in moduli indipendenti, ogni modulo può essere scalato separatamente in base alle proprie esigenze di risorse. Se ospiti l'app modulare su un cluster GKE, GKE può persino automatizzare la scalabilità.

Il termine monolitico non significa codice mal organizzato. Un monolite può essere ben strutturato e i suoi componenti possono essere implementati in aree distinte del codice. Ciò che distingue un monolite è che questi componenti non possono essere eseguiti o scalati in modo indipendente.

Costi

Puoi completare questo tutorial senza incorrere in addebiti. Tuttavia, se segui i passaggi del tutorial finale di questa serie, ti verranno addebitati costi sul tuo Google Cloud account. 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 indicato nella pagina dei prezzi, e gli addebiti per l'esecuzione delle VM Compute Engine.

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

Prima di iniziare

Questo tutorial richiede Python versione 3.13 sulla tua macchina locale. Per verificare la versione di Python sulla tua macchina, esegui questo comando:

python3 --version

Se la tua versione di Python è precedente alla 3.13, scarica e installa l'ultima versione dal sito web ufficiale di Python.

Configurare l'ambiente

In questa serie di tutorial, eseguirai versioni diverse dell'applicazione in luoghi diversi:

• La versione monolitica sulla macchina locale
• La versione modulare sulla macchina locale
• La versione containerizzata in Cloud Shell e poi in un cluster GKE

In questa sezione, configurerai un ambiente virtuale sulla tua macchina locale in cui può essere eseguito il monolite.

Scarica il codice

1. Apri un terminale sulla tua macchina locale.

2. Clona il repository GitHub del tutorial sulla tua macchina locale:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
   

   La cartellakubernetes-engine-samples/quickstarts/monolith-to-microservices contiene le seguenti tre cartelle: monolith/, modular/ e containerized/. In questo tutorial, ti concentrerai esclusivamente sui file nella cartella monolith/.

Creare e attivare un ambiente virtuale

Un ambiente virtuale fornisce uno spazio isolato per eseguire l'app. Impedisce alle librerie Python che devi installare per l'app di interferire con altri progetti Python sul tuo sistema.

Per creare e attivare un ambiente virtuale:

1. Nel terminale aperto nella sezione precedente, vai alla seguente cartella nel repository clonato in precedenza sulla macchina:

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

2. Crea un ambiente virtuale denominato book-review-env:

   python3 -m venv book-review-env
   

   La creazione di un ambiente virtuale è una buona idea perché è un'area in cui puoi eseguire l'app in modo isolato. In questo modo, le dipendenze e le configurazioni dell'app non entrano in conflitto con altri software o librerie sul tuo sistema.

3. Attiva l'ambiente virtuale utilizzando il comando per il tuo sistema operativo:

   macOS e Linux

   source book-review-env/bin/activate
   

   Windows

   book-review-env\Scripts\activate
   

4. Installa le dipendenze Python per il monolite. Le dipendenze sono librerie Python esterne su cui si basa l'app per funzionare correttamente. Queste librerie sono elencate nel file requirements.txt e il seguente comando le installa tutte nell'ambiente virtuale:

   pip install -r monolith/requirements.txt
   

Eseguire ed esplorare Cymbal Books nel browser

L'app Cymbal Books è intenzionalmente semplice e ha le seguenti funzionalità:

• Una home page che mostra tutti i libri della raccolta.
• Una pagina che mostra i dettagli di un libro.
• Un pulsante nella pagina dei dettagli che, quando viene selezionato, mostra le recensioni dei libri.
• La possibilità di visualizzare le immagini delle copertine dei libri.

La home page mostra tre libri e un pulsante Visualizza dettagli con ciascuno:

Ora che l'ambiente virtuale è attivo e le dipendenze dell'app sono installate in questo ambiente, esegui l'app seguendo questi passaggi:

1. Sulla macchina locale, vai alla directory del monolite:

   cd monolith/
   

2. Avvia l'app:

   python3 mono.py
   

3. Apri il browser web e vai alla home page dell'app: http://127.0.0.1:8080.

4. Per andare alla pagina dei dettagli di un libro, fai clic su Visualizza dettagli. La pagina dei dettagli fornisce ulteriori informazioni su un libro, come l'autore e l'anno di pubblicazione.

5. Per visualizzare un elenco di recensioni per il libro, fai clic su Mostra recensioni in una pagina dei dettagli. L'immagine seguente mostra la pagina dei dettagli del libro per il libro Zephyr's Timepiece e la prima recensione del libro:

   

Esplorare i file nella cartella /monolith

Esamina i file nella cartella /monolith:

monolith/
├── mono.py
├── data/
│   ├── book-1.json
│   ├── book-2.json
│   ├── book-3.json
│   ├── reviews-1.json
│   ├── reviews-2.json
│   └── reviews-3.json
├── images/
│   ├── fungi_frontier.jpg
│   ├── melodic_mechanics.jpg
│   └── zephyrs_timepiece.jpg
├── static/
│   ├── styles_for_details.css
│   └── styles_for_home.css
└── templates/
    ├── book_details.html
    └── home.html

Le cartelle e i file chiave sono i seguenti:

• La cartella images/ contiene le seguenti immagini di copertine di libri, che vengono visualizzate nell'app:

  • fungi_frontier.jpg
  • melodic_mechanics.jpg
  • zephyrs_timepiece.jpg

• La cartella data/ contiene i seguenti file JSON. Questi file contengono recensioni dei tre libri della raccolta Cymbal Books e dettagli su ogni libro:

  • reviews-1.json, reviews-2.json, reviews-3.json
  • book-1.json, book-2.json, book-3.json

Sebbene le app reali utilizzino spesso i database, l'archiviazione dei dati dell'app nei file JSON ne semplifica l'implementazione. L'app di esempio Cymbal Book utilizza i file JSON in modo da non dover gestire codice complesso. Puoi invece concentrarti sull'obiettivo principale di questa serie di tutorial, ovvero imparare a modularizzare e containerizzare il monolite.

Puoi ignorare le seguenti cartelle perché i file in esse contenuti sono importanti per il layout e il design dell'app, ma non sono direttamente pertinenti alla logica dell'app:

• static/: contiene i file CSS che definiscono lo stile dell'app.
• templates/: contiene i file HTML che definiscono il layout e i contenuti dell'app.

Comprendere il monolite come applicazione Flask

Il monolite in questo tutorial è creato utilizzando Flask, una libreria Python per la creazione di applicazioni web. Tuttavia, Flask non viene in genere utilizzato negli ambienti di produzione perché non supporta la concorrenza, il che può portare a colli di bottiglia delle prestazioni in caso di carico elevato. Un'applicazione Flask manca anche di funzionalità di gestione degli errori e scalabilità robuste.

L'app Cymbal Books utilizza Flask perché la sua semplicità e la configurazione minima semplificano la comprensione dei concetti di modularizzazione e containerizzazione. Per le applicazioni di livello di produzione che utilizzano Python, valuta alternative a Flask come FastAPI o Django. Puoi anche utilizzare framework personalizzati per altri linguaggi, come Spring Boot per Java o Express.js per Node.js. Questi framework possono offrire una migliore concorrenza, scalabilità e funzionalità pronte per la produzione per soddisfare le esigenze delle applicazioni reali.

Esaminare mono.py

Tutta la logica del monolite è contenuta in un unico file denominato mono.py. Questo file crea un'applicazione Flask. Un'applicazione Flask viene eseguita all'interno di un server web, ascolta URL specifici, chiamati endpoint, e risponde alle richieste effettuate a questi URL. Quando qualcuno richiede uno di questi URL, visitandolo in un browser web o effettuando la richiesta a livello di programmazione, Flask esegue la parte di codice corrispondente per gestire la richiesta.

La seguente schermata mostra il file mono.py. Le caselle evidenziano i gestori di route dell'app. Mentre un gestore gestisce la home page rivolta all'utente, gli altri vengono utilizzati principalmente per la comunicazione tra moduli, fornendo dati in formato JSON o file di immagini statiche. Maggiori dettagli su questi endpoint sono forniti nelle sezioni successive.

Nella schermata, le caselle evidenziano i gestori di route dell'app. Un gestore di route è composto da due parti:

• La riga @app.route() che definisce un pattern URL (ad esempio /book/<id>/reviews).
• La funzione che viene eseguita quando viene chiamato l'endpoint.

Un endpoint è un URL che corrisponde al pattern definito nella riga @app.route().

Ad esempio, quando un utente fa clic su Mostra recensioni nella pagina dei dettagli di un libro, l'app invia una richiesta a http://localhost:8080/book/1/reviews. Il gestore di route delle recensioni dei libri risponde a questa richiesta eseguendo i seguenti passaggi:

1. Riconosce che questo URL corrisponde al pattern /book/<id>/reviews.
2. Recupera le recensioni del libro 1 da un file JSON.
3. Invia queste recensioni al frontend in formato JSON.

Il componente dei dettagli del libro visualizza quindi queste recensioni in formato leggibile sulla pagina web. Il monolite di Cymbal Books utilizza una libreria Python chiamata Flask per semplificare l'implementazione dei gestori di route. Nel tutorial successivo, vedrai che Flask e i gestori di route svolgono un ruolo fondamentale quando impari come il monolite viene convertito in un'app modulare.

Perché gli endpoint del monolite sono importanti per la modularizzazione

Gli endpoint svolgono un ruolo fondamentale nelle applicazioni Flask, inclusa l'app Cymbal Books. Tuttavia, la loro importanza va oltre la progettazione monolitica, perché la comprensione degli endpoint è essenziale per suddividere l'app in moduli indipendenti. Ecco perché:

• Funzionalità di base: gli endpoint implementano le funzionalità principali dell'app, come la visualizzazione delle pagine o il recupero dei dati. Ogni funzionalità è associata a un endpoint specifico.
• Modularizzazione: gli endpoint fungono da limiti naturali, o linee di faglia, per dividere l'app in moduli più piccoli. Come vedrai nel tutorial successivo, ogni modulo nella versione modulare dell'app corrisponde a una funzionalità con i propri endpoint.
• Comunicazione: in una progettazione modulare, gli endpoint consentono ai moduli autonomi di comunicare tra loro. La comprensione di come vengono implementati gli endpoint in mono.py pone le basi per la modularizzazione dell'app Cymbal Books in moduli indipendenti nel tutorial successivo.

Testare i gestori di route del monolite

Per vedere il tipo di dati restituiti da ogni gestore di route, visita i seguenti endpoint nel browser:

• Gestore di route della home page: visita http://localhost:8080/ per visualizzare una pagina HTML completa che mostra il catalogo dei libri.
• Gestore di route dei dettagli del libro: visita http://localhost:8080/book/1 per visualizzare una pagina HTML che mostra i dettagli di un libro specifico. La pagina recupera i dati JSON di un libro dal server e li presenta in formato leggibile utilizzando un modello HTML. Prova a visualizzare i dettagli di altri libri modificando il numero ID (1, 2 o 3) nell'URL.
• Gestore di route delle recensioni dei libri: visita http://localhost:8080/book/3/reviews per visualizzare i dati JSON delle recensioni del libro. Questi dati vengono elaborati in un formato leggibile quando fai clic su Show Reviews nella pagina dei dettagli del libro Melodic Mechanics.
• Gestore di route delle immagini: visita http://localhost:8080/images/fungi_frontier.jpg per visualizzare un file immagine. La home page e le pagine dei dettagli del libro chiamano questo endpoint per visualizzare le immagini di copertine dei libri.

Riepilogo

In questo tutorial, hai configurato ed eseguito l'app monolitica Cymbal Books. Hai quindi appreso che il monolite viene implementato come applicazione Flask, che ascolta URL specifici, chiamati endpoint, e risponde alle richieste effettuate a questi URL.

Passaggi successivi

Nel tutorial successivo, Modularizzare il monolite, vedrai come suddividere il monolite in moduli indipendenti.