GSP662

Übersicht

Es gibt viele Möglichkeiten, Websites in Google Cloud bereitzustellen. Jede Lösung hat andere Funktionen und Kontrollebenen. Compute Engine bietet eine tief greifende 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. Google Kubernetes Engine (GKE) und App Engine. Mit Compute Engine haben Sie detailgenaue Kontrolle über die Infrastruktur, einschließlich der virtuellen Maschinen und Load-Balancer.

In diesem Lab stellen Sie eine Beispielanwendung bereit (die E-Commerce-Website "Fancy Store") und zeigen, wie eine Website auf einfache Weise mit Compute Engine 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 die Ressourcen für das Lab verfügbar sind.

In diesem praxisorientierten Lab können Sie die Lab-Aktivitäten in einer echten Cloud-Umgebung selbst 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, 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: Wenn Sie über ein persönliches Google Cloud-Konto oder -Projekt verfügen, verwenden Sie es nicht für dieses Lab. So werden zusätzliche Kosten für Ihr Konto vermieden.

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 Pop-up-Fenster 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 sich eine Liste der Google Cloud-Produkte und ‑Dienste ansehen möchten, klicken Sie oben links auf das Navigationsmenü.

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 .

Wenn Sie verbunden sind, sind Sie bereits authentifiziert und das Projekt ist auf Ihre 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.

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

gcloud auth list

3. 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`

4. (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 spezifischer 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 der Cloud Console 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-$DEVSHELL_PROJECT_ID Hinweis: Mithilfe der Umgebungsvariablen $DEVSHELL_PROJECT_ID in Cloud Shell wird sichergestellt, dass die Namen der Objekte eindeutig sind. Da alle Projekt-IDs in Google Cloud eindeutig sein müssen, sollten andere Namen durch das Anhängen der Projekt-ID ebenfalls eindeutig werden.

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

Aufgabe 3: Quell-Repository klonen

Verwenden Sie die bereits bestehende E-Commerce-Website „Fancy Store“, die auf dem Repository monolith-to-microservices basiert, als Grundlage für Ihre Website.

Klonen Sie den Quellcode, damit Sie sich auf das Bereitstellen in der Compute Engine konzentrieren können. Später in diesem Lab führen Sie eine kleine Aktualisierung an diesem Code durch, um aufzuzeigen, wie einfach das in Compute Engine ist.

1. Klonen Sie den Quellcode und rufen Sie dann das Verzeichnis monolith-to-microservices auf:

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 Skript 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 anschließend den folgenden Befehl aus, um die Anwendung zu testen. Dabei wechseln Sie zum Verzeichnis microservices und starten den Webserver:

cd microservices npm start

Es sollte folgende Ausgabe angezeigt werden:

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

5. Rufen Sie eine Vorschau Ihrer Anwendung auf. Klicken Sie dazu auf das Symbol für die Webvorschau und wählen Sie dann 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.

Aufgabe 4: Compute Engine-Instanzen erstellen

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

Diese Schritte sind zu erledigen:

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

Startskript erstellen

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

1. Führen Sie in Cloud Shell 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. Sie werden nach dem Einfügen einen Teil des Codes bearbeiten:

#!/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. Suchen Sie in der Datei den Text [DEVSHELL_PROJECT_ID] und ersetzen Sie ihn durch die Projekt-ID:

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/

6. Speichern Sie die Datei startup-script.sh, aber schließen Sie sie noch nicht.

7. Prüfen Sie rechts unten im Cloud Shell-Code-Editor, ob „End of Line Sequence“ auf „LF“ gesetzt ist und nicht auf „CRLF“.

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

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

9. 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-$DEVSHELL_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 Startskript 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.

1. Kopieren Sie den geklonten Code in Ihren Bucket:

cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_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. Startskript und Code in den Cloud Storage-Bucket kopieren

Backend-Instanz bereitstellen

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

Hinweis: In einer Produktionsumgebung sollten Sie für jeden Mikrodienst eine eigene Instanz und Instanzgruppe einrichten, damit sie unabhängig skaliert werden können. 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=$ZONE \ --machine-type=e2-standard-2 \ --tags=backend \ --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-$DEVSHELL_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 in 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 obigen 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. Kopieren Sie dann den Anwendungscode in den Cloud Storage-Bucket:

cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/

Frontend-Instanz bereitstellen

Nachdem der Code nun konfiguriert ist, stellen Sie die Frontend-Instanz bereit.

• 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=$ZONE \ --machine-type=e2-standard-2 \ --tags=frontend \ --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-$DEVSHELL_PROJECT_ID/startup-script.sh Hinweis: Der Bereitstellungsbefehl und das Startscript werden sowohl bei der Frontend‑ als auch bei der Backend-Instanz verwendet, weil damit der Vorgang vereinfacht wird und 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. Erstellen Sie Firewallregeln, um den Zugriff auf Port 8080 für das Frontend und auf die Ports 8081–8082 für das Backend zu 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 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 können Sie die Hochverfügbarkeit Ihrer Anwendungen aufrechterhalten, 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 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. Beenden Sie zuerst beide Instanzen:

gcloud compute instances stop frontend --zone=$ZONE gcloud compute instances stop backend --zone=$ZONE

2. Erstellen Sie dann die Instanzvorlage aus jeder der Quellinstanzen:

gcloud compute instance-templates create fancy-fe \ --source-instance-zone=$ZONE \ --source-instance=frontend gcloud compute instance-templates create fancy-be \ --source-instance-zone=$ZONE \ --source-instance=backend

3. Prüfen Sie, 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=$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 Instanzgruppe erstellen

1. Erstellen Sie als Nächstes zwei verwaltete Instanzgruppen, eine für das Frontend und eine für das Backend:

gcloud compute instance-groups managed create fancy-fe-mig \ --zone=$ZONE \ --base-instance-name fancy-fe \ --size 2 \ --template fancy-fe gcloud compute instance-groups managed create fancy-be-mig \ --zone=$ZONE \ --base-instance-name fancy-be \ --size 2 \ --template fancy-be

Diese verwalteten Instanzgruppen verwenden die Instanzvorlagen und werden für zwei Instanzen konfiguriert, die jeweils in 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ür Ihre Anwendung wird der frontend-Mikrodienst an Port 8080 ausgeführt und der backend-Mikrodienst an Port 8081 für orders und an Port 8082 für „Products“:

gcloud compute instance-groups set-named-ports fancy-fe-mig \ --zone=$ZONE \ --named-ports frontend:8080 gcloud compute instance-groups set-named-ports fancy-be-mig \ --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, der später konfiguriert wird.

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 Compute Engine fehlerhafte Instanzen proaktiv ersetzt. Sie sollte daher konservativer sein als eine Systemdiagnose für das Load-Balancing.

1. Erstellen Sie eine Systemdiagnose, bei der die Instanz repariert wird, wenn die Prüfung dreimal hintereinander für die frontend- und backend-Instanzen 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. Erstellen Sie eine Firewallregel, damit die Systemdiagnoseprüfungen eine Verbindung zu den Mikrodiensten an den Ports 8080–8081 herstellen können:

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 auf die entsprechenden Dienste an:

gcloud compute instance-groups managed update fancy-fe-mig \ --zone=$ZONE \ --health-check fancy-fe-hc \ --initial-delay 300 gcloud compute instance-groups managed update fancy-be-mig \ --zone=$ZONE \ --health-check fancy-be-hc \ --initial-delay 300 Hinweis: Es kann 15 Minuten dauern, bis das Monitoring von Instanzen in der Gruppe durch die automatische Reparatur 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:

1. Mit einer Weiterleitungsregel werden eingehende Anfragen an einen Ziel-HTTP-Proxy weitergeleitet.
2. 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.
3. Der Backend-Dienst leitet jede Anfrage basierend auf Bereitstellungskapazität, Zone und Instanzstatus der dazugehörigen Backends an das passende Backend weiter. Der Status jeder Backend-Instanz wird mithilfe einer HTTP-Systemdiagnose überprüft. Wenn der Backend-Dienst so konfiguriert ist, dass er eine HTTPS‑ oder HTTP/2-Systemdiagnose verwendet, wird die Anfrage auf dem Weg zur Backend-Instanz verschlüsselt.
4. 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, muss jede Instanz 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. Erstellen Sie Systemdiagnosen, mit denen ermittelt wird, welche Instanzen Traffic für jeden 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. Erstellen Sie Backend-Dienste, 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ügen Sie die Backend-Dienste des Load Balancers hinzu:

gcloud compute backend-services add-backend fancy-fe-frontend \ --instance-group-zone=$ZONE \ --instance-group fancy-fe-mig \ --global gcloud compute backend-services add-backend fancy-be-orders \ --instance-group-zone=$ZONE \ --instance-group fancy-be-mig \ --global gcloud compute backend-services add-backend fancy-be-products \ --instance-group-zone=$ZONE \ --instance-group fancy-be-mig \ --global

4. Erstellen Sie eine URL-Zuordnung. Mit der URL-Zuordnung wird angegeben, welche URLs an welche Backend-Dienste weitergeleitet werden:

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

5. Erstellen Sie einen Pfad-Matcher, 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. Erstellen Sie den Proxy, der mit der URL-Zuordnung verknüpft ist:

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

7. Erstellen Sie eine globale Weiterleitungsregel, 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. Öffnen Sie in Cloud Shell den Ordner react-app, in dem die .env-Datei gespeichert ist, die die Konfiguration enthält:

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

2. Suchen Sie die IP-Adresse für den Load-Balancer:

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. Erstellen Sie react-app neu, wodurch der Frontend-Code aktualisiert wird:

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

6. Kopieren Sie den Anwendungscode in Ihren Bucket:

cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_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 einen Befehl für einen rollierenden Neustart ausführen:

gcloud compute instance-groups managed rolling-action replace fancy-fe-mig \ --zone=$ZONE \ --max-unavailable 100% Hinweis: In diesem Beispiel einer rollierenden 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 aufweisen.

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 Front-End-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 aufweisen, 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 eine statische Konfiguration 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=$ZONE \ --max-num-replicas 2 \ --target-load-balancing-utilization 0.60 gcloud compute instance-groups managed set-autoscaling \ fancy-be-mig \ --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 Content Delivery Network-Dienst, 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

Vorhandene Instanzvorlagen können nicht bearbeitet werden. Da Ihre Instanzen aber zustandslos sind und die gesamte Konfiguration über das Startskript erfolgt, müssen Sie die Instanzvorlage nur ändern, wenn Sie die Vorlageneinstellungen ändern wollen. Sie nehmen nun eine einfache Änderung vor, indem Sie einen größeren Maschinentyp verwenden, und verteilen sie.

Führen Sie folgende Schritte aus:

• Aktualisieren Sie die frontend-Instanz, die als Basis für die Instanzvorlage dient. Bei der Aktualisierung speichern Sie die aktualisierte 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=$ZONE \ --machine-type e2-small

2. Erstellen Sie die neue Instanzvorlage.

gcloud compute instance-templates create fancy-fe-new \ --region=$REGION \ --source-instance=frontend \ --source-instance-zone=$ZONE

3. Stellen Sie die aktualisierte Instanzvorlage in der verwalteten Instanzgruppe bereit:

gcloud compute instance-groups managed rolling-action start-update fancy-fe-mig \ --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=$ZONE

Dies kann einige Augenblicke dauern.

Sobald mindestens eine Instanz folgende Bedingung aufweist:

• STATUS: RUNNING
• ACTION gesetzt auf 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=$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 sollte mehr Informationen über das Unternehmen selbst und dessen Produkte enthalten.

Aufgabe: 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. Gehen Sie wie unten beschrieben vor, um die entsprechenden Änderungen vorzunehmen.

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 Code sollte dann in etwa so aussehen:

/* 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. Laden Sie dann diesen Code wieder in den Bucket:

cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/

Änderungen per Push mit rollierenden Ersetzungen übertragen

1. Erzwingen Sie nun, dass alle Instanzen ersetzt werden, um die Aktualisierung abzurufen:

gcloud compute instance-groups managed rolling-action replace fancy-fe-mig \ --zone=$ZONE \ --max-unavailable=100%

Hinweis: In diesem Beispiel einer rollierenden 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 an 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=$ZONE

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

gcloud compute ssh [INSTANCE_NAME] --zone=$ZONE

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

4. Beenden Sie in der Instanz die Anwendung mit supervisorctl:

sudo supervisorctl stop nodeapp; sudo killall node

5. Beenden Sie die Instanz:

exit

6. Überwachen Sie die Reparaturvorgänge:

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

Das dauert einige Minuten.

Suchen Sie nach der folgenden Beispielausgabe:

NAME TYPE TARGET HTTP_STATUS STATUS TIMESTAMP repair-1568314034627-5925f90ee238d-fe645bf0-7becce15 compute.instances.repair.recreateInstance us-central1-a/instances/fancy-fe-1vqq 200 DONE 2019-09-12T11:47:14.627-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 Ihre Website in Compute Engine bereitgestellt, skaliert und aktualisiert. Sie sind jetzt mit Compute Engine, verwalteten Instanzgruppen, Load Balancern und Systemdiagnosen vertraut.

Weitere Informationen

• Automatische Reparatur und Systemdiagnosen in verwalteten Instanzgruppen

• Video zu Anwendungsfall: 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.

Handbuch zuletzt aktualisiert am 26. April 2024

Lab zuletzt am 15. Dezember 2023 getestet

© 2024 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.