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

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 comprendi alcuni di questi termini. Man mano che avanzi nella serie, imparerai il loro significato.

Il percorso di apprendimento è costituito dai seguenti tutorial:

  1. Panoramica
  2. Comprendere il monolite (questo tutorial)
  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

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

  1. Configurazione dell'app sulla macchina locale.
  2. Esplorando le sue funzionalità nel browser.
  3. Sto esaminando il codice.

Che cos'è un monolite?

Prima di preparare ed eseguire il monolite di esempio di Cymbal Books, è importante capire innanzitutto 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 sue esigenze di risorse. Se ospiti l'app modulare su un cluster GKE, GKE può persino automatizzare la scalabilità per te.

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 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

Questo tutorial richiede Python versione 3.13 sulla tua macchina locale. Per controllare la versione di Python installata sul tuo computer, 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.

Configura l'ambiente

In questa serie di tutorial, esegui diverse versioni dell'applicazione in posizioni diverse:

  • La versione monolitica sulla tua macchina locale
  • La versione modulare sulla tua 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 concentri esclusivamente sui file nella cartella monolith/.

Crea e attiva un ambiente virtuale

Un ambiente virtuale fornisce uno spazio isolato per eseguire l'app. Impedisce che le librerie Python che devi installare per l'app interferiscano 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 sul tuo computer:

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

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

    python3 -m venv book-review-env

    Creare un ambiente virtuale è una buona idea perché è un'area in cui puoi eseguire l'app in isolamento. In questo modo, le dipendenze e le configurazioni dell'app non entrano in conflitto con altri software o librerie del 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

Esegui ed esplora Cymbal Books nel browser

L'app Cymbal Books è intenzionalmente semplice e presenta 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, se premuto, mostra le recensioni del libro.
  • La possibilità di visualizzare le immagini delle copertine dei libri.

La home page mostra tre libri e per ognuno è presente un pulsante Visualizza dettagli:

Home page dell'app di recensioni di libri

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

  1. Sulla tua macchina locale, vai alla directory monolith:

    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, ad esempio l'autore e l'anno di pubblicazione.

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

    Un diagramma che mostra i dettagli e le recensioni di un libro

Esplora i file nella cartella /monolith

Dedica un momento a esaminare 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 principali 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 nella raccolta di Cymbal Books e dettagli su ciascun 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 in file JSON ne semplifica l'implementazione. L'app di esempio Cymbal Book utilizza file JSON in modo da non dover gestire codice complesso. Invece, puoi 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 al loro interno 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 di 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 condizioni di carico elevato. Inoltre, un'applicazione Flask non dispone di funzionalità robuste di gestione degli errori e scalabilità.

L'app Cymbal Books utilizza Flask perché la sua semplicità e la configurazione minima rendono più facile comprendere i 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.

Esamina 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 web server, 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 in modo programmatico, Flask esegue il codice corrispondente per gestire la richiesta.

Lo screenshot seguente mostra il file mono.py. I riquadri evidenziano i gestori di intent dell'app. Mentre un gestore serve la home page visibile all'utente, gli altri vengono utilizzati principalmente per la comunicazione tra moduli, fornendo dati in formato JSON o file di immagini statiche. Ulteriori dettagli su questi endpoint sono forniti nelle sezioni successive.

Un diagramma che mostra i riquadri intorno ai vari gestori di route nel codice monolitico

Nello screenshot, i riquadri evidenziano i gestori di route dell'app. Un gestore di route è costituito 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 di 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 mostra quindi queste recensioni in un formato leggibile sulla pagina web. Il monolite 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, ad esempio la visualizzazione di pagine o il recupero di dati. Ogni funzionalità è associata a un endpoint specifico.
  • Modularizzazione: gli endpoint fungono da confini naturali o linee di faglia per dividere l'app in moduli più piccoli. Come vedrai nel tutorial successivo, ogni modulo della 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. Comprendere come vengono implementati gli endpoint in mono.py pone le basi per la modularizzazione dell'app Cymbal Books in moduli indipendenti nel tutorial successivo.

Testa i gestori di route del monolite

Per vedere il tipo di dati restituito 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 di 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 relativi a un libro dal server e li presenta in un 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 per le recensioni di 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 per Meccanica melodica.
  • 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 dei libri chiamano questo endpoint per visualizzare le immagini di copertina dei libri.

Riepilogo

In questo tutorial hai configurato ed eseguito l'app monolitica Cymbal Books. Poi hai scoperto che il monolite è implementato come applicazione Flask, che è in ascolto di 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.