Webanwendung mit Compute Engine in Google Cloud hosten und skalieren

1. Einführung

Es gibt viele Möglichkeiten, Websites in Google Cloud bereitzustellen, wobei jede Lösung verschiedene Funktionen und Kontrollebenen bietet. Compute Engine bietet eine tiefgreifende Kontrolle über die Infrastruktur, mit der eine Website ausgeführt wird, erfordert aber etwas mehr Verwaltungsaufwand im Vergleich zu Lösungen wie z. B. der Google Kubernetes Engine und der App Engine. Mit Compute Engine haben Sie detailgenaue Kontrolle über die Infrastruktur, einschließlich der virtuellen Maschinen und Load-Balancer. Heute 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

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

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

Vorbereitung

• Einführende Übersichten zu den Konzepten, die wir in diesem Lab verwenden, finden Sie unten:
• Willkommen bei der Google Cloud Platform – Grundlagen der GCP
• Erste Schritte mit Google Cloud Compute Engine
• Erste Schritte mit Google Cloud Storage
• Erste Schritte: Cloud Shell

2. Umgebung einrichten

Umgebung zum selbstbestimmten Lernen einrichten

1. Melden Sie sich in der Cloud Console an und erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes Projekt. Wenn Sie noch kein Gmail- oder Google Workspace-Konto haben, müssen Sie eines erstellen.

Hinweis:Sie können ganz einfach auf die Cloud Console zugreifen, wenn Sie sich die URL console.cloud.google.com merken.

Notieren Sie sich die Projekt-ID, also den projektübergreifend nur einmal vorkommenden Namen eines Google Cloud-Projekts. Der oben angegebene Name ist bereits vergeben und kann leider nicht mehr verwendet werden. Sie wird später in diesem Codelab als PROJECT_ID bezeichnet.

Hinweis:Wenn Sie ein Gmail-Konto verwenden, können Sie den Standardspeicherort auf Keine Organisation belassen. Wenn Sie ein Google Workspace-Konto verwenden, wählen Sie einen Standort aus, der für Ihre Organisation sinnvoll ist.

2. Als Nächstes müssen Sie die Abrechnung in der Cloud Console aktivieren, um Google Cloud-Ressourcen verwenden zu können.

Die Durchführung dieses Codelabs sollte keine oder nur geringe Kosten verursachen. Folgen Sie bitte der Anleitung im Abschnitt „Bereinigen“, in der Sie erfahren, wie Sie Ressourcen herunterfahren können, damit nach Abschluss dieser Anleitung keine Gebühren anfallen. Neue Nutzer von Google Cloud kommen für das Programm für kostenlose Testversionen mit einem Guthaben von 300$ infrage.

Hinweis:Es ist wichtig, ein neues Projekt zu erstellen und kein vorhandenes wiederzuverwenden, da Sie das Projekt löschen, um alle im Codelab ausgeführten Aktivitäten zu bereinigen.

Compute Engine API aktivieren

Als Nächstes müssen Sie die Compute Engine API aktivieren. Zum Aktivieren einer API müssen Sie auch die Nutzungsbedingungen und die Zuständigkeit für die Abrechnung für die API akzeptieren.

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

gcloud services enable compute.googleapis.com

Cloud Shell

Während Sie Google Cloud von Ihrem Laptop aus per Fernzugriff nutzen können, wird in diesem Codelab Cloud Shell verwendet, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.

Diese Debian-basierte virtuelle Maschine verfügt über alle Entwicklungstools, die Sie benötigen. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft in Google Cloud, was die Netzwerkleistung und Authentifizierung erheblich verbessert. Für dieses Codelab benötigen Sie also nur einen Browser (es funktioniert auch auf einem Chromebook).

1. Klicken Sie zum Aktivieren von Cloud Shell in der Cloud Console einfach auf Cloud Shell aktivieren . Die Bereitstellung und Verbindung mit der Umgebung sollte nur wenige Augenblicke dauern.

Sobald die Verbindung mit der Cloud Shell hergestellt ist, sehen Sie, dass Sie bereits authentifiziert sind und für das Projekt schon Ihre PROJECT_ID eingestellt ist.

gcloud auth list

Befehlsausgabe

Credentialed accounts:
 - <myaccount>@<mydomain>.com (active)

Hinweis:Das gcloud-Befehlszeilentool ist in Cloud Shell vorinstalliert und unterstützt die Tab-Vervollständigung. Weitere Informationen finden Sie in der Übersicht über das gcloud-Befehlszeilentool.

gcloud config list project

Befehlsausgabe

[core]
project = <PROJECT_ID>

Wenn das Projekt aus irgendeinem Grund nicht festgelegt ist, führen Sie einfach den folgenden Befehl aus:

gcloud config set project <PROJECT_ID>

Suchst du nach deinem PROJECT_ID? Sehen Sie nach, welche ID Sie in den Einrichtungsschritten verwendet haben, oder suchen Sie sie im Cloud Console-Dashboard:

In Cloud Shell werden auch einige Umgebungsvariablen standardmäßig festgelegt, die für zukünftige Befehle nützlich sein können.

echo $GOOGLE_CLOUD_PROJECT

Befehlsausgabe

<PROJECT_ID>

2. Legen Sie zum Schluss die Standardzone und die Projektkonfiguration fest.

gcloud config set compute/zone us-central1-f

Sie können verschiedene Zonen auswählen. Weitere Informationen finden Sie unter Regionen und Zonen.

Hinweis:Wenn Sie gcloud auf Ihrem eigenen Computer ausführen, werden die Konfigurationseinstellungen sitzungsübergreifend beibehalten. In Cloud Shell müssen Sie sie für jede neue Sitzung oder Verbindung festlegen.

Cloud Storage-Bucket erstellen

Wir 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:Sie verwenden die Umgebungsvariable $DEVSHELL_PROJECT_ID in Cloud Shell, um sicherzustellen, dass die Namen der Objekte eindeutig sind. Da alle Google Cloud-Projekt-IDs eindeutig sein müssen, sollten andere Namen durch das Anhängen der ID ebenfalls eindeutig werden.

3. Quell-Repository klonen

Sie verwenden die bereits bestehende E‑Commerce-Website „Fancy Store“, die auf dem Repository „monolith-to-microservices“ basiert, als Grundlage für Ihre Website. Sie klonen den Quellcode aus Ihrem Repository, damit Sie sich auf die Bereitstellung in Compute Engine konzentrieren können. Später führen Sie eine kleine Aktualisierung an diesem Code durch, um zu sehen, wie einfach das in Compute Engine ist.

Über den folgenden Link können Sie das Code-Repository automatisch in das Projekt klonen sowie Cloud Shell und den integrierten Code-Editor öffnen: In Cloud Shell öffnen.

Alternativ können Sie das Repository mit den folgenden Befehlen in Cloud Shell manuell klonen:

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

Führen Sie an der Cloud Shell-Eingabeaufforderung den ursprünglichen Build des Codes aus, damit die App lokal ausgeführt werden kann. Die Ausführung des Skripts kann einige Minuten dauern.

./setup.sh

Testen Sie Ihre App sorgfältig. Führen Sie den folgenden Befehl aus, um den Webserver zu starten:

cd microservices
npm start

Ausgabe:

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

Rufen Sie eine Vorschau Ihrer App auf. Klicken Sie dazu auf das Webvorschau-Symbol und wählen Sie „Vorschau auf Port 8080“ aus.

Dadurch sollte ein neues Fenster geöffnet werden, in dem Sie das Frontend von Fancy Store in Aktion sehen können.

Sie können dieses Fenster schließen, nachdem Sie sich die Website angesehen haben. Drücken Sie im Terminalfenster Control+C (Command+C auf Macintosh), um den Webserverprozess zu beenden.

Hinweis:In der Vorschau können Sie das Frontend sehen. Die Funktionen „Products“ und „Orders“ funktionieren jedoch nicht, weil diese Dienste in dieser Methode noch nicht verfügbar sind.

4. Compute Engine-Instanzen erstellen

Sie haben nun eine funktionsfähige Entwicklungsumgebung. Jetzt können Sie einige Compute Engine-Instanzen bereitstellen. In den folgenden Schritten gehen Sie so vor:

1. Erstellen Sie ein Startskript, 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.

Startskript erstellen

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

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

Öffnen Sie den Ordner „monolith-to-microservices“. Klicken Sie auf Datei > Neue Datei und erstellen Sie eine Datei mit dem Namen startup-script.sh.

Fügen Sie in die neue Datei den folgenden Code ein. Einen Teil davon werden Sie nach dem Einfügen 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/v8.12.0/node-v8.12.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

Suchen Sie nun im Code-Editor nach dem Text [DEVSHELL_PROJECT_ID] und ersetzen Sie ihn durch die Ausgabe des folgenden Befehls:

echo $DEVSHELL_PROJECT_ID

Beispielausgabe:

my-gce-codelab-253520

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

gs://fancy-store-my-gce-codelab-253520/monolith-to-microservices/microservices/* /fancy-store/

Hinweis:Wenn Sie den Code-Editor in Cloud Shell verwenden, muss das Zeilenende auf „LF“ und nicht auf „CRLF“ gesetzt sein. Sehen Sie dazu unten rechts im Code-Editor nach:

Wenn die Auswahl „CRLF“ lautet, klicken Sie auf „CRLF“ und wählen Sie dann im Drop-down „LF“ aus.

Das Startskript führt die folgenden Aktionen aus:

• Installation des Logging-Agents, der automatisch Logs aus syslog erfasst
• Installation von Node.js und Supervisor, der die App als Daemon ausführt
• Klonen des Quellcodes der App aus dem Cloud Storage-Bucket und Installation von Abhängigkeiten
• Konfiguration von Supervisor, der die App ausführt, sorgt dafür, dass die App neu gestartet wird, wenn sie unerwartet beendet oder von einem Administrator oder Prozess gestoppt wird, und sendet „stdout“ und „stderr“ der App an „syslog“, damit sie vom Logging-Agenten erfasst werden.

Kopieren Sie nun die erstellte Datei „startup-script.sh“ in den zuvor erstellten Cloud Storage-Bucket:

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 ihre Dienstkonten automatisch darauf zugreifen.

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 Datei „.env“ 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.

Kopieren Sie den geklonten Code 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/

Hinweis:Löschen Sie die Abhängigkeitsverzeichnisse „node_modules“, damit der Code so schnell und effizient wie möglich ausgeführt wird. Sie werden beim Start der Instanzen neu erstellt.

Back-End-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 in Cloud Shell aus, um eine f1-micro-Instanz zu erstellen, die so konfiguriert ist, dass sie das zuvor erstellte Startskript verwendet. Die Instanz wird als Backend-Instanz getaggt, sodass Sie später spezielle Firewallregeln darauf anwenden können:

gcloud compute instances create backend \
    --machine-type=f1-micro \
    --image=debian-9-stretch-v20190905 \
    --image-project=debian-cloud \
    --tags=backend \
    --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-$DEVSHELL_PROJECT_ID/startup-script.sh

Hinweis: Wenn die Compute Engine API in den vorherigen Schritten nicht aktiviert wurde, werden Sie vom gcloud-Befehlszeilentool gefragt: „Möchten Sie die API aktivieren und den Vorgang wiederholen? Das kann einige Minuten dauern.“ Wählen Sie „y“ aus, um die Compute Engine API zu aktivieren.

Hinweis:Wenn Sie aufgefordert werden, eine Zone anzugeben, muss gewährleistet sein, dass im Abschnitt zur Einrichtung der Umgebung eine Standardzone konfiguriert wurde.

Verbindung zum Back-End konfigurieren

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

Rufen Sie die externe IP-Adresse des Backends ab. Sie können sie mit dem folgenden Befehl auf dem Tab EXTERNAL_IP für die Backend-Instanz aufrufen:

gcloud compute instances list

Beispielausgabe:

NAME     ZONE           MACHINE_TYPE  PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP   STATUS
backend  us-central1-a  f1-micro                   10.128.0.2   34.68.223.88  RUNNING

Öffnen Sie im Code-Editor von Cloud Shell den Ordner monolith-to-microservices > react-app. Wählen Sie im Menü des Code-Editors Ansicht > Versteckte Dateien umschalten aus, um die Datei .env zu sehen.

Bearbeiten Sie die .env-Datei so, dass auf die externe IP-Adresse des Backends verwiesen wird. [BACKEND_ADDRESS] unten ist die externe IP-Adresse der Backend-Instanz, die mit dem vorherigen Befehl im gcloud-Tool ermittelt wurde.

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

Speichern Sie die Datei.

Verwenden Sie den folgenden Befehl, um „react-app“ neu zu erstellen. Dadurch wird der Frontend-Code aktualisiert:

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

Kopieren Sie den App-Code 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, 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 jedoch mit dem Tag „frontend“ versehen, um damit später Firewallregeln erstellen zu können.

gcloud compute instances create frontend \
    --machine-type=f1-micro \
    --image=debian-9-stretch-v20190905 \
    --image-project=debian-cloud \
    --tags=frontend \
    --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-$DEVSHELL_PROJECT_ID/startup-script.sh 

Hinweis:Sie verwenden einen ähnlichen Bereitstellungsbefehl und ein ähnliches Startskript für die Frontend- und Backend-Instanzen. Das dient der Einfachheit und liegt daran, dass der Code so konfiguriert ist, dass standardmäßig alle Mikrodienste gestartet werden. Alle Mikrodienste im Beispiel werden daher sowohl auf dem Frontend als auch auf dem Backend ausgeführt. In einer Produktionsumgebung würden Sie jedoch nur die erforderlichen Mikrodienste auf getrennten Komponenten ausführen.

Netzwerk konfigurieren

Erstellen Sie Firewallregeln, um den Zugriff auf Port 8080 für das Frontend und auf die Ports 8081 und 8082 für das Backend zu erlauben. Die 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 funktionieren. Ermitteln Sie die externe IP-Adresse des Frontends. Die Adresse kann ermittelt werden, indem Sie nach der EXTERNAL_IP der Frontend-Instanz suchen:

gcloud compute instances list

Beispielausgabe:

NAME      ZONE           MACHINE_TYPE  PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP      STATUS
backend   us-central1-a  f1-micro                   10.128.0.2   104.198.235.171  RUNNING
frontend  us-central1-a  f1-micro                   10.128.0.3   34.69.141.9      RUNNING

Es kann einige Minuten dauern, bis die Instanz gestartet und konfiguriert ist. Führen Sie Folgendes aus, um die Bereitschaft der App zu überwachen:

watch -n 5 curl http://[EXTERNAL_IP]:8080 

Sobald Ihre Ausgabe in etwa so aussieht, sollte Ihre Website verfügbar sein. Drücken Sie Control+C (Command+C auf Macintosh) in der Eingabeaufforderung, um den Wiedergabebefehl zu beenden.

Rufen Sie in einem neuen Browsertab http://[FRONTEND_ADDRESS]:8080 auf, um auf die Website zuzugreifen. Dabei ist [FRONTEND_ADDRESS] die oben ermittelte EXTERNAL_IP.

Versuchen Sie, die Seiten „Produkte“ und „Bestellungen“ aufzurufen. Das sollte funktionieren.

Hinweis:Wenn Sie an diesem Punkt aufhören und die Umgebung nicht skalieren, sollten die Instanzen so konfiguriert werden, dass sie statische IP-Adressen verwenden. Sie sollten weiterhin verwaltete Instanzgruppen und einen Load-Balancer erstellen, auch wenn keine hohe Skalierung erforderlich ist, damit Redundanz und automatische Reparatur implementiert werden können.

5. Verwaltete Instanzgruppen erstellen

Damit Ihre 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 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.

Zuerst müssen Sie beide Instanzen beenden.

gcloud compute instances stop frontend

gcloud compute instances stop backend

Erstellen Sie nun die Instanzvorlage aus den Quellinstanzen.

gcloud compute instance-templates create fancy-fe \
    --source-instance=frontend

gcloud compute instance-templates create fancy-be \
    --source-instance=backend

Prüfen Sie, ob die Instanzvorlagen erstellt wurden:

gcloud compute instance-templates list

Beispielausgabe:

NAME      MACHINE_TYPE  PREEMPTIBLE  CREATION_TIMESTAMP
fancy-be  f1-micro                   2019-09-12T07:52:57.544-07:00
fancy-fe  f1-micro                   2019-09-12T07:52:48.238-07:00

Verwaltete Instanzgruppe erstellen

Sie erstellen zwei verwaltete Instanzgruppen, eine für das Frontend und eine für das Backend. Diese verwalteten Instanzgruppen verwenden die zuvor erstellten 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.

gcloud compute instance-groups managed create fancy-fe-mig \
    --base-instance-name fancy-fe \
    --size 2 \
    --template fancy-fe

gcloud compute instance-groups managed create fancy-be-mig \
    --base-instance-name fancy-be \
    --size 2 \
    --template fancy-be

Für Ihre Anwendung wird der Frontend-Mikrodienst an Port 8080 ausgeführt und die Backend-Mikrodienste an Port 8081 für Bestellungen und an Port 8082 für Produkte. Da es sich um keine Standardports handelt, 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 Informationen werden vom Load-Balancer verwendet, den Sie später konfigurieren.

gcloud compute instance-groups set-named-ports fancy-fe-mig \ 
    --named-ports frontend:8080

gcloud compute instance-groups set-named-ports fancy-be-mig \
    --named-ports orders:8081,products:8082

Automatische Reparatur konfigurieren

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

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 den Load Balancer und die automatische Reparatur werden separate Systemdiagnosen verwendet. Systemdiagnosen für den Load-Balancer können und sollten aggressiver sein, da diese Systemdiagnosen festlegen, ob eine Instanz Nutzertraffic empfängt. Nicht reagierende 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 die Systemdiagnose für einen Load Balancer.

Erstellen Sie eine Systemdiagnose, bei der die Instanz repariert wird, wenn die Prüfung dreimal hintereinander für das Frontend und das Backend 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

Erstellen Sie eine Firewallregel, damit die Systemdiagnoseprüfungen eine Verbindung zu den Mikrodiensten an den Ports 8080 und 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

Wenden Sie die Systemdiagnosen auf die entsprechenden Dienste an:

gcloud compute instance-groups managed update fancy-fe-mig \
    --health-check fancy-fe-hc \
    --initial-delay 300

gcloud compute instance-groups managed update fancy-be-mig \
    --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.

Fahren Sie mit dem Codelab fort, da es eine Weile dauert, bis die Instanzen in der Gruppe im Rahmen der automatischen Reparatur überwacht werden. Später simulieren Sie einen Fehler, um die automatische Reparatur zu testen.

6. Load-Balancer erstellen

Um Ihre verwalteten Instanzgruppen zu vervollständigen, verwenden Sie HTTP(S)-Load-Balancing, um Traffic an die Frontend- und Backend-Mikrodienste weiterzuleiten, sowie Zuordnungen, um Traffic an die richtigen Backend-Dienste basierend auf Pfadregeln zu senden. So wird eine einzelne IP-Adresse mit Load-Balancing für alle Dienste verfügbar gemacht.

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

HTTP(S)-Load-Balancing erstellen

Google Cloud bietet viele verschiedene Arten von Load-Balancing, aber für Ihren Traffic verwenden Sie HTTP(S)-Load-Balancing. HTTP(S)-Load-Balancing 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 für die Verwendung einer HTTPS- oder HTTP/2-Systemdiagnose konfiguriert ist, 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:Um die Komplexität von SSL-Zertifikaten zu vermeiden, verwenden Sie HTTP anstelle von HTTPS. Für die Produktion wird empfohlen, nach Möglichkeit HTTPS zur Verschlüsselung zu verwenden.

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:Die Systemdiagnosen sind für den Load-Balancer vorgesehen und handhaben nur die Weiterleitung von Traffic vom Load-Balancer. Sie veranlassen nicht, dass die verwalteten Instanzgruppen Instanzen neu erstellen.

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

Fügen Sie die Back-End-Dienste hinzu.

gcloud compute backend-services add-backend fancy-fe-frontend \
  --instance-group fancy-fe-mig \
  --instance-group-zone us-central1-f \
  --global

gcloud compute backend-services add-backend fancy-be-orders \
  --instance-group fancy-be-mig \
  --instance-group-zone us-central1-f \
  --global

gcloud compute backend-services add-backend fancy-be-products \
  --instance-group fancy-be-mig \
  --instance-group-zone us-central1-f \
  --global

Erstellen Sie eine URL-Zuordnung. Mit der URL-Zuordnung wird angegeben, welche URLs an welche Back-End-Dienste weitergeleitet werden.

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

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"

Erstellen Sie den Proxy, der mit der erstellten URL-Zuordnung verknüpft ist.

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

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

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.

Wechseln Sie in Cloud Shell zum Ordner „react-app“, in dem die Datei „.env“ mit der Konfiguration gespeichert ist.

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

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

gcloud compute forwarding-rules list --global

Beispielausgabe:

NAME                    REGION  IP_ADDRESS     IP_PROTOCOL  TARGET
fancy-http-rule          34.102.237.51  TCP          fancy-proxy

Bearbeiten Sie die .env-Datei mit Ihrem bevorzugten Texteditor (z. B. GNU nano), damit sie auf die öffentliche IP-Adresse des Load Balancers verweist. [LB_IP] ist die 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 die Weiterleitung für Sie übernimmt.

Erstellen Sie „react-app“ neu, wodurch der Frontend-Code aktualisiert wird.

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

Kopieren Sie den Anwendungscode in den GCS-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

Jetzt sollen die Frontend-Instanzen in der verwalteten Instanzgruppe den neuen Code abrufen. Ihre Instanzen rufen den Code beim Start ab. Sie können also einen Befehl für einen rollierenden Neustart ausführen.

gcloud compute instance-groups managed rolling-action restart fancy-fe-mig \
    --max-unavailable 100%

Hinweis:In diesem Beispiel eines rollierenden Neustarts haben Sie explizit mit dem Parameter –max-unavailable angegeben, dass alle Maschinen sofort neu gestartet werden können. Andernfalls würde der Befehl eine Instanz aktiv lassen, während die anderen neu starten. Für Testzwecke geben Sie an, dass alle sofort neu gestartet werden, damit es schneller geht.

Website testen

Warten Sie etwa 30 Sekunden, nachdem der Befehl rolling-action restart ausgeführt wurde, damit die Instanzen verarbeitet werden können. Prüfen Sie dann den Status der verwalteten Instanzgruppe, bis Instanzen in der Liste angezeigt werden.

watch -n 5 gcloud compute instance-groups list-instances fancy-fe-mig

Sobald Elemente in der Liste angezeigt werden, beenden Sie den Watch-Befehl, indem Sie Control+C (Command+C auf Macintosh) drücken.

Prüfen Sie, ob der Dienst als fehlerfrei aufgeführt wird.

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

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

Sobald Instanzen in der Liste angezeigt werden, beenden Sie den watch-Befehl. Drücken Sie dazu Control+C (Command+C auf Macintosh).

Der Zugriff auf die Anwendung ist dann ü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

7. Compute Engine skalieren

Bisher 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, die auf der Auslastung basiert, um jede verwaltete Instanzgruppe automatisch zu skalieren.

Anhand der Auslastung automatisch skalieren

Führen Sie die folgenden Befehle in Cloud Shell aus, um die Autoscaling-Richtlinie zu erstellen. Dabei wird eine Autoscaling-Funktion für verwaltete Instanzgruppen erstellt. Beim Autoscaling werden automatisch Instanzen hinzugefügt, wenn die Auslastung des Load-Balancers bei über 60% liegt, und Instanzen entfernt, wenn der Load-Balancer bei unter 60% Auslastung ist.

gcloud compute instance-groups managed set-autoscaling \
  fancy-fe-mig \
  --max-num-replicas 5 \
  --target-load-balancing-utilization 0.60

gcloud compute instance-groups managed set-autoscaling \
  fancy-be-mig \
  --max-num-replicas 5 \
  --target-load-balancing-utilization 0.60

Content Delivery Network aktivieren

Eine weitere Funktion, die für das Skalieren hilfreich sein kann, ist Cloud CDN, ein CDN-Dienst (Content Delivery Network), der Caching für den Frontend-Dienst ermöglicht. Führen Sie dazu den folgenden Befehl für Ihren Frontend-Dienst aus:

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

Wenn ein Nutzer nun Inhalte vom Load Balancer anfordert, kommt die Anfrage bei einem Google-Frontend an, das zuerst im Cloud CDN-Cache nach einer Antwort auf die Anfrage des Nutzers sucht. Wenn das Frontend eine im Cache gespeicherte Antwort findet, sendet es diese Antwort an den Nutzer. Das wird als Cache-Treffer bezeichnet.

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

8. Website aktualisieren

Instanzvorlage aktualisieren

Vorhandene 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 des Core-Images selbst ändern möchten. Sie nehmen nun eine einfache Änderung vor, indem Sie einen größeren Maschinentyp verwenden, und verteilen sie.

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.

Sie ändern den Maschinentyp Ihrer Instanzvorlage. Ersetzen Sie dazu den Standardmaschinentyp „f1-micro“ durch einen benutzerdefinierten Maschinentyp mit 4 vCPU und 3.840 MiB RAM.

Führen Sie in Cloud Shell den folgenden Befehl aus, um den Maschinentyp der frontend-Instanz zu ändern:

gcloud compute instances set-machine-type frontend --machine-type custom-4-3840

Erstellen Sie die neue Instanzvorlage:

gcloud compute instance-templates create fancy-fe-new \
    --source-instance=frontend \
    --source-instance-zone=us-central1-a

Stellen Sie die aktualisierte Instanzvorlage in der verwalteten Instanzgruppe bereit:

gcloud compute instance-groups managed rolling-action start-update fancy-fe-mig \
    --version template=fancy-fe-new

Überwachen Sie den Status des Updates:

watch -n 2 gcloud compute instance-groups managed list-instances fancy-fe-mig

Sobald Sie mehr als eine Instanz mit dem Status RUNNING haben,ACTION auf None festgelegt ist und INSTANCE_TEMPLATE als neuer Vorlagenname (fancy-fe-new) festgelegt ist, kopieren Sie den Namen einer der aufgeführten Maschinen, um ihn für den nächsten Befehl zu verwenden.

Control+S (Command+S auf Macintosh), um den Beobachtungsvorgang zu beenden.

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

gcloud compute instances describe [VM_NAME] | grep machineType

Erwartete Beispielausgabe:

machineType: https://www.googleapis.com/compute/v1/projects/project-name/zones/us-central1-f/machineTypes/custom-4-3840

Website ändern

Ihr Marketingteam möchte, dass Sie die Startseite für die Website ändern. Sie sollte 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 Ihrer Entwickler die Änderungen bereits unter dem Dateinamen index.js.new erstellt. Sie können die Datei nach index.js kopieren. Die Änderungen sollten dann zu sehen sein. Gehen Sie wie unten beschrieben vor, um die entsprechenden Änderungen vorzunehmen.

Führen Sie die folgenden Befehle aus, um die aktualisierte Datei in den korrekten Dateinamen zu kopieren, und rufen Sie dann deren Inhalt auf, um die Änderungen zu prüfen:

cd ~/monolith-to-microservices/react-app/src/pages/Home
mv index.js.new index.js
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 { makeStyles } from "@material-ui/core/styles";
import Paper from "@material-ui/core/Paper";
import Typography from "@material-ui/core/Typography";
const useStyles = makeStyles(theme => ({
  root: {
    flexGrow: 1
  },
  paper: {
    width: "800px",
    margin: "0 auto",
    padding: theme.spacing(3, 2)
  }
}));
export default function Home() {
  const classes = useStyles();
  return (
    <div className={classes.root}>
      <Paper className={classes.paper}>
        <Typography variant="h5">
          Fancy Fashion &amp; Style Online
        </Typography>
        <br />
        <Typography variant="body1">
          Tired of mainstream fashion ideas, popular trends and societal norms?
          This line of lifestyle products will help you catch up with the Fancy trend and express your personal style.
          Start shopping Fancy items now!
        </Typography>
      </Paper>
    </div>
  );
}

Sie haben die React-Komponenten aktualisiert, müssen aber noch die React-Anwendung erstellen, um die statischen Dateien zu generieren. 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

Laden Sie den Code dann noch einmal in Ihren Cloud Storage-Bucket hoch.

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 Rolling Updates übertragen

Sie können jetzt erzwingen, dass alle Instanzen neu gestartet werden, um das Update abzurufen.

gcloud compute instance-groups managed rolling-action restart fancy-fe-mig \
    --max-unavailable=100%

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

Warten Sie etwa 30 Sekunden, nachdem der Befehl „rolling-action restart“ ausgeführt wurde, damit die Instanzen verarbeitet werden können. Prüfen Sie dann den Status der verwalteten Instanzgruppe, bis Instanzen in der Liste angezeigt werden.

watch -n 5 gcloud compute instance-groups list-instances fancy-fe-mig

Sobald Instanzen in der Liste angezeigt werden, beenden Sie den „watch“-Befehl. Drücken Sie dazu Control+S (Command+S auf Macintosh).

Führen Sie den folgenden Befehl aus, um zu prüfen, ob der Dienst den Status healthy aufweist:

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

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

Sobald Elemente in der Liste angezeigt werden, beenden Sie den Watch-Befehl, indem Sie Control+S (Command+S auf Macintosh) drücken.

Führen Sie den folgenden Befehl aus, um die im Content Delivery Network (CDN) zwischengespeicherten Inhalte zu entwerten und dafür zu sorgen, dass neue Inhalte angezeigt werden:

gcloud compute url-maps invalidate-cdn-cache fancy-map \
    --path "/*"

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

Hinweis:Wenn neue Inhalte nicht angezeigt werden, aktualisieren Sie die Webseite in Google Chrome mit Control+F5 (Command+Shift+R auf Macintosh), damit die im Cache gespeicherten Inhalte noch einmal heruntergeladen werden.

Fehler simulieren

Um zu prüfen, ob die Systemdiagnose funktioniert, melden Sie sich bei einer Instanz an und beenden die Dienste. Führen Sie den folgenden Befehl aus, um einen Instanznamen zu finden:

gcloud compute instance-groups list-instances fancy-fe-mig

Stellen Sie dann eine Secure Shell-Verbindung zu einer der Instanzen her. INSTANCE_NAME ist hierbei eine der Instanzen aus der Liste:

gcloud compute ssh [INSTANCE_NAME]

Beenden Sie die App in der Instanz mit supervisorctl.

sudo supervisorctl stop nodeapp; sudo killall node

Beenden Sie die Instanz.

exit

Überwachen Sie die Reparaturvorgänge.

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

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

Nachdem die Reparatur abgeschlossen ist, drücken Sie Control+C (Command+S auf einem Macintosh), um den Watch-Befehl zu beenden. An diesem Punkt erstellt die verwaltete Instanzgruppe die Instanz neu, um sie zu reparieren.

9. Bereinigen

Wenn Sie fertig sind, können Sie alle ausgeführten Aktivitäten am einfachsten bereinigen, indem Sie das Projekt löschen. Durch das Löschen des Projekts werden der Load-Balancer, die Instanzen, die Vorlagen und weitere Elemente gelöscht, die während des Codelabs erstellt wurden. So wird verhindert, dass unerwartete wiederkehrende Gebühren anfallen. Führen Sie den folgenden Befehl in Cloud Shell aus. Dabei ist PROJECT_ID die vollständige Projekt-ID, nicht nur der Projektname.

gcloud projects delete [PROJECT_ID]

Bestätigen Sie das Löschen, indem Sie „Y“ eingeben, wenn Sie dazu aufgefordert werden.

Wenn Sie sich nicht sicher sind, können Sie die Projekt-ID abrufen, indem Sie gcloud config list | grep project in Cloud Shell ausführen.

10. Glückwunsch!

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