GSP662

Übersicht

Es gibt viele Möglichkeiten, Websites in Google Cloud bereitzustellen. Jede Lösung hat andere Funktionen und Kontrollebenen. Die Compute Engine bietet eine tiefgreifende Kontrolle über die Infrastruktur, mit der eine Website ausgeführt wird, erfordert aber etwas mehr operatives Management im Vergleich zu Lösungen wie z. B. der Google Kubernetes Engine (GKE) und der App Engine. Mit der Compute Engine haben Sie detailgenaue Kontrolle über die Infrastruktur, einschließlich virtueller Maschinen und Load Balancer.

In diesem Lab stellen Sie eine Beispielanwendung bereit (die E-Commerce-Website „Fancy Store“) und erfahren, wie eine Website mit der Compute Engine ganz unkompliziert bereitgestellt und skaliert werden kann.

Lerninhalte

Aufgaben in diesem Lab:

• Compute Engine-Instanzen erstellen
• Instanzvorlagen aus Quellinstanzen erstellen
• Verwaltete Instanzgruppen erstellen
• Systemdiagnosen für verwaltete Instanzgruppen erstellen und testen
• HTTP(S) Load Balancer erstellen
• Systemdiagnosen für Load Balancer erstellen
• Content Delivery Network (CDN) für das Caching verwenden

Am Ende des Labs haben Sie Instanzen in verwalteten Instanzgruppen für die automatische Reparatur, Load Balancing, Autoscaling und Rolling Updates für Ihre Website.

Einrichtung und Anforderungen

Vor dem Klick auf „Start Lab“ (Lab starten)

Lesen Sie diese Anleitung. Labs sind zeitlich begrenzt und können nicht pausiert werden. Der Timer beginnt zu laufen, wenn Sie auf Lab starten klicken, und zeigt Ihnen, wie lange Google Cloud-Ressourcen für das Lab verfügbar sind.

In diesem praxisorientierten Lab können Sie die Lab-Aktivitäten in einer echten Cloud-Umgebung durchführen – nicht in einer Simulations- oder Demo-Umgebung. Dazu erhalten Sie neue, temporäre Anmeldedaten, mit denen Sie für die Dauer des Labs auf Google Cloud zugreifen können.

Für dieses Lab benötigen Sie Folgendes:

• Einen Standardbrowser (empfohlen wird Chrome)

Hinweis: Nutzen Sie den privaten oder Inkognitomodus (empfohlen), um dieses Lab durchzuführen. So wird verhindert, dass es zu Konflikten zwischen Ihrem persönlichen Konto und dem Teilnehmerkonto kommt und zusätzliche Gebühren für Ihr persönliches Konto erhoben werden.

• Zeit für die Durchführung des Labs – denken Sie daran, dass Sie ein begonnenes Lab nicht unterbrechen können.

Hinweis: Verwenden Sie für dieses Lab nur das Teilnehmerkonto. Wenn Sie ein anderes Google Cloud-Konto verwenden, fallen dafür möglicherweise Kosten an.

Lab starten und bei der Google Cloud Console anmelden

1. Klicken Sie auf Lab starten. Wenn Sie für das Lab bezahlen müssen, wird ein Dialogfeld geöffnet, in dem Sie Ihre Zahlungsmethode auswählen können. Auf der linken Seite befindet sich der Bereich „Details zum Lab“ mit diesen Informationen:

   • Schaltfläche „Google Cloud Console öffnen“
   • Restzeit
   • Temporäre Anmeldedaten für das Lab
   • Ggf. weitere Informationen für dieses Lab

2. Klicken Sie auf Google Cloud Console öffnen (oder klicken Sie mit der rechten Maustaste und wählen Sie Link in Inkognitofenster öffnen aus, wenn Sie Chrome verwenden).

   Im Lab werden Ressourcen aktiviert. Anschließend wird ein weiterer Tab mit der Seite „Anmelden“ geöffnet.

   Tipp: Ordnen Sie die Tabs nebeneinander in separaten Fenstern an.

   Hinweis: Wird das Dialogfeld Konto auswählen angezeigt, klicken Sie auf Anderes Konto verwenden.

3. Kopieren Sie bei Bedarf den folgenden Nutzernamen und fügen Sie ihn in das Dialogfeld Anmelden ein.

   {{{user_0.username | "Username"}}}

   Sie finden den Nutzernamen auch im Bereich „Details zum Lab“.

4. Klicken Sie auf Weiter.

5. Kopieren Sie das folgende Passwort und fügen Sie es in das Dialogfeld Willkommen ein.

   {{{user_0.password | "Password"}}}

   Sie finden das Passwort auch im Bereich „Details zum Lab“.

6. Klicken Sie auf Weiter.

   Wichtig: Sie müssen die für das Lab bereitgestellten Anmeldedaten verwenden. Nutzen Sie nicht die Anmeldedaten Ihres Google Cloud-Kontos. Hinweis: Wenn Sie Ihr eigenes Google Cloud-Konto für dieses Lab nutzen, können zusätzliche Kosten anfallen.

7. Klicken Sie sich durch die nachfolgenden Seiten:

   • Akzeptieren Sie die Nutzungsbedingungen.
   • Fügen Sie keine Wiederherstellungsoptionen oder Zwei-Faktor-Authentifizierung hinzu (da dies nur ein temporäres Konto ist).
   • Melden Sie sich nicht für kostenlose Testversionen an.

Nach wenigen Augenblicken wird die Google Cloud Console in diesem Tab geöffnet.

Hinweis: Wenn Sie auf Google Cloud-Produkte und ‑Dienste zugreifen möchten, klicken Sie auf das Navigationsmenü oder geben Sie den Namen des Produkts oder Dienstes in das Feld Suchen ein.

Cloud Shell aktivieren

Cloud Shell ist eine virtuelle Maschine, auf der Entwicklertools installiert sind. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft auf Google Cloud. Mit Cloud Shell erhalten Sie Befehlszeilenzugriff auf Ihre Google Cloud-Ressourcen.

1. Klicken Sie oben in der Google Cloud Console auf Cloud Shell aktivieren .

2. Klicken Sie sich durch die folgenden Fenster:

   • Fahren Sie mit dem Informationsfenster zu Cloud Shell fort.
   • Autorisieren Sie Cloud Shell, Ihre Anmeldedaten für Google Cloud API-Aufrufe zu verwenden.

Wenn eine Verbindung besteht, sind Sie bereits authentifiziert und das Projekt ist auf Project_ID, eingestellt. Die Ausgabe enthält eine Zeile, in der die Project_ID für diese Sitzung angegeben ist:

Ihr Cloud-Projekt in dieser Sitzung ist festgelegt als {{{project_0.project_id | "PROJECT_ID"}}}

gcloud ist das Befehlszeilentool für Google Cloud. Das Tool ist in Cloud Shell vorinstalliert und unterstützt die Tab-Vervollständigung.

3. (Optional) Sie können den aktiven Kontonamen mit diesem Befehl auflisten:

gcloud auth list

4. Klicken Sie auf Autorisieren.

Ausgabe:

ACTIVE: * ACCOUNT: {{{user_0.username | "ACCOUNT"}}} Um das aktive Konto festzulegen, führen Sie diesen Befehl aus: $ gcloud config set account `ACCOUNT`

5. (Optional) Sie können die Projekt-ID mit diesem Befehl auflisten:

gcloud config list project

Ausgabe:

[core] project = {{{project_0.project_id | "PROJECT_ID"}}} Hinweis: Die vollständige Dokumentation für gcloud finden Sie in Google Cloud in der Übersicht zur gcloud CLI.

Region und Zone einrichten

Bestimmte Compute Engine-Ressourcen befinden sich in Regionen und Zonen. Eine Region ist ein bestimmter Ort, an dem Sie Ihre Ressourcen ausführen können. Jede Region hat eine oder mehrere Zonen.

Führen Sie die folgenden gcloud-Befehle in Cloud Shell aus, um die Standardregion und ‑zone für Ihr Lab festzulegen:

gcloud config set compute/zone "{{{project_0.default_zone|ZONE}}}" export ZONE=$(gcloud config get compute/zone) gcloud config set compute/region "{{{project_0.default_region|REGION}}}" export REGION=$(gcloud config get compute/region)

Aufgabe 1: Compute Engine API aktivieren

• Führen Sie den folgenden Befehl aus, um die Compute Engine API zu aktivieren:

gcloud services enable compute.googleapis.com

Aufgabe 2: Cloud Storage-Bucket erstellen

Sie speichern den erstellten Code sowie die Startscripts in einem Cloud Storage-Bucket.

• Führen Sie in Cloud Shell den folgenden Befehl aus, um einen neuen Cloud Storage-Bucket zu erstellen:

gsutil mb gs://fancy-store-{{{project_0.project_id | Project ID}}}

Klicken Sie auf Fortschritt prüfen. Cloud Storage-Bucket erstellen

Aufgabe 3: Quell-Repository klonen

In diesem Lab verwenden Sie die bereits bestehende E‑Commerce-Website „Fancy Store“ als Grundlage. Sie basiert auf dem Repository monolith-to-microservices.

In dieser Aufgabe klonen Sie den Quellcode, damit Sie sich auf die Bereitstellung in der Compute Engine konzentrieren können. Später führen Sie eine kleine Aktualisierung an diesem Code durch, um zu sehen, wie einfach das in der Compute Engine ist.

1. Führen Sie die folgenden Befehle aus, um den Quellcode zu klonen und dann zum Verzeichnis monolith-to-microservices zu wechseln:

git clone https://github.com/googlecodelabs/monolith-to-microservices.git cd ~/monolith-to-microservices

2. Führen Sie den ursprünglichen Build des Codes aus, damit die Anwendung lokal ausgeführt werden kann:

./setup.sh

Es dauert einige Minuten, bis das Script ausgeführt ist.

3. Stellen Sie anschließend mithilfe des folgenden Befehls sicher, dass in Cloud Shell eine kompatible Node.js-Version ausgeführt wird:

nvm install --lts

4. Führen Sie dann den folgenden Befehl aus, um die Anwendung zu testen. Dabei wechseln Sie zum Verzeichnis microservices und starten den Webserver:

cd microservices npm start

Sie sollten folgende Ausgabe erhalten.

Ausgabe:

Products microservice listening on port 8082! Frontend microservice listening on port 8080! Orders microservice listening on port 8081!

5. Rufen Sie eine Vorschau für Ihre Anwendung auf. Klicken Sie dazu auf das Webvorschau-Symbol und wählen Sie Vorschau auf Port 8080 aus.

Ein neues Fenster mit dem Frontend von Fancy Store wird geöffnet.

Hinweis: In der Vorschau sollten Sie das Frontend sehen können. Die Funktionen „Products“ und „Orders“ funktionieren jedoch nicht, weil diese Dienste noch nicht freigegeben wurden.

6. Schließen Sie das Fenster, nachdem Sie sich die Website angesehen haben, und drücken Sie im Terminalfenster „Strg + C“, um den Webserverprozess zu beenden.

Gemini Code Assist in der Cloud Shell-IDE aktivieren

Sie können Gemini Code Assist in einer integrierten Entwicklungsumgebung (Integrated Development Environment, IDE) wie Cloud Shell verwenden, um Unterstützung beim Programmieren zu erhalten oder Probleme mit Ihrem Code zu lösen. Bevor Sie Gemini Code Assist verwenden können, müssen Sie das Tool aktivieren.

1. Aktivieren Sie in Cloud Shell die Gemini for Google Cloud API mit dem folgenden Befehl:

gcloud services enable cloudaicompanion.googleapis.com

2. Klicken Sie in der Cloud Shell-Symbolleiste auf Editor öffnen.

Hinweis: Klicken Sie zum Öffnen des Cloud Shell-Editors in der Cloud Shell-Symbolleiste auf Editor öffnen. Sie können zwischen Cloud Shell und dem Code-Editor wechseln. Klicken Sie dazu entsprechend auf Editor öffnen oder Terminal öffnen.

3. Klicken Sie im linken Bereich auf das Symbol Einstellungen und suchen Sie unter Einstellungen nach Gemini Code Assist.

4. Suchen Sie nach Gemini Code Assist: Aktivieren und prüfen Sie, ob das Kästchen ausgewählt ist. Schließen Sie dann die Einstellungen.

5. Klicken Sie in der Statusleiste unten auf dem Bildschirm auf Cloud Code – kein Projekt.

6. Autorisieren Sie das Plug-in wie beschrieben. Wenn kein Projekt automatisch ausgewählt wurde, klicken Sie auf Google Cloud-Projekt auswählen und wählen Sie aus.

7. Prüfen Sie, ob Ihr Google Cloud-Projekt () in der Cloud Code-Statusmeldung in der Statusleiste angezeigt wird.

Aufgabe 4: Compute Engine-Instanzen erstellen

Als Nächstes stellen Sie einige Compute Engine-Instanzen bereit.

In den nächsten Abschnitten führen Sie die folgenden Aktionen aus:

1. Sie erstellen ein Startscript, das Instanzen konfigurieren soll.
2. Sie klonen den Quellcode und laden ihn in Cloud Storage hoch.
3. Sie stellen eine Compute Engine-Instanz bereit, die die Backend-Mikrodienste hosten soll.
4. Sie konfigurieren den Frontend-Code neu, sodass die Instanz der Backend-Mikrodienste verwendet wird.
5. Sie stellen eine Compute Engine-Instanz bereit, die den Frontend-Mikrodienst hosten soll.
6. Sie konfigurieren das Netzwerk, um die Kommunikation zu ermöglichen.

Startscript erstellen

Ein Startscript weist die Instanz an, was bei jedem Start auszuführen ist. So werden die Instanzen automatisch konfiguriert.

1. Führen Sie im Cloud Shell-Terminal den folgenden Befehl aus, um eine Datei mit dem Namen startup-script.sh zu erstellen:

touch ~/monolith-to-microservices/startup-script.sh

2. Klicken Sie in der Cloud Shell-Symbolleiste auf Editor öffnen, um den Code-Editor zu öffnen.

3. Öffnen Sie den Ordner monolith-to-microservices.

4. Fügen Sie den folgenden Code in die Datei startup-script.sh ein. Später bearbeiten Sie einen Teil des eingefügten Codes:

#!/bin/bash # Install logging monitor. The monitor will automatically pick up logs sent to # syslog. curl -s "https://storage.googleapis.com/signals-agents/logging/google-fluentd-install.sh" | bash service google-fluentd restart & # Install dependencies from apt apt-get update apt-get install -yq ca-certificates git build-essential supervisor psmisc # Install nodejs mkdir /opt/nodejs curl https://nodejs.org/dist/v16.14.0/node-v16.14.0-linux-x64.tar.gz | tar xvzf - -C /opt/nodejs --strip-components=1 ln -s /opt/nodejs/bin/node /usr/bin/node ln -s /opt/nodejs/bin/npm /usr/bin/npm # Get the application source code from the Google Cloud Storage bucket. mkdir /fancy-store gsutil -m cp -r gs://fancy-store-[DEVSHELL_PROJECT_ID]/monolith-to-microservices/microservices/* /fancy-store/ # Install app dependencies. cd /fancy-store/ npm install # Create a nodeapp user. The application will run as this user. useradd -m -d /home/nodeapp nodeapp chown -R nodeapp:nodeapp /opt/app # Configure supervisor to run the node app. cat >/etc/supervisor/conf.d/node-app.conf << EOF [program:nodeapp] directory=/fancy-store command=npm start autostart=true autorestart=true user=nodeapp environment=HOME="/home/nodeapp",USER="nodeapp",NODE_ENV="production" stdout_logfile=syslog stderr_logfile=syslog EOF supervisorctl reread supervisorctl update

5. Klicken Sie zum Aktualisieren der Datei startup-script.sh auf das Symbol Gemini Code Assist: Intelligente Aktionen  und fügen Sie den folgenden Prompt ein, um den Text für [DEVSHELL_PROJECT_ID] zu suchen und zu ersetzen.

As an application developer at Cymbal AI, update the "startup-script.sh" file. Replace [DEVSHELL_PROJECT_ID] with the project ID: {{{project_0.project_id | Project ID}}}.

6. Drücken Sie die Eingabetaste, um die Datei zu aktualisieren. Klicken Sie in der Ansicht Unterschiede von Gemini auf Akzeptieren, wenn Sie dazu aufgefordert werden.

Die Codezeile in startup-script.sh sollte jetzt etwa so aussehen:

gs://fancy-store-{{{project_0.project_id | Project ID}}}/monolith-to-microservices/microservices/* /fancy-store/

7. Klicken Sie auf Speichern oder drücken Sie „Strg + S“, um die Datei startup-script.sh zu speichern, aber schließen Sie sie noch nicht.

8. Vergewissern Sie sich rechts unten im Cloud Shell-Code-Editor, dass „End of Line Sequence“ auf „LF“ gesetzt ist und nicht auf „CRLF“.

• Wenn die Auswahl „CRLF“ lautet, klicken Sie auf CRLF und wählen Sie dann im Drop-down LF aus.
• Wenn die Option bereits auf LF gesetzt ist, können Sie sie unverändert lassen.

Mit Gemini Code Assist Informationen zur Startscriptdatei abrufen

Damit Sie produktiver arbeiten können und weniger Kontextwechsel erforderlich sind, bietet Gemini Code Assist KI-basierte intelligente Aktionen direkt in Ihrem Code-Editor. Mit der Funktion „Erkläre mir das“ können Sie sich beispielsweise von Gemini Code Assist weitere Informationen zu einer bestimmten Datei, einem Codeblock oder einer Funktion geben lassen.

In diesem Abschnitt fordern Sie Gemini Code Assist auf, weitere Informationen zu einem Startscript für ein neues Teammitglied bereitzustellen, das damit nicht vertraut ist.

1. Klicken Sie bei geöffneter Datei startup-script.sh in der Symbolleiste auf das Symbol Gemini Code Assist: Intelligente Aktionen und wählen Sie Erkläre mir das aus.

2. Gemini Code Assist öffnet ein Chatfenster mit dem vorausgefüllten Prompt Erkläre mir das. Ersetzen Sie im Inline-Textfeld des Code Assist-Chats den vorausgefüllten Prompt durch Folgendes und klicken Sie auf Senden:

You are an Application developer at Cymbal AI. A new team member is unfamiliar with this startup script. Explain this "startup-script.sh" file in detail, breaking down its key components used in the code. Do not suggest any improvements or changes to the file.

Die Erklärung für den Code in der Datei startup-script.sh wird im Gemini Code Assist-Chat angezeigt.

3. Schließen Sie die Datei startup-script.sh.

Kehren Sie zum Cloud Shell-Terminal zurück und führen Sie den folgenden Befehl aus, um die Datei startup-script.sh in den Bucket zu kopieren:

gsutil cp ~/monolith-to-microservices/startup-script.sh gs://fancy-store-{{{project_0.project_id | Project ID}}}

Sie ist jetzt unter https://storage.googleapis.com/[BUCKET_NAME]/startup-script.sh verfügbar.

[BUCKET_NAME] ist der Name des Cloud Storage-Buckets. Die Datei ist standardmäßig nur für autorisierte Nutzer und Dienstkonten sichtbar und daher nicht über einen Webbrowser zugänglich. Compute Engine-Instanzen können über ihr Dienstkonto automatisch darauf zugreifen.

Das Startscript führt die folgenden Aktionen aus:

• Es installiert den Logging-Agent. Der Agent erfasst automatisch Logs aus „syslog“.
• Es installiert Node.js und Supervisor. Supervisor führt die Anwendung als Daemon aus.
• Es klont den Quellcode der Anwendung aus dem Cloud Storage-Bucket und installiert Abhängigkeiten.
• Es konfiguriert Supervisor zum Ausführen der Anwendung. Supervisor sorgt dafür, dass die Anwendung neu gestartet wird, wenn sie unerwartet beendet oder von einem Administrator oder einem anderen Prozess abgebrochen wird. Außerdem sendet es „stdout“ und „stderr“ der Anwendung an „syslog“, damit sie vom Logging-Agent erfasst werden.

Code in den Cloud Storage-Bucket kopieren

Beim Start rufen Instanzen Code aus dem Cloud Storage-Bucket ab. Sie können also Konfigurationsvariablen in der .env-Datei des Codes speichern.

Hinweis: Sie können auch im Code festlegen, dass Umgebungsvariablen von einer anderen Stelle abgerufen werden. Zu Demonstrationszwecken ist dies aber eine einfache Methode für die Konfiguration. In der Produktion sind Umgebungsvariablen meistens außerhalb des Codes gespeichert.

• Führen Sie den folgenden Befehl aus, um den geklonten Code in Ihren Bucket zu kopieren:

cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | Project ID}}}/ Hinweis: Die Abhängigkeitsverzeichnisse node_modules werden gelöscht, damit der Kopiervorgang so schnell und effizient wie möglich ausgeführt wird. Diese Abhängigkeiten werden beim Start der Instanzen neu erstellt.

Klicken Sie auf Fortschritt prüfen. Startscript und Code in den Cloud Storage-Bucket kopieren

Backend-Instanz bereitstellen

Als erste Instanz wird die Backend-Instanz bereitgestellt, die die Mikrodienste „Orders“ und „Products“ beinhaltet.

Hinweis: In einer Produktionsumgebung sollten Sie für jeden Mikrodienst eine eigene Instanz und Instanzgruppe einrichten, damit er unabhängig skaliert werden kann. Zu Demonstrationszwecken befinden sich beide Backend-Mikrodienste („Orders“ und „Products“) in derselben Instanz und Instanzgruppe.

• Führen Sie den folgenden Befehl aus, um eine e2-standard-2-Instanz zu erstellen, die zur Verwendung des Startscripts konfiguriert ist. Die Instanz ist mit dem Tag backend versehen, sodass Sie später spezielle Firewallregeln darauf anwenden können:

gcloud compute instances create backend \ --zone={{{project_0.default_zone | zone}}} \ --machine-type=e2-standard-2 \ --tags=backend \ --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-{{{project_0.project_id | Project ID}}}/startup-script.sh

Verbindung zum Backend konfigurieren

Bevor Sie das Frontend der Anwendung bereitstellen, müssen Sie die Konfiguration so aktualisieren, dass sie auf das gerade bereitgestellte Backend verweist.

1. Rufen Sie die externe IP-Adresse des Backends mit dem folgenden Befehl ab. Suchen Sie unter dem Tab EXTERNAL_IP nach der Backend-Instanz:

gcloud compute instances list

Beispielausgabe:

NAME: backend ZONE: {{{project_0.default_zone | zone}}} MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: INTERNAL_IP: 10.142.0.2 EXTERNAL_IP: 35.237.245.193 STATUS: RUNNING

2. Kopieren Sie die externe IP-Adresse für das Backend.

3. Öffnen Sie im Cloud Shell-Explorer monolith-to-microservices > react-app.

4. Wählen Sie im Code-Editor Ansicht > Versteckte Dateien einblenden aus, um die .env-Datei zu sehen.

Im nächsten Schritt bearbeiten Sie die .env-Datei, damit sie auf die externe IP-Adresse des Backends verweist. [BACKEND_ADDRESS] ist die externe IP-Adresse der Backend-Instanz, die mit dem zuletzt ausgeführten gcloud-Befehl ermittelt wurde.

5. Ersetzen Sie in der .env-Datei localhost durch Ihre [BACKEND_ADDRESS]:

REACT_APP_ORDERS_URL=http://[BACKEND_ADDRESS]:8081/api/orders REACT_APP_PRODUCTS_URL=http://[BACKEND_ADDRESS]:8082/api/products

6. Speichern Sie die Datei.

7. Führen Sie in Cloud Shell den folgenden Befehl aus, um react-app neu zu erstellen. Dadurch wird der Frontend-Code aktualisiert:

cd ~/monolith-to-microservices/react-app npm install && npm run-script build

8. Führen Sie dann den folgenden Befehl aus, um den Anwendungscode in den Cloud Storage-Bucket zu kopieren:

cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | Project ID}}}/

Frontend-Instanz bereitstellen

Nachdem der Code nun konfiguriert ist, können Sie die Frontend-Instanz bereitstellen.

• Führen Sie den folgenden Befehl aus, um die frontend-Instanz mit einem ähnlichen Befehl wie zuvor bereitzustellen. Diese Instanz ist mit dem Tag frontend versehen, um damit später Firewallregeln erstellen zu können:

gcloud compute instances create frontend \ --zone={{{project_0.default_zone | zone}}} \ --machine-type=e2-standard-2 \ --tags=frontend \ --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-{{{project_0.project_id | Project ID}}}/startup-script.sh Hinweis: Das Bereitstellungs- und Startscript wird der Einfachheit halber für die Frontend- und die Backend-Instanzen verwendet – auch, weil der Code so konfiguriert ist, dass standardmäßig alle Mikrodienste gestartet werden. Alle Mikrodienste in diesem Beispiel werden daher sowohl auf dem Frontend als auch auf dem Backend ausgeführt. In einer Produktionsumgebung würden Sie die erforderlichen Mikrodienste auf getrennten Komponenten ausführen.

Netzwerk konfigurieren

1. Führen Sie den folgenden Befehl aus, um Firewallregeln zu erstellen, die den Zugriff auf Port 8080 für das Frontend und auf die Ports 8081–8082 für das Backend erlauben. Diese Firewallbefehle verwenden die Tags, die während der Instanzerstellung für die Anwendung zugewiesen wurden:

gcloud compute firewall-rules create fw-fe \ --allow tcp:8080 \ --target-tags=frontend gcloud compute firewall-rules create fw-be \ --allow tcp:8081-8082 \ --target-tags=backend

Die Website sollte jetzt voll funktionsfähig sein.

2. Sie müssen die externe IP-Adresse der frontend-Instanz kennen, um sie aufzurufen. Führen Sie den folgenden Befehl aus und suchen Sie die externe IP-Adresse der frontend-Instanz:

gcloud compute instances list

Beispielausgabe:

NAME: backend ZONE: us-central1-f MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: INTERNAL_IP: 10.128.0.2 EXTERNAL_IP: 34.27.178.79 STATUS: RUNNING NAME: frontend ZONE: us-central1-f MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: INTERNAL_IP: 10.128.0.3 EXTERNAL_IP: 34.172.241.242 STATUS: RUNNING

Es kann einige Minuten dauern, bis die Instanz gestartet und konfiguriert ist.

3. Warten Sie drei Minuten, öffnen Sie dann einen neuen Browsertab und rufen Sie http://[FRONTEND_ADDRESS]:8080 auf, um auf die Website zuzugreifen. Dabei ist [FRONTEND_ADDRESS] die oben ermittelte externe IP-Adresse des Frontends.

4. Versuchen Sie, die Seiten Products und Orders zu öffnen. Das sollte nun funktionieren.

Klicken Sie auf Fortschritt prüfen. Instanzen bereitstellen und Netzwerk konfigurieren

Aufgabe 5: Verwaltete Instanzgruppen erstellen

Damit die Anwendung skalierbar ist, werden verwaltete Instanzgruppen erstellt, die die frontend- und backend-Instanzen als Instanzvorlagen verwenden.

Eine verwaltete Instanzgruppe enthält identische Instanzen, die Sie als einzelne Entität in einer einzelnen Zone verwalten können. Mit verwalteten Instanzgruppen sorgen Sie für Hochverfügbarkeit Ihrer Anwendungen, da sie proaktiv dafür sorgen, dass die Instanzen verfügbar bleiben, also den Status WIRD AUSGEFÜHRT haben. Sie nutzen verwaltete Instanzgruppen für Ihre Frontend‑ und Backend-Instanzen für die automatische Reparatur, Load Balancing, Autoscaling und Rolling Updates.

Instanzvorlage aus einer Quellinstanz erstellen

Bevor Sie eine verwaltete Instanzgruppe erstellen können, müssen Sie zuerst eine Instanzvorlage erstellen, die die Grundlage für die Gruppe bildet. Mit Instanzvorlagen können Sie bei der Erstellung neuer VM-Instanzen den Maschinentyp, das Bootlaufwerk-Image oder Container-Image, das Netzwerk sowie weitere Eigenschaften von Instanzen definieren. Außerdem können Sie mit Instanzvorlagen Instanzen in einer verwalteten Instanzgruppe oder sogar einzelne Instanzen erstellen.

Erstellen Sie die Instanzvorlage mithilfe der Instanzen, die Sie zuvor erstellt haben.

1. Führen Sie zuerst den folgenden Befehl aus, um beide Instanzen zu beenden:

gcloud compute instances stop frontend --zone={{{project_0.default_zone | zone}}} gcloud compute instances stop backend --zone={{{project_0.default_zone | zone}}}

2. Erstellen Sie dann mit den folgenden Befehlen Instanzvorlagen aus den Quellinstanzen:

gcloud compute instance-templates create fancy-fe \ --source-instance-zone={{{project_0.default_zone | zone}}} \ --source-instance=frontend gcloud compute instance-templates create fancy-be \ --source-instance-zone={{{project_0.default_zone | zone}}} \ --source-instance=backend

3. Führen Sie den folgenden Befehl aus, um zu prüfen, ob die Instanzvorlagen erstellt wurden:

gcloud compute instance-templates list

Beispielausgabe:

NAME: fancy-be MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: CREATION_TIMESTAMP: 2023-07-25T14:52:21.933-07:00 NAME: fancy-fe MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: CREATION_TIMESTAMP: 2023-07-25T14:52:15.442-07:00

4. Da die Instanzvorlagen nun erstellt sind, können Sie die backend-VM löschen, um Ressourcen zu sparen:

gcloud compute instances delete backend --zone={{{project_0.default_zone | zone}}}

5. Geben Sie bei entsprechender Aufforderung y ein und drücken Sie die Eingabetaste.

Normalerweise könnten Sie die frontend-VM ebenfalls löschen, aber Sie werden sie später in diesem Lab noch verwenden, um die Instanzvorlage zu aktualisieren.

Verwaltete Instanzgruppen erstellen

1. Führen Sie als Nächstes die folgenden Befehle aus, um zwei verwaltete Instanzgruppen zu erstellen, eine für das Frontend und eine für das Backend:

gcloud compute instance-groups managed create fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --base-instance-name fancy-fe \ --size 2 \ --template fancy-fe gcloud compute instance-groups managed create fancy-be-mig \ --zone={{{project_0.default_zone | zone}}} \ --base-instance-name fancy-be \ --size 2 \ --template fancy-be

Diese verwalteten Instanzgruppen verwenden die Instanzvorlagen und sind so konfiguriert, dass je zwei Instanzen aus jeder Gruppe gestartet werden. Die Instanzen werden automatisch basierend auf dem angegebenen base-instance-name benannt, wobei zufällige Zeichen angehängt werden.

2. Führen Sie den folgenden Befehl aus, um sicherzustellen, dass für Ihre Anwendung der frontend-Mikrodienst an Port 8080 und der backend-Mikrodienst an Port 8081 für orders und an Port 8082 für products ausgeführt wird:

gcloud compute instance-groups set-named-ports fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --named-ports frontend:8080 gcloud compute instance-groups set-named-ports fancy-be-mig \ --zone={{{project_0.default_zone | zone}}} \ --named-ports orders:8081,products:8082

Da dies keine Standardports sind, geben Sie benannte Ports an, um sie zu kennzeichnen. Benannte Ports sind Metadaten mit Schlüssel/Wert-Paaren, die den Dienstnamen und den Port darstellen, an dem er ausgeführt wird. Benannte Ports können einer Instanzgruppe zugewiesen werden. Dadurch wird festgelegt, dass der Dienst für alle Instanzen in der Gruppe verfügbar ist. Diese Information wird vom HTTP-Load-Balancing-Dienst genutzt, den Sie später konfigurieren.

Automatische Reparatur konfigurieren

Um die Verfügbarkeit der Anwendung selbst zu verbessern und um zu prüfen, ob sie antwortet, konfigurieren Sie eine Richtlinie zur automatischen Reparatur für die verwalteten Instanzgruppen.

Im Rahmen der Richtlinie wird eine anwendungsbasierte Systemdiagnose durchgeführt, bei der geprüft wird, ob eine Anwendung wie erwartet antwortet. Die Prüfung, ob eine Anwendung antwortet, liefert genauere Ergebnisse als die Prüfung, ob eine Instanz ausgeführt wird (Standardverhalten).

Hinweis: Für das Load Balancing und die automatische Reparatur werden getrennte Systemdiagnosen verwendet. Die Systemdiagnose für das Load Balancing sollte strenger sein, denn sie entscheidet darüber, ob eine Instanz Nutzertraffic empfängt. Nicht antwortende Instanzen müssen schnell ermittelt werden, damit der Traffic bei Bedarf umgeleitet werden kann. Im Gegensatz dazu führt die Systemdiagnose für die automatische Reparatur dazu, dass die Compute Engine fehlerhafte Instanzen proaktiv ersetzt. Sie sollte daher konservativer sein als eine Systemdiagnose für das Load Balancing.

1. Führen Sie den folgenden Befehl aus, um eine Systemdiagnose zu erstellen, bei der die Instanz repariert wird, wenn die Prüfung für die frontend- und backend-Instanzen dreimal hintereinander fehlschlägt:

gcloud compute health-checks create http fancy-fe-hc \ --port 8080 \ --check-interval 30s \ --healthy-threshold 1 \ --timeout 10s \ --unhealthy-threshold 3 gcloud compute health-checks create http fancy-be-hc \ --port 8081 \ --request-path=/api/orders \ --check-interval 30s \ --healthy-threshold 1 \ --timeout 10s \ --unhealthy-threshold 3

2. Führen Sie den folgenden Befehl aus, um eine Firewallregel zu erstellen, die es den Systemdiagnoseprüfungen ermöglicht, eine Verbindung zu den Mikrodiensten an den Ports 8080–8081 herzustellen:

gcloud compute firewall-rules create allow-health-check \ --allow tcp:8080-8081 \ --source-ranges 130.211.0.0/22,35.191.0.0/16 \ --network default

3. Wenden Sie die Systemdiagnosen mit den folgenden Befehlen auf die entsprechenden Dienste an:

gcloud compute instance-groups managed update fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --health-check fancy-fe-hc \ --initial-delay 300 gcloud compute instance-groups managed update fancy-be-mig \ --zone={{{project_0.default_zone | zone}}} \ --health-check fancy-be-hc \ --initial-delay 300 Hinweis: Es kann 15 Minuten dauern, bis die automatische Reparatur mit der Überwachung von Instanzen in der Gruppe beginnt.

4. Fahren Sie mit dem Lab fort, da es eine Weile dauert, bis die Instanzen in der Gruppe im Rahmen der automatischen Reparatur überwacht werden. Am Ende des Labs werden Sie einen Fehler simulieren, um die automatische Reparatur zu testen.

Klicken Sie auf Fortschritt prüfen. Verwaltete Instanzgruppen erstellen

Aufgabe 6: Load Balancer erstellen

Verwenden Sie als Ergänzung Ihrer verwalteten Instanzgruppen HTTP(S) Load Balancer, um Traffic an die Frontend‑ und Backend-Mikrodienste weiterzuleiten, sowie Zuordnungen, um Traffic basierend auf Pfadregeln an die richtigen Backend-Dienste zu senden. So wird eine einzelne IP-Adresse mit Load Balancing für alle Dienste verfügbar gemacht.

Weitere Informationen zu den Load-Balancing-Optionen in Google Cloud finden Sie unter Übersicht über Cloud Load Balancing.

HTTP(S) Load Balancer erstellen

Google Cloud bietet viele verschiedene Load-Balancer-Typen. In diesem Lab verwenden Sie einen HTTP(S) Load Balancer für Ihren Traffic. Ein HTTP Load Balancer ist so aufgebaut:

• Mit einer Weiterleitungsregel werden eingehende Anfragen an einen Ziel-HTTP-Proxy weitergeleitet.
• Der Ziel-HTTP-Proxy überprüft bei jeder Anfrage, ob diese mit der URL-Zuordnung übereinstimmt, um den passenden Backend-Dienst für die Anfrage auswählen zu können.
• Der Backend-Dienst leitet jede Anfrage basierend auf Bereitstellungskapazität, Zone und Instanzstatus der dazugehörigen Backends an das passende Backend weiter. Der Status aller Backend-Instanzen wird mithilfe einer HTTP-Systemdiagnose überprüft. Wenn der Backend-Dienst für die Verwendung einer HTTPS- oder HTTP/2-Systemdiagnose konfiguriert ist, wird die Anfrage auf dem Weg zur Backend-Instanz verschlüsselt.
• Sitzungen zwischen dem Load Balancer und der Instanz können das HTTP-, HTTPS- oder HTTP/2-Protokoll verwenden. Wenn Sie HTTPS oder HTTP/2 verwenden, müssen alle Instanzen in den Backend-Diensten ein SSL-Zertifikat haben.

Hinweis: Verwenden Sie HTTP anstelle von HTTPS, um zu Demonstrationszwecken die Komplexität von SSL-Zertifikaten zu vermeiden. Für die Produktion wird empfohlen, nach Möglichkeit HTTPS zur Verschlüsselung zu verwenden.

1. Führen Sie den folgenden Befehl aus, um Systemdiagnosen zu erstellen, mit denen ermittelt wird, welche Instanzen Traffic an den jeweiligen Dienst weiterleiten können:

gcloud compute http-health-checks create fancy-fe-frontend-hc \ --request-path / \ --port 8080 gcloud compute http-health-checks create fancy-be-orders-hc \ --request-path /api/orders \ --port 8081 gcloud compute http-health-checks create fancy-be-products-hc \ --request-path /api/products \ --port 8082 Hinweis: Diese Systemdiagnosen sind für den Load Balancer vorgesehen und dienen nur der Weiterleitung von Traffic vom Load Balancer. Sie sorgen nicht dafür, dass die verwalteten Instanzgruppen Instanzen neu erstellen.

2. Führen Sie den folgenden Befehl aus, um Backend-Dienste zu erstellen, die das Ziel für Traffic mit Load Balancing sind. Die Backend-Dienste verwenden die Systemdiagnosen und benannten Ports, die Sie erstellt haben:

gcloud compute backend-services create fancy-fe-frontend \ --http-health-checks fancy-fe-frontend-hc \ --port-name frontend \ --global gcloud compute backend-services create fancy-be-orders \ --http-health-checks fancy-be-orders-hc \ --port-name orders \ --global gcloud compute backend-services create fancy-be-products \ --http-health-checks fancy-be-products-hc \ --port-name products \ --global

3. Führen Sie den folgenden Befehl aus, um die Backend-Dienste des Load Balancers hinzuzufügen:

gcloud compute backend-services add-backend fancy-fe-frontend \ --instance-group-zone={{{project_0.default_zone | zone}}} \ --instance-group fancy-fe-mig \ --global gcloud compute backend-services add-backend fancy-be-orders \ --instance-group-zone={{{project_0.default_zone | zone}}} \ --instance-group fancy-be-mig \ --global gcloud compute backend-services add-backend fancy-be-products \ --instance-group-zone={{{project_0.default_zone | zone}}} \ --instance-group fancy-be-mig \ --global

4. Führen Sie den folgenden Befehl aus, um eine URL-Zuordnung zu erstellen, die festlegt, welche URLs an welche Backend-Dienste weitergeleitet werden:

gcloud compute url-maps create fancy-map \ --default-service fancy-fe-frontend

5. Führen Sie den folgenden Befehl aus, um einen Pfad-Matcher zu erstellen, damit die Pfade /api/orders und /api/products an die entsprechenden Dienste weitergeleitet werden:

gcloud compute url-maps add-path-matcher fancy-map \ --default-service fancy-fe-frontend \ --path-matcher-name orders \ --path-rules "/api/orders=fancy-be-orders,/api/products=fancy-be-products"

6. Führen Sie den folgenden Befehl aus, um den Proxy zu erstellen, der mit der URL-Zuordnung verknüpft ist:

gcloud compute target-http-proxies create fancy-proxy \ --url-map fancy-map

7. Führen Sie den folgenden Befehl aus, um eine globale Weiterleitungsregel zu erstellen, die eine öffentliche IP-Adresse und einen Port mit dem Proxy verknüpft:

gcloud compute forwarding-rules create fancy-http-rule \ --global \ --target-http-proxy fancy-proxy \ --ports 80

Klicken Sie auf Fortschritt prüfen. HTTP(S) Load Balancer erstellen

Konfiguration aktualisieren

Sie haben nun eine neue statische IP-Adresse. Aktualisieren Sie den Code an der frontend-Instanz, damit auf diese neue Adresse verwiesen wird und nicht auf die zuvor verwendete sitzungsspezifische Adresse, die auf die backend-Instanz verwiesen hat.

1. Führen Sie in Cloud Shell den folgenden Befehl aus, um zum Ordner react-app zu wechseln, in dem die Datei .env gespeichert ist, die die Konfiguration enthält:

cd ~/monolith-to-microservices/react-app/

2. Führen Sie den folgenden Befehl aus, um die IP-Adresse für den Load Balancer zu ermitteln:

gcloud compute forwarding-rules list --global

Beispielausgabe:

NAME: fancy-http-rule REGION: IP_ADDRESS: 34.111.203.235 IP_PROTOCOL: TCP TARGET: fancy-proxy

3. Kehren Sie zum Cloud Shell-Editor zurück und bearbeiten Sie die .env-Datei noch einmal, damit sie auf die öffentliche IP-Adresse des Load Balancers verweist. [LB_IP] ist die oben ermittelte externe IP-Adresse der Backend-Instanz.

REACT_APP_ORDERS_URL=http://[LB_IP]/api/orders REACT_APP_PRODUCTS_URL=http://[LB_IP]/api/products Hinweis: Die Ports werden in der neuen Adresse entfernt, weil der Load Balancer so konfiguriert ist, dass er diese Weiterleitung für Sie übernimmt.

4. Speichern Sie die Datei.

5. Führen Sie die folgenden Befehle aus, um react-app neu zu erstellen. Dadurch wird der Frontend-Code aktualisiert:

cd ~/monolith-to-microservices/react-app npm install && npm run-script build

6. Führen Sie den folgenden Befehl aus, um den Anwendungscode in Ihren Bucket zu kopieren:

cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | Project ID}}}/

Frontend-Instanzen aktualisieren

Da es neuen Code und eine neue Konfiguration gibt, sollen die Frontend-Instanzen in der verwalteten Instanzgruppe den neuen Code abrufen.

• Weil Ihre Instanzen den Code beim Start abrufen, können Sie mit dem folgenden Befehl einen gestaffelten Neustart ausführen:

gcloud compute instance-groups managed rolling-action replace fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --max-unavailable 100% Hinweis: In diesem Beispiel einer gestaffelten Ersetzung geben Sie explizit mit dem --max-unavailable-Parameter an, dass alle Maschinen sofort ersetzt werden können. Ohne diesen Parameter würde der Befehl eine Instanz aktiv lassen, während die anderen neu starten, um Verfügbarkeit zu gewährleisten. Für Testzwecke geben Sie an, dass alle sofort ersetzt werden, damit es schneller geht.

Klicken Sie auf Fortschritt prüfen. Frontend-Instanzen aktualisieren

Website testen

1. Warten Sie drei Minuten, nachdem der Befehl rolling-action replace ausgeführt wurde, damit die Instanzen verarbeitet werden können. Prüfen Sie dann den Status der verwalteten Instanzgruppe. Führen Sie den folgenden Befehl aus, um zu prüfen, ob der Dienst den Status HEALTHY aufweist:

watch -n 2 gcloud compute backend-services get-health fancy-fe-frontend --global

2. Warten Sie, bis die zwei Dienste den Status HEALTHY haben.

Beispielausgabe:

backend: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instanceGroups/fancy-fe-mig status: healthStatus: - healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instances/fancy-fe-x151 ipAddress: 10.128.0.7 port: 8080 - healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instances/fancy-fe-cgrt ipAddress: 10.128.0.11 port: 8080 kind: compute#backendServiceGroupHealth Hinweis: Wenn bei einer Instanz ein Problem auftritt und sie den Status UNHEALTHY hat, sollte sie automatisch repariert werden. Warten Sie, bis dieser Vorgang abgeschlossen ist.

Wenn nach einer Weile keine der Instanzen den Status HEALTHY erhält, wurden die Frontend-Instanzen nicht korrekt eingerichtet, wodurch der Zugriff auf sie an Port 8080 nicht möglich ist. Testen Sie dies. Rufen Sie dazu die Instanzen direkt an Port 8080 auf.

3. Sobald beide Instanzen in der Liste den Status HEALTHY haben, beenden Sie den watch-Befehl. Drücken Sie dazu „Strg + C“.

Hinweis: Der Zugriff auf die Anwendung ist über http://[LB_IP] möglich, wobei [LB_IP] die für den Load Balancer angegebene IP-Adresse ist, die mit dem folgenden Befehl ermittelt werden kann:

gcloud compute forwarding-rules list --global

Sie prüfen die Anwendung später im Lab.

Aufgabe 7: Compute Engine skalieren

Bis jetzt haben Sie zwei verwaltete Instanzgruppen mit jeweils zwei Instanzen erstellt. Diese Konfiguration ist voll funktionsfähig, aber statisch und damit unabhängig von der Last. Als Nächstes erstellen Sie eine Autoscaling-Richtlinie, um die verwalteten Instanzgruppen basierend auf der Auslastung automatisch zu skalieren.

Anhand der Auslastung automatisch skalieren

• Führen Sie den folgenden Befehl aus, um die Autoscaling-Richtlinie zu erstellen:

gcloud compute instance-groups managed set-autoscaling \ fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --max-num-replicas 2 \ --target-load-balancing-utilization 0.60 gcloud compute instance-groups managed set-autoscaling \ fancy-be-mig \ --zone={{{project_0.default_zone | zone}}} \ --max-num-replicas 2 \ --target-load-balancing-utilization 0.60

Mit diesen Befehlen wird eine Autoscaling-Funktion für verwaltete Instanzgruppen erstellt. Beim Autoscaling werden automatisch Instanzen hinzugefügt, wenn die Auslastung bei über 60 % liegt, und Instanzen entfernt, wenn der Load Balancer bei unter 60 % Auslastung ist.

Content Delivery Network aktivieren

Eine weitere Funktion, die für das Skalieren hilfreich sein kann, ist ein CDN-Dienst (Content Delivery Network), der Caching für das Frontend ermöglicht.

• Führen Sie für den Frontend-Dienst den folgenden Befehl aus:

gcloud compute backend-services update fancy-fe-frontend \ --enable-cdn --global

Wenn ein Nutzer Inhalt vom HTTP(S) Load Balancer anfordert, kommt die Anfrage bei einem Google Front End (GFE) an, das zuerst im Cloud CDN-Cache nach einer Antwort auf die Anfrage des Nutzers sucht. Wenn das GFE eine im Cache gespeicherte Antwort findet, sendet es diese Antwort an den Nutzer. Dies wird als Cache-Treffer bezeichnet.

Wenn das GFE keine im Cache gespeicherte Antwort für die Anfrage findet, stellt es eine Anfrage direkt an das Backend. Kann die Antwort auf die Anfrage im Cache gespeichert werden, speichert das GFE sie im Cloud CDN-Cache, sodass der Cache für weitere Anfragen genutzt werden kann.

Klicken Sie auf Fortschritt prüfen. Compute Engine skalieren

Aufgabe 8: Website aktualisieren

Instanzvorlage aktualisieren

Bestehende Instanzvorlagen können nicht bearbeitet werden. Da Ihre Instanzen jedoch zustandslos sind und die gesamte Konfiguration über das Startscript erfolgt, müssen Sie die Instanzvorlage nur ändern, wenn Sie die Vorlageneinstellungen anpassen möchten. In dieser Aufgabe nehmen Sie eine einfache Anpassung vor, indem Sie einen größeren Maschinentyp auswählen und diese Änderung ausrollen.

Führen Sie dazu die folgenden Schritte aus:

• Aktualisieren Sie die frontend-Instanz, die als Basis für die Instanzvorlage dient. Bei der Aktualisierung speichern Sie die neue Version des Images der Instanzvorlage in einer Datei. Dann aktualisieren Sie die Instanzvorlage und stellen die neue Vorlage bereit. Schließlich prüfen Sie, ob die Datei in den Instanzen der verwalteten Instanzgruppe vorhanden ist.

• Ändern Sie den Maschinentyp Ihrer Instanzvorlage. Ersetzen Sie dazu den Maschinentyp e2-standard-2 durch e2-small.

1. Führen Sie den folgenden Befehl aus, um den Maschinentyp der Frontend-Instanz zu ändern:

gcloud compute instances set-machine-type frontend \ --zone={{{project_0.default_zone | zone}}} \ --machine-type e2-small

2. Führen Sie den folgenden Befehl aus, um die neue Instanzvorlage zu erstellen:

gcloud compute instance-templates create fancy-fe-new \ --region=$REGION \ --source-instance=frontend \ --source-instance-zone={{{project_0.default_zone | zone}}}

3. Stellen Sie die aktualisierte Instanzvorlage mit dem folgenden Befehl in der verwalteten Instanzgruppe bereit:

gcloud compute instance-groups managed rolling-action start-update fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --version template=fancy-fe-new

4. Warten Sie drei Minuten und führen Sie dann den folgenden Befehl aus, um den Status der Aktualisierung zu überwachen:

watch -n 2 gcloud compute instance-groups managed list-instances fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}}

Dieser Vorgang dauert einige Minuten.

Achten Sie darauf, dass mindestens eine Instanz die folgende Bedingung erfüllt, bevor Sie fortfahren:

• STATUS: RUNNING
• ACTION: None
• INSTANCE_TEMPLATE: der neue Vorlagenname (fancy-fe-new)

5. Kopieren Sie den Namen einer der aufgeführten Maschinen, um ihn für den nächsten Befehl zu verwenden.

6. Drücken Sie „Strg + C“, um den watch-Prozess zu beenden.

7. Führen Sie den folgenden Befehl aus, um zu sehen, ob die virtuelle Maschine den neuen Maschinentyp (e2-small) verwendet, wobei [VM_NAME] die neu erstellte Instanz ist:

gcloud compute instances describe [VM_NAME] --zone={{{project_0.default_zone | zone}}} | grep machineType

Erwartete Beispielausgabe:

machineType: https://www.googleapis.com/compute/v1/projects/project-name/zones/us-central1-f/machineTypes/e2-small

Website ändern

Szenario: Ihr Marketingteam hat Sie gebeten, die Startseite Ihrer Website zu ändern. Sie soll mehr Informationen über das Unternehmen selbst und dessen Produkte enthalten.

In diesem Abschnitt fügen Sie der Startseite neue Texte hinzu, um dem Wunsch des Marketingteams nachzukommen. Offenbar hat einer der Entwickler die Änderungen bereits unter dem Dateinamen index.js.new erstellt. Sie können diese Datei einfach nach index.js kopieren, sodass die Änderungen darin enthalten sind. Mit den folgenden Schritten nehmen Sie die entsprechenden Änderungen vor.

1. Führen Sie die folgenden Befehle aus, um die aktualisierte Datei in den korrekten Dateinamen umzubenennen:

cd ~/monolith-to-microservices/react-app/src/pages/Home mv index.js.new index.js

2. Geben Sie den Dateiinhalt aus, um die Änderungen zu prüfen:

cat ~/monolith-to-microservices/react-app/src/pages/Home/index.js

Der resultierende Code sollte in etwa so aussehen:

Ausgabe:

/* Copyright 2019 Google LLC Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at https://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ import React from "react"; import { Box, Paper, Typography } from "@mui/material"; export default function Home() { return ( <Box sx={{ flexGrow: 1 }}> <Paper elevation={3} sx={{ width: "800px", margin: "0 auto", padding: (theme) => theme.spacing(3, 2), }} > <Typography variant="h5">Welcome to the Fancy Store!</Typography> <br /> <Typography variant="body1"> Take a look at our wide variety of products. </Typography> </Paper> </Box> ); }

Sie haben die React-Komponenten aktualisiert, müssen aber noch die React-Anwendung erstellen, um die statischen Dateien zu generieren.

3. Führen Sie den folgenden Befehl aus, um die React-Anwendung zu erstellen und in das öffentliche monolith-Verzeichnis zu kopieren:

cd ~/monolith-to-microservices/react-app npm install && npm run-script build

4. Führen Sie dann den folgenden Befehl aus, um diesen Code wieder in den Bucket hochzuladen:

cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | Project ID}}}/

Änderungen per Push mit gestaffelten Ersetzungen übertragen

1. Führen Sie nun den folgenden Befehl aus, um alle Instanzen zu ersetzen und die Aktualisierung zu übernehmen:

gcloud compute instance-groups managed rolling-action replace fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --max-unavailable=100%

Hinweis: In diesem Beispiel einer gestaffelten Ersetzung geben Sie explizit mit dem --max-unavailable-Parameter an, dass alle Maschinen sofort ersetzt werden können. Ohne diesen Parameter würde der Befehl eine Instanz aktiv lassen, während die anderen ersetzt werden. Für Testzwecke geben Sie an, dass alle sofort ersetzt werden, damit es schneller geht. In der Produktion würde durch diesen Puffer die Website während der Aktualisierung weiterhin bereitgestellt werden können.

Klicken Sie auf Fortschritt prüfen. Website aktualisieren

2. Warten Sie drei Minuten, nachdem der Befehl rolling-action replace ausgeführt wurde, damit die Instanzen verarbeitet werden können. Prüfen Sie dann den Status der verwalteten Instanzgruppe. Führen Sie den folgenden Befehl aus, um zu prüfen, ob der Dienst den Status HEALTHY aufweist:

watch -n 2 gcloud compute backend-services get-health fancy-fe-frontend --global

3. Warten Sie einige Sekunden, bis beide Dienste angezeigt werden und den Status HEALTHY erhalten.

Beispielausgabe:

backend: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instanceGroups/fancy-fe-mig status: healthStatus: - healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instances/fancy-fe-x151 ipAddress: 10.128.0.7 port: 8080 - healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instances/fancy-fe-cgrt ipAddress: 10.128.0.11 port: 8080 kind: compute#backendServiceGroupHealth

4. Sobald die Dienste in der Liste mit dem Status HEALTHY angezeigt werden, beenden Sie den watch-Befehl. Drücken Sie dazu „Strg + C“.

5. Öffnen Sie die Website über http://[LB_IP], wobei [LB_IP] die für den Load Balancer angegebene IP-Adresse ist, die mit dem folgenden Befehl ermittelt werden kann:

gcloud compute forwarding-rules list --global

Die neuen Websiteänderungen sollten jetzt sichtbar sein.

Fehler simulieren

Um zu prüfen, ob die Systemdiagnose funktioniert, melden Sie sich bei einer Instanz an und beenden die Dienste.

1. Führen Sie den folgenden Befehl aus, um einen Instanznamen zu finden:

gcloud compute instance-groups list-instances fancy-fe-mig --zone={{{project_0.default_zone | zone}}}

2. Kopieren Sie einen Instanznamen. Führen Sie dann den folgenden Befehl aus, um SSH in der Instanz zu nutzen. INSTANCE_NAME ist hierbei eine der Instanzen von der Liste:

gcloud compute ssh [INSTANCE_NAME] --zone={{{project_0.default_zone | zone}}}

3. Geben Sie „y“ ein, um zu bestätigen. Drücken Sie zweimal die Eingabetaste, um kein Passwort zu verwenden.

4. Führen Sie in der Instanz den folgenden Befehl aus, um die Anwendung mit supervisorctl zu beenden:

sudo supervisorctl stop nodeapp; sudo killall node

5. Führen Sie den folgenden Befehl aus, um die Instanz zu verlassen:

exit

6. Überwachen Sie die Reparaturvorgänge:

watch -n 2 gcloud compute operations list \ --filter='operationType~compute.instances.repair.*'

Der Vorgang kann mehrere Minuten dauern.

Suchen Sie nach der folgenden Beispielausgabe:

Ausgabe:

NAME: repair-1755080598062-63c3c8b99843b-eed8dabc-f1833ea3 TYPE: compute.instances.repair.recreateInstance TARGET: us-east4-c/instances/fancy-fe-tn40 HTTP_STATUS: 200 STATUS: DONE TIMESTAMP: 2025-08-13T03:23:18.062-07:00

Die verwaltete Instanzgruppe hat die Instanz neu erstellt, um sie zu reparieren.

7. Sie können das Monitoring auch über die Console ausführen. Klicken Sie dazu auf Navigationsmenü > Compute Engine > VM-Instanzen.

Das wars! Sie haben das Lab erfolgreich abgeschlossen.

Sie haben Ihre Website in der Compute Engine bereitgestellt, skaliert und aktualisiert. Sie sind jetzt mit der Compute Engine, verwalteten Instanzgruppen, Load Balancern und Systemdiagnosen vertraut.

Weitere Informationen

• Automatische Reparatur und Systemdiagnosen in verwalteten Instanzgruppen

• Video zu Fallstudie: Skalierbare Webanwendungen in Google Cloud

Google Cloud-Schulungen und -Zertifizierungen

In unseren Schulungen erfahren Sie alles zum optimalen Einsatz unserer Google Cloud-Technologien und können sich entsprechend zertifizieren lassen. Unsere Kurse vermitteln technische Fähigkeiten und Best Practices, damit Sie möglichst schnell mit Google Cloud loslegen und Ihr Wissen fortlaufend erweitern können. Wir bieten On-Demand-, Präsenz- und virtuelle Schulungen für Anfänger wie Fortgeschrittene an, die Sie individuell in Ihrem eigenen Zeitplan absolvieren können. Mit unseren Zertifizierungen weisen Sie nach, dass Sie Experte im Bereich Google Cloud-Technologien sind.

Anleitung zuletzt am 25. August 2025 aktualisiert

Lab zuletzt am 25. August 2025 getestet

© 2025 Google LLC. Alle Rechte vorbehalten. Google und das Google-Logo sind Marken von Google LLC. Alle anderen Unternehmens- und Produktnamen können Marken der jeweils mit ihnen verbundenen Unternehmen sein.