Diese Seite wurde von der Cloud Translation API übersetzt.

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 unterschiedliche Funktionen und Kontrollebenen bietet. Compute Engine bietet ein tiefes Maß an Kontrolle über die Infrastruktur, die zum Ausführen einer Website verwendet wird, erfordert jedoch im Vergleich zu Lösungen wie Google Kubernetes Engine, App Engine oder anderen etwas mehr operatives Management. Mit Compute Engine haben Sie die fein abgestufte Kontrolle über alle Aspekte der Infrastruktur, einschließlich der virtuellen Maschinen, des Load-Balancers und mehr. Heute stellen Sie eine Beispiel-App – die E-Commerce-Website des Fancy Store – bereit, um zu zeigen, wie eine Website mit Compute Engine einfach 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, um automatische Reparatur, Load-Balancing, Autoscaling und Rolling Updates für Ihre Website bereitzustellen.

Vorbereitung

Einführende Übersicht über die Konzepte, 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

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.

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 in diesem Codelab später als PROJECT_ID bezeichnet.

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

Dieses Codelab sollte möglichst wenig kosten. Folgen Sie der Anleitung im Abschnitt „Bereinigen“, . Hier erfahren Sie, wie Sie Ressourcen herunterfahren, damit Ihnen über dieses Tutorial hinaus keine Kosten entstehen. Neue Google Cloud-Nutzer haben Anspruch auf eine kostenlose Testversion mit 300$Guthaben.

Compute Engine API aktivieren

Als Nächstes müssen Sie die Compute Engine API aktivieren. Wenn Sie eine API aktivieren, müssen Sie die Nutzungsbedingungen und Abrechnungspflichten 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

Sie können Google Cloud zwar von Ihrem Laptop aus der Ferne bedienen, in diesem Codelab verwenden Sie jedoch Cloud Shell, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.

Diese Debian-basierte virtuelle Maschine verfügt über alle erforderlichen Entwicklungstools. Es bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und wird in Google Cloud ausgeführt. Dadurch werden die Netzwerkleistung und die Authentifizierung erheblich verbessert. Für dieses Codelab benötigen Sie also nur einen Browser – ja, er funktioniert auf Chromebooks.

Klicken Sie einfach auf Cloud Shell aktivieren , um Cloud Shell über die Cloud Console zu aktivieren. Die Bereitstellung und Verbindung mit der Umgebung dauert einen Moment.

Screen Shot 2017-06-14 at 10.13.43 PM.png

Sobald Sie mit Cloud Shell verbunden sind, sollten Sie sehen, dass Sie bereits authentifiziert sind und dass das Projekt bereits auf Ihre PROJECT_ID eingestellt ist.

gcloud auth list

Befehlsausgabe

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

gcloud config list project

Befehlsausgabe

[core]
project = <PROJECT_ID>

Sollte das Projekt aus irgendeinem Grund nicht eingerichtet sein, geben Sie einfach den folgenden Befehl ein:

gcloud config set project <PROJECT_ID>

Du suchst dein Gerät (PROJECT_ID)? Sehen Sie nach, welche ID Sie bei den Einrichtungsschritten verwendet haben, oder rufen Sie sie im Dashboard der Cloud Console auf:

Cloud Shell legt außerdem standardmäßig einige Umgebungsvariablen fest, die bei der Ausführung zukünftiger Befehle nützlich sein können.

echo $GOOGLE_CLOUD_PROJECT

Befehlsausgabe

<PROJECT_ID>

Legen Sie schließlich 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.

Cloud Storage-Bucket erstellen

Wir verwenden einen Cloud Storage-Bucket, um unseren erstellten Code und unsere Startskripts unterzubringen. 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

3. Quell-Repository klonen

Sie verwenden die vorhandene E-Commerce-Website von Fancy Store, die auf dem Repository „monolith-to-microservices“ basiert, als Grundlage für Ihre Website. Dabei klonen Sie 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 des Codes durch, um zu demonstrieren, wie einfach die Aktualisierung in Compute Engine ist.

Über den folgenden Link können Sie das Code-Repository automatisch in das Projekt klonen und 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 in der Cloud Shell-Eingabeaufforderung den ersten Build des Codes aus, damit die Anwendung lokal ausgeführt werden kann. Es kann einige Minuten dauern, bis das Skript ausgeführt wird.

./setup.sh

Gehen Sie mit der Due-Diligence-Prüfung vor und testen Sie Ihre App. 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!

Sehen Sie sich eine Vorschau Ihrer App an, indem Sie auf das Symbol für die Webvorschau klicken und „Vorschau auf Port 8080“ auswählen.

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

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

4. Compute Engine-Instanzen erstellen

Da Sie nun über Ihre funktionierende Entwicklungsumgebung verfügen, können Sie einige Compute Engine-Instanzen bereitstellen. In den folgenden Schritten führen Sie folgende Schritte aus:

Erstellen Sie ein Startskript, das Instanzen konfigurieren soll.
Klonen Sie den Quellcode und laden Sie ihn in Cloud Storage hoch.
Stellen Sie eine Compute Engine-Instanz bereit, die die Backend-Mikrodienste hosten soll.
Konfigurieren Sie den Frontend-Code neu, sodass die Instanz der Backend-Mikrodienste verwendet wird.
Stellen Sie eine Compute Engine-Instanz bereit, die den Frontend-Mikrodienst hosten soll.
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.

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

Rufen Sie den Ordner „monolith-to-microservices“ auf. Klicken Sie auf Datei > Neue Datei und erstellen Sie eine Datei namens startup-script.sh.

Fügen Sie den folgenden Code in die neue Datei ein. Einige davon werden Sie nach dem Einfügen noch 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 den 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 in etwa so aussehen:

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

Das Startskript führt die folgenden Aktionen aus:

Installation des Logging-Agents, der automatisch Logs aus Syslog erfasst
Installation von Node.js und Supervisor, wodurch die Anwendung als Daemon ausgeführt wird
Klonen des Quellcodes der Anwendung aus dem Cloud Storage-Bucket und Installation von Abhängigkeiten
Konfiguration von Supervisor, mit der die Anwendung ausgeführt wird. Sie sorgt dafür, dass die Anwendung neu gestartet wird, wenn sie unerwartet beendet oder von einem Administrator oder Prozess angehalten wird, und sendet die Werte stdout und stderr der Anwendung an syslog, damit der Logging-Agent Daten erfassen kann.

Kopieren Sie jetzt 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 zugänglich. [BUCKET_NAME] steht für den Namen des Cloud Storage-Buckets. Sie ist standardmäßig nur für autorisierte Nutzer und Dienstkonten sichtbar und kann nicht über einen Webbrowser aufgerufen werden. Compute Engine-Instanzen können automatisch über ihre Dienstkonten darauf zugreifen.

Code in den Cloud Storage-Bucket kopieren

Beim Start von Instanzen wird Code aus dem Cloud Storage-Bucket abgerufen, sodass Sie einige Konfigurationsvariablen in der Datei ".env" speichern können. -Datei des Codes.

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/

Back-End-Instanz bereitstellen

Die erste Instanz, die Sie bereitstellen, ist die Back-End-Instanz, die die Mikrodienste für Bestellungen und Produkte enthält.

Führen Sie in Cloud Shell den folgenden Befehl aus, um eine f1-micro-Instanz zu erstellen, die so konfiguriert ist, dass sie Ihr zuvor erstelltes Startskript verwendet und als Back-End-Instanz getaggt ist. So können Sie später bestimmte Firewallregeln darauf anwenden:

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

Verbindung zum Backend konfigurieren

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

Rufen Sie die externe IP-Adresse des Back-Ends ab, die über den folgenden Befehl auf dem Tab EXTERNAL_IP für die Back-End-Instanz angezeigt werden kann:

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

Gehen Sie im Codeeditor von Cloud Shell zum Ordner monolith-to-microservices. react-app an. Wählen Sie im Menü des Code-Editors View > Aktivieren Sie die Option „Ausgeblendete Dateien“, um die .env-Datei zu sehen.

Bearbeiten Sie die .env-Datei so, dass sie auf die externe IP-Adresse des Back-Ends verweist. [BACKEND_ADDRESS] unten steht für die externe IP-Adresse der Back-End-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 die Funktion „reserve-app“ neu zu erstellen. Dadurch wird der Front-End-Code aktualisiert:

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

Kopieren Sie 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/

Front-End-Instanz bereitstellen

Nachdem der Code nun konfiguriert ist, können Sie die Front-End-Instanz bereitstellen. Führen Sie den folgenden Befehl aus, um die Front-End-Instanz mit einem ähnlichen Befehl wie zuvor bereitzustellen. Diese Instanz hat jedoch das Tag "frontend". für Firewall-Zwecke.

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

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 gewähren. Die Firewallbefehle verwenden die Tags, die bei 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. Bestimmen Sie die externe IP-Adresse des Front-Ends. Sie können die Adresse ermitteln, indem Sie nach der EXTERNAL_IP der Front-End-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 den folgenden Befehl aus, um die Bereitschaft der Anwendung zu überwachen:

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

Sobald die Ausgabe in etwa so aussieht, sollte die Website bereit sein. Drücken Sie bei der Eingabeaufforderung die Taste Control+C (Command+C auf einem Macintosh), um den Smartwatch-Befehl abzubrechen.

Rufen Sie mit einem neuen Webbrowser-Tab http://[FRONTEND_ADDRESS]:8080 auf, um auf die Website zuzugreifen, wobei [FRONTEND_ADDRESS] die oben ermittelte EXTERNAL_IP ist.

Versuchen Sie, die Seiten „Produkte“ und „Bestellungen“ aufzurufen. Diese Seiten sollten ebenfalls funktionieren.

5. Verwaltete Instanzgruppen erstellen

Damit Ihre Anwendung skaliert werden kann, werden verwaltete Instanzgruppen erstellt, die die frontend- und backend-Instanzen als Instanzvorlagen verwenden.

Eine verwaltete Instanzgruppe enthält identische Instanzen, die Sie als eine 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 verwenden verwaltete Instanzgruppen für Ihre Frontend- und Backend-Instanzen, um automatische Reparatur, Load-Balancing, Autoscaling und Rolling Updates bereitzustellen.

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 beim Erstellen 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.

Verwenden Sie zum Erstellen der Instanzvorlage die von Ihnen erstellten Instanzen.

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 den Start jeweils zwei Instanzen in jeder Gruppe konfiguriert. Die Instanzen werden automatisch anhand von „base-instance-name“ benannt durch Zufallszeichen ersetzt 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

Bei Ihrer Anwendung wird der Front-End-Mikrodienst auf Port 8080 und die Back-End-Mikrodienste auf Port 8081 für Bestellungen und Port 8082 für Produkte ausgeführt. Da es sich hierbei um Nichtstandard-Ports handelt, geben Sie benannte Ports an, um sie zu identifizieren. 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

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

Eine Richtlinie für die automatische Reparatur stützt sich auf eine anwendungsbasierte Systemdiagnose, um zu prüfen, ob eine Anwendung wie erwartet reagiert. Die Überprüfung, ob eine Anwendung antwortet, ist genauer als die Überprüfung, ob eine Instanz den Status RUNNING hat (Standardverhalten).

Erstellen Sie eine Systemdiagnose, die die Instanz repariert, wenn sie dreimal hintereinander für das Frontend und Backend als fehlerhaft zurückgegeben wird:

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 über die Ports 8080 und 8081 eine Verbindung zu den Mikrodiensten 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

Fahren Sie mit dem Codelab fort, um der automatischen Reparatur etwas Zeit zu geben, um die Instanzen in der Gruppe zu überwachen. Später simulieren Sie beim Testen der automatischen Reparatur einen Fehler.

6. Load-Balancer erstellen

Zur Ergänzung unserer verwalteten Instanzgruppen verwenden Sie HTTP(S)-Load-Balancing, um Traffic an die Frontend- und Backend-Mikrodienste bereitzustellen, und Zuordnungen, um Traffic basierend auf Pfadregeln an die richtigen Backend-Dienste zu senden. Dadurch wird für alle Dienste eine einzelne IP-Adresse mit Load-Balancing verfügbar gemacht.

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

HTTP(S)-Load-Balancing erstellen

Google Cloud bietet viele verschiedene Arten von Load-Balancing. Für Ihren Traffic wird jedoch HTTP(S)-Load-Balancing verwendet. Das HTTP(S)-Load-Balancing ist so aufgebaut:

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

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

Erstellen Sie Backend-Dienste, die das Ziel für Traffic mit Load Balancing sind. Die Back-End-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 können.

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

Da Sie nun über eine neue statische IP-Adresse verfügen, müssen Sie den Code im Frontend aktualisieren, sodass er auf die neue Adresse anstatt auf die zuvor verwendete sitzungsspezifische Adresse verweist, die auf die backend-Instanz verweist.

Wechseln Sie in Cloud Shell in den Ordner „ret-app“, der die .env-Datei mit der Konfiguration enthält.

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), sodass sie auf die öffentliche IP-Adresse des Load-Balancers verweist. [LB_IP] ist die externe IP-Adresse der Back-End-Instanz.

REACT_APP_ORDERS_URL=http://[LB_IP]/api/orders
REACT_APP_PRODUCTS_URL=http://[LB_IP]/api/products

Rebuild-app neu erstellen, wodurch der Front-End-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

Nun sollen die Front-End-Instanzen in der verwalteten Instanzgruppe den neuen Code abrufen. Ihre Instanzen rufen den Code beim Start ab, sodass Sie einen Befehl für einen rollierenden Neustart ausführen können.

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

Website testen

Warten Sie nach Ausführung des Befehls rolling-action reset etwa 30 Sekunden, 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

Wenn Elemente in der Liste angezeigt werden, beende den Befehl zur Überwachung, indem du Control+C (Command+C auf Macintosh) drückst.

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 Elemente in der Liste angezeigt werden, beenden Sie den watch-Befehl, indem Sie Control+C (Command+C auf Macintosh) drücken.

Die Anwendung ist dann über http://[LB_IP] zugänglich, wobei [LB_IP] die für das Lastenausgleichsmodul 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. Die Konfiguration ist voll funktionsfähig, aber eine statische Konfiguration unabhängig von der Last. Jetzt erstellen Sie eine auf der Auslastung basierende Autoscaling-Richtlinie, 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. Er erstellt ein Autoscaling für die verwalteten Instanzgruppen, das automatisch Instanzen hinzufügt, wenn der Load-Balancer eine Auslastung von mehr als 60% hat, und Instanzen entfernt, wenn der Load-Balancer eine Auslastung von weniger als 60% hat.

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 bei der Skalierung hilfreich sein kann, besteht darin, Cloud CDN – einen Content Delivery Network-Dienst – zu aktivieren, um Caching für den Front-End-Dienst bereitzustellen. Dazu können Sie den folgenden Befehl in Ihrem Front-End-Dienst ausführen:

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 Front-End eine im Cache gespeicherte Antwort findet, wird die im Cache gespeicherte Antwort an den Nutzer gesendet. Das nennt man Cache-Treffer.

Wenn das Front-End keine im Cache gespeicherte Antwort für die Anfrage finden kann, wird die Anfrage direkt an das Back-End gesendet. Wenn die Antwort auf diese Anfrage im Cache speicherbar ist, speichert das Frontend die Antwort im Cloud CDN-Cache, sodass der Cache für nachfolgende Anfragen verwendet 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 Startskript erfolgt, müssen Sie die Instanzvorlage nur ändern, wenn Sie das Kern-Image der Vorlageneinstellungen ändern möchten. Jetzt nehmen Sie eine einfache Änderung vor, um einen größeren Maschinentyp zu verwenden, und verteilen diesen.

Aktualisieren Sie die Front-End-Instanz, die als Grundlage für die Instanzvorlage dient. Während des Updates fügen Sie eine Datei in die aktualisierte Version des Images der Instanzvorlage ein, aktualisieren dann die Instanzvorlage, stellen die neue Vorlage bereit und bestätigen, dass die Datei in den Instanzen der verwalteten Instanzgruppe vorhanden ist.

Sie ändern den Maschinentyp Ihrer Instanzvorlage, indem Sie vom Standardmaschinentyp f1-micro zu einem benutzerdefinierten Maschinentyp mit 4 vCPUs und 3.840 MiB RAM wechseln.

Ändern Sie in Cloud Shell den folgenden Befehl, 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 sich mehr als eine Instanz im Status RUNNING und ACTION auf None gesetzt und INSTANCE_TEMPLATE als neuer Vorlagenname (fancy-fe-new) festgelegt hat, kopieren Sie den Namen einer der Maschinen, die im nächsten Befehl verwendet werden.

Control+S (Command+S auf Macintosh), um den Wiedergabeprozess 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 hat Sie gebeten, die Startseite Ihrer Website zu ändern. Sie sollte mehr Informationen über das Unternehmen selbst und dessen Produkte enthalten. In diesem Abschnitt fügen Sie der Startseite Text hinzu, um die Zufriedenheit des Marketingteams zu steigern. Offenbar hat einer Ihrer Entwickler die Änderungen bereits unter dem Dateinamen „index.js.new“ erstellt. Sie können die Datei in die Datei „index.js“ kopieren. Ihre Änderungen sollten dann übernommen werden. Gehen Sie wie unten beschrieben vor, um die entsprechenden Änderungen vorzunehmen.

Führen Sie die folgenden Befehle aus, kopieren Sie die aktualisierte Datei in den richtigen Dateinamen und geben Sie dann den Inhalt aus, 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

Übertragen Sie den Code dann noch einmal per Push in Ihren Cloud Storage-Bucket.

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

Änderungen mit Rolling Updates übertragen

Sie können jetzt einen Neustart aller Instanzen erzwingen, um das Update abzurufen.

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

Warten Sie ca. 30 Sekunden, nachdem der Befehl für den Neustart der Rolling-Aktion ausgegeben 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 die Elemente in der Liste angezeigt werden, beenden Sie den Befehl zur Überwachung, indem Sie Control+S (Command+S auf Macintosh) drücken.

Führen Sie den folgenden Befehl aus, um zu prüfen, ob der Dienst als healthy gelistet ist:

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

Wenn Elemente in der Liste angezeigt werden, beende den Befehl zur Überwachung, indem du Control+S (Command+S auf Macintosh) drückst.

Führen Sie folgenden Befehl aus, um die im Cache gespeicherten Inhalte im Content Delivery Network zu entwerten und sicherzustellen, dass neue Inhalte angezeigt werden:

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

Rufen Sie die Website über http://[LB_IP] auf, wobei [LB_IP] die für das Lastenausgleichsmodul 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 bestätigen, dass die Systemdiagnose funktioniert, melden Sie sich bei einer Instanz an und beenden Sie die Dienste. Führen Sie den folgenden Befehl aus, um einen Instanznamen zu finden:

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

Sichern Sie von dort aus eine Shell-Verbindung zu einer der Instanzen, wobei INSTANCE_NAME eine der Instanzen aus der Liste ist:

gcloud compute ssh [INSTANCE_NAME]

Beenden Sie in der Instanz die Anwendung 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

Sobald die Reparatur erkannt wurde, Control+C (Command+S auf Macintosh), um den Smartwatch-Befehl zu beenden. An dieser Stelle wird die Instanz von der verwalteten Instanzgruppe neu erstellt, um sie zu reparieren.

9. Bereinigen

Wenn Sie fertig sind, können Sie alle ausgeführten Aktivitäten am einfachsten durch Löschen des Projekts bereinigen. 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. Dadurch wird sichergestellt, dass keine unerwarteten wiederkehrenden 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 durch Eingabe von „Y“ wenn Sie dazu aufgefordert werden.

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.