Lernpfad: Monolith in eine GKE-Anwendung umwandeln – Monolith verstehen

Willkommen zum ersten Teil einer Reihe von Anleitungen, in denen Sie erfahren, wie Sie einen Monolithen (oder eine monolithische App) in Module aufteilen, die Module in Containern verpacken und die Container-Images in einem Google Kubernetes Engine-Cluster (GKE) bereitstellen. Keine Sorge, wenn Sie einige dieser Begriffe nicht verstehen. Im Laufe der Serie erfahren Sie, was sie bedeuten.

Der Lernpfad besteht aus den folgenden Anleitungen:

1. Übersicht
2. Monolith verstehen (diese Anleitung)
3. Monolith modularisieren
4. Modulare App für die Containerisierung vorbereiten
5. Modulare App containerisieren
6. Anwendung in einem GKE-Cluster bereitstellen

In dieser Anleitung lernen Sie den Monolithen kennen, indem Sie die folgenden Schritte ausführen:

1. Einrichten der App auf Ihrem lokalen Computer
2. Sie können die Funktionen im Browser ausprobieren.
3. Code prüfen

Was ist ein Monolith?

Bevor Sie den Beispielmonolithen von Cymbal Books zum Laufen bringen, ist es wichtig, erst einmal zu verstehen, was ein Monolith ist.

Ein Monolith ist eine App, in der alle Komponenten miteinander verbunden sind und nicht unabhängig skaliert werden können. Wenn beispielsweise eine Reihe von Nutzern plötzlich die Anmeldeseite der App aufruft, können Sie nicht nur die Anmeldekomponente unabhängig skalieren. Stattdessen müssen Sie die gesamte Anwendung skalieren, einschließlich nicht verwandter Komponenten wie dem Produktkatalog oder dem Auftragsbearbeitungssystem.

Wenn eine Anwendung in unabhängige Module unterteilt ist, kann jedes Modul dagegen separat auf Grundlage seines Ressourcenbedarfs skaliert werden. Wenn Sie die modulare App in einem GKE-Cluster hosten, kann GKE die Skalierung sogar für Sie automatisieren.

Der Begriff monolithisch bedeutet nicht, dass der Code schlecht organisiert ist. Ein Monolith kann gut strukturiert sein und seine Komponenten können in verschiedenen Bereichen des Codes implementiert werden. Das Besondere an einem Monolithen ist, dass diese Komponenten nicht unabhängig voneinander ausgeführt oder skaliert werden können.

Kosten

Für diese Anleitung fallen keine Kosten an. Wenn Sie jedoch die Schritte in der letzten Anleitung dieser Reihe ausführen, fallen Kosten für IhrGoogle Cloud -Konto an. Die Kosten fallen an, sobald Sie GKE aktivieren und die Cymbal Books-App in einem GKE-Cluster bereitstellen. Diese Kosten umfassen Clustergebühren für GKE, wie auf der Preisseite beschrieben, sowie Gebühren für die Ausführung von Compute Engine-VMs.

Um unnötige Gebühren zu vermeiden, sollten Sie GKE deaktivieren oder das Projekt löschen, sobald Sie diese Anleitung abgeschlossen haben.

Hinweise

Für diese Anleitung ist Python 3.13 auf Ihrem lokalen Computer erforderlich. Führen Sie den folgenden Befehl aus, um zu prüfen, welche Version von Python auf Ihrem Computer installiert ist:

python3 --version

Wenn Ihre Python-Version älter als 3.13 ist, laden Sie die aktuelle Version von der offiziellen Python-Website herunter und installieren Sie sie.

Umgebung einrichten

In dieser Anleitungsserie führen Sie verschiedene Versionen der Anwendung an verschiedenen Orten aus:

• Die monolithische Version auf Ihrem lokalen Computer
• Die modulare Version auf Ihrem lokalen Computer
• Die containerisierte Version in Cloud Shell und dann in einem GKE-Cluster

In diesem Abschnitt richten Sie eine virtuelle Umgebung auf Ihrem lokalen Computer ein, in der der Monolith ausgeführt werden kann.

Code herunterladen

1. Öffnen Sie ein Terminal auf Ihrem lokalen Computer.

2. Klonen Sie das GitHub-Repository der Anleitung auf Ihren lokalen Computer:

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

   Der Ordnerkubernetes-engine-samples/quickstarts/monolith-to-microservicesenthält die folgenden drei Ordner: monolith/, modular/ und containerized/. In dieser Anleitung konzentrieren Sie sich ausschließlich auf die Dateien im Ordner monolith/.

Virtuelle Umgebung erstellen und aktivieren

Eine virtuelle Umgebung bietet einen isolierten Bereich zum Ausführen der App. Dadurch wird verhindert, dass die Python-Bibliotheken, die Sie für die App installieren müssen, andere Python-Projekte auf Ihrem System beeinträchtigen.

So erstellen und aktivieren Sie eine virtuelle Umgebung:

1. Wechseln Sie im Terminal, das Sie im vorherigen Abschnitt geöffnet haben, zum folgenden Ordner im Repository, das Sie zuvor auf Ihren Computer geklont haben:

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

2. Erstellen Sie eine virtuelle Umgebung mit dem Namen book-review-env:

   python3 -m venv book-review-env
   

   Das Erstellen einer virtuellen Umgebung ist eine gute Idee, da Sie die App dort isoliert ausführen können. So wird sichergestellt, dass die Abhängigkeiten und Konfigurationen der App nicht mit anderer Software oder Bibliotheken auf Ihrem System in Konflikt geraten.

3. Aktivieren Sie die virtuelle Umgebung mit dem Befehl für Ihr Betriebssystem:

   macOS und Linux

   source book-review-env/bin/activate
   

   Windows

   book-review-env\Scripts\activate
   

4. Installieren Sie die Python-Abhängigkeiten für den Monolithen. Abhängigkeiten sind externe Python-Bibliotheken, auf die die App angewiesen ist, um ordnungsgemäß zu funktionieren. Diese Bibliotheken sind in der Datei requirements.txt aufgeführt. Mit dem folgenden Befehl werden alle in Ihrer virtuellen Umgebung installiert:

   pip install -r monolith/requirements.txt
   

Cymbal Books im Browser ausführen und ansehen

Die Cymbal Books App ist bewusst einfach gehalten und bietet die folgenden Funktionen:

• Eine Startseite, auf der alle Bücher in der Mediathek angezeigt werden.
• Eine Seite mit Details zu einem Buch.
• Eine Schaltfläche auf der Detailseite, über die Buchrezensionen angezeigt werden.
• Bilder von Buchcovern anzeigen

Auf der Startseite werden drei Bücher angezeigt. Bei jedem Buch ist die Schaltfläche „Details ansehen“ zu sehen:

Nachdem die virtuelle Umgebung aktiviert und die Abhängigkeiten der App in dieser Umgebung installiert wurden, führen Sie die App mit den folgenden Schritten aus:

1. Wechseln Sie auf Ihrem lokalen Computer zum Monolith-Verzeichnis:

   cd monolith/
   

2. App starten:

   python3 mono.py
   

3. Öffnen Sie Ihren Webbrowser und rufen Sie die Startseite der App auf: http://127.0.0.1:8080.

4. Klicken Sie auf Details ansehen, um zur Detailseite eines Buchs zu gelangen. Auf der Detailseite finden Sie weitere Informationen zu einem Buch, z. B. den Autor und das Erscheinungsjahr.

5. Wenn Sie eine Liste der Rezensionen für das Buch auf einer Detailseite aufrufen möchten, klicken Sie auf Rezensionen anzeigen. Die folgende Abbildung zeigt die Buchdetailseite für das Buch Zephyr's Timepiece und die erste Rezension:

   

Dateien im Ordner /monolith ansehen

Sehen Sie sich die Dateien im Ordner /monolith an:

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

Die wichtigsten Ordner und Dateien sind:

• Der Ordner images/ enthält die folgenden Buchcoverbilder, die in der App angezeigt werden:

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

• Der Ordner data/ enthält die folgenden JSON-Dateien. Diese Dateien enthalten Rezensionen der drei Bücher in der Cymbal Books-Bibliothek sowie Details zu den einzelnen Büchern:

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

In der Praxis werden für Apps häufig Datenbanken verwendet. Die Speicherung der App-Daten in JSON-Dateien vereinfacht jedoch die Implementierung. In der Beispiel-App „Cymbal Book“ werden JSON-Dateien verwendet, damit Sie keinen komplexen Code verarbeiten müssen. Stattdessen können Sie sich auf das Hauptziel dieser Tutorialreihe konzentrieren: das Modularisieren und Containerisieren des Monolithen.

Die folgenden Ordner können Sie ignorieren, da die Dateien darin zwar für das Layout und Design der App wichtig sind, aber nicht direkt mit der Logik der App zusammenhängen:

• static/: Enthält CSS-Dateien, die den Stil der App definieren.
• templates/: Enthält HTML-Dateien, die das Layout und die Inhalte der App definieren.

Monolith als Flask-Anwendung verstehen

Der Monolith in diesem Tutorial wurde mit Flask erstellt, einer Python-Bibliothek zum Erstellen von Webanwendungen. Flask wird jedoch in der Regel nicht in Produktionsumgebungen verwendet, da es keine Parallelität unterstützt, was bei hoher Last zu Leistungsengpässen führen kann. Einer Flask-Anwendung fehlen außerdem robuste Funktionen für die Fehlerbehandlung und Skalierbarkeit.

Die Cymbal Books App verwendet Flask, da die Einfachheit und die minimale Einrichtung es einfacher machen, die Konzepte der Modularisierung und Containerisierung zu verstehen. Für Produktionsanwendungen, die Python verwenden, sollten Sie Alternativen zu Flask wie FastAPI oder Django in Betracht ziehen. Sie können auch Frameworks verwenden, die auf andere Sprachen zugeschnitten sind, z. B. Spring Boot für Java oder Express.js für Node.js. Diese Frameworks bieten möglicherweise eine bessere Parallelität, Skalierbarkeit und produktionsreife Funktionen, um den Anforderungen von Anwendungen in der Praxis gerecht zu werden.

mono.py untersuchen

Die gesamte Logik des Monolithen ist in einer einzigen Datei mit dem Namen mono.py enthalten. In dieser Datei wird eine Flask-Anwendung erstellt. Eine Flask-Anwendung wird auf einem Webserver ausgeführt, überwacht bestimmte URLs (Endpunkte) und reagiert auf Anfragen, die an diese URLs gesendet werden. Wenn jemand eine dieser URLs anfordert – entweder durch Aufrufen in einem Webbrowser oder durch programmgesteuertes Senden der Anfrage –, führt Flask den entsprechenden Code aus, um die Anfrage zu verarbeiten.

Der folgende Screenshot zeigt die mono.py-Datei. Die Kästchen heben die Routen-Handler der App hervor. Während ein Handler die für Nutzer sichtbare Startseite bereitstellt, werden die anderen hauptsächlich für die Kommunikation zwischen Modulen verwendet, um Daten im JSON-Format oder statische Bilddateien zu übertragen. Weitere Informationen zu diesen Endpunkten finden Sie in den nächsten Abschnitten.

Im Screenshot sind die Routen-Handler der App in Kästen hervorgehoben. Ein Routen-Handler besteht aus zwei Teilen:

• Die @app.route()-Zeile, in der ein URL-Muster definiert wird (z. B. /book/<id>/reviews).
• Die Funktion, die ausgeführt wird, wenn der Endpunkt aufgerufen wird.

Ein Endpunkt ist eine URL, die dem Muster in der Zeile @app.route() entspricht.

Wenn ein Nutzer beispielsweise auf der Detailseite eines Buchs auf Rezensionen anzeigen klickt, sendet die App eine Anfrage an http://localhost:8080/book/1/reviews. Der Routen-Handler für Buchrezensionen reagiert auf diese Anfrage, indem er die folgenden Schritte ausführt:

1. Die URL entspricht dem Muster /book/<id>/reviews.
2. Ruft die Rezensionen für Buch 1 aus einer JSON-Datei ab.
3. Die Rezensionen werden im JSON-Format an das Frontend zurückgesendet.

In der Komponente „Buchdetails“ werden diese Rezensionen dann in einer für Menschen lesbaren Form auf der Webseite angezeigt. Im Cymbal Books-Monolith wird eine Python-Bibliothek namens Flask verwendet, um die Implementierung von Routenhandlern zu vereinfachen. Im nächsten Tutorial sehen Sie, dass Flask und die Routenhandler eine entscheidende Rolle spielen, wenn Sie lernen, wie der Monolith in eine modulare App umgewandelt wird.

Warum die Endpunkte des Monolithen für die Modularisierung wichtig sind

Endpunkte spielen eine wichtige Rolle in Flask-Anwendungen, einschließlich der Cymbal Books-App. Ihre Bedeutung geht jedoch über das monolithische Design hinaus, da das Verständnis von Endpunkten unerlässlich ist, um die App in unabhängige Module aufzuteilen. Das kann folgende Gründe haben:

• Hauptfunktionen: Endpunkte implementieren die Hauptfunktionen der App, z. B. das Anzeigen von Seiten oder das Abrufen von Daten. Jede Funktion ist an einen bestimmten Endpunkt gebunden.
• Modularisierung: Endpunkte dienen als natürliche Grenzen oder Sollbruchstellen, um die App in kleinere Module zu unterteilen. Wie Sie im nächsten Tutorial sehen werden, entspricht jedes Modul in der modularen Version der App einer Funktion mit eigenen Endpunkten.
• Kommunikation: In einem modularen Design ermöglichen Endpunkte die Kommunikation zwischen autonomen Modulen. Wenn Sie wissen, wie Endpunkte in mono.py implementiert werden, können Sie die Cymbal Books-App im nächsten Tutorial in unabhängige Module unterteilen.

Routenhandler des Monolithen testen

Um zu sehen, welche Art von Daten die einzelnen Routenhandler zurückgeben, rufen Sie die folgenden Endpunkte in Ihrem Browser auf:

• Homepage-Routenhandler: Unter http://localhost:8080/ finden Sie eine vollständige HTML-Seite, auf der der Buchkatalog angezeigt wird.
• Routen-Handler für Buchdetails: Rufen Sie http://localhost:8080/book/1 auf, um eine HTML-Seite mit Details zu einem bestimmten Buch aufzurufen. Auf der Seite werden JSON-Daten zu einem Buch vom Server abgerufen und mithilfe einer HTML-Vorlage in menschenlesbarer Form dargestellt. Wenn Sie sich die Details zu anderen Büchern ansehen möchten, ändern Sie die ID-Nummer (1, 2 oder 3) in der URL.
• Routen-Handler für Buchrezensionen: Rufen Sie http://localhost:8080/book/3/reviews auf, um JSON-Daten der Buchrezensionen zu sehen. Diese Daten werden in ein lesbares Format umgewandelt, wenn Sie auf der Buchdetailseite für Melodic Mechanics auf Show Reviews klicken.
• Bildrouten-Handler: Rufen Sie http://localhost:8080/images/fungi_frontier.jpg auf, um eine Bilddatei aufzurufen. Auf der Startseite und den Buchdetailseiten wird dieser Endpunkt aufgerufen, um die Titelbilder für Bücher anzuzeigen.

Zusammenfassung

In dieser Anleitung haben Sie die monolithische Cymbal Books-App eingerichtet und ausgeführt. Sie haben dann erfahren, dass der Monolith als Flask-Anwendung implementiert ist, die auf bestimmte URLs (Endpunkte) wartet und auf Anfragen reagiert, die an diese URLs gesendet werden.

Nächste Schritte

Im nächsten Tutorial Monolith modularisieren erfahren Sie, wie Sie den Monolith in unabhängige Module aufteilen.