Diese Seite wurde von der Cloud Translation API übersetzt.

InnerLoop-Entwicklung mit Cloud Workstations und NodeJS

1. Übersicht

In diesem Lab werden Funktionen und Möglichkeiten zur Optimierung des Entwicklungsworkflows für Softwareentwickler vorgestellt, die mit der Entwicklung von Node.js-Anwendungen in einer Containerumgebung betraut sind. Bei der typischen Containerentwicklung muss der Nutzer die Details von Containern und den Container-Build-Prozess genau kennen. Außerdem müssen Entwickler in der Regel den Ablauf unterbrechen, um ihre Anwendungen in Remote-Umgebungen zu testen und zu debuggen. Mit den in dieser Anleitung erwähnten Tools und Technologien können Entwickler effektiv mit Containeranwendungen arbeiten, ohne ihre IDE zu verlassen.

Lerninhalte

In diesem Lab lernen Sie Methoden für die Entwicklung mit Containern in Google Cloud kennen, darunter:

Node.js-Startanwendung erstellen
Node.js-Anwendung für die Containerentwicklung konfigurieren
Einen einfachen CRUD Rest Service programmieren
In GKE bereitstellen
Debugging eines Fehlerstatus
Haltepunkt / Logs verwenden
Heiß-Deployment von Änderungen zurück in GKE
Optional: CloudSQL für Back-End-Persistenz einbinden

2. Einrichtung und Anforderungen

Umgebung zum selbstbestimmten Lernen einrichten

Melden Sie sich in der Google 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.

Der Projektname ist der Anzeigename für die Projektteilnehmer. Es handelt sich um eine Zeichenfolge, die von Google APIs nicht verwendet wird. Sie können sie jederzeit aktualisieren.
Die Projekt-ID ist für alle Google Cloud-Projekte eindeutig und unveränderlich. Sie kann nach dem Festlegen nicht mehr geändert werden. Die Cloud Console generiert automatisch einen eindeutigen String. ist Ihnen meist egal, was es ist. In den meisten Codelabs musst du dich auf die Projekt-ID beziehen, die üblicherweise als PROJECT_ID gekennzeichnet ist. Wenn Ihnen die generierte ID nicht gefällt, können Sie eine weitere zufällige ID erstellen. Alternativ können Sie einen eigenen verwenden und nachsehen, ob er verfügbar ist. Sie kann nach diesem Schritt nicht mehr geändert werden und bleibt für die Dauer des Projekts bestehen.
Zur Information gibt es noch einen dritten Wert, die Projektnummer, die von manchen APIs verwendet wird. Weitere Informationen zu allen drei Werten finden Sie in der Dokumentation.

Als Nächstes müssen Sie in der Cloud Console die Abrechnung aktivieren, um Cloud-Ressourcen/APIs verwenden zu können. Dieses Codelab sollte ohne großen Aufwand betrieben werden. Wenn Sie Ressourcen herunterfahren möchten, um über diese Anleitung hinaus keine Kosten zu verursachen, können Sie die von Ihnen erstellten Ressourcen oder das gesamte Projekt löschen. Neue Google Cloud-Nutzer haben Anspruch auf eine kostenlose Testversion von 300$.

Cloud Shell-Editor starten

Dieses Lab wurde für die Verwendung mit dem Google Cloud Shell-Editor entwickelt und getestet. So greifen Sie auf den Editor zu:

Rufen Sie Ihr Google-Projekt unter https://console.cloud.google.com auf.
Klicken Sie rechts oben auf das Symbol für den Cloud Shell-Editor

Unten im Fenster wird ein neuer Bereich geöffnet.
Klicken Sie auf die Schaltfläche „Editor öffnen“.

Der Editor wird mit einem Explorer auf der rechten Seite und dem Editor im mittleren Bereich geöffnet.
Unten auf dem Bildschirm sollte außerdem ein Terminalbereich verfügbar sein.
Wenn das Terminal NICHT geöffnet ist, verwende die Tastenkombination „Strg +“, um ein neues Terminalfenster zu öffnen

gcloud einrichten

Legen Sie in Cloud Shell Ihre Projekt-ID und die Region fest, in der Sie die Anwendung bereitstellen möchten. Speichern Sie sie als Variablen des Typs PROJECT_ID und REGION.

export PROJECT_ID=$(gcloud config get-value project)
export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format='value(projectNumber)')

In diesem Lab verwendete Infrastruktur bereitstellen

In diesem Lab stellen Sie Code in GKE bereit und greifen auf Daten zu, die in einer Cloud SQL-Datenbank gespeichert sind. Mit dem Einrichtungsskript unten wird diese Infrastruktur für Sie vorbereitet.

Laden Sie das Einrichtungsskript herunter und machen Sie es ausführbar.

wget https://raw.githubusercontent.com/GoogleCloudPlatform/container-developer-workshop/main/labs/nodejs/setup_with_cw.sh
chmod +x setup_with_cw.sh

Öffne die Datei „setup_with_cw.sh“ und bearbeite die Werte für Passwörter, die derzeit auf CHANGEME festgelegt sind
Führen Sie das Setupskript aus, um einen GKE-Cluster und eine Cloud SQL-Datenbank zu erstellen, die Sie in diesem Lab verwenden werden

./setup_with_cw.sh &

Cloud Workstations-Cluster

Öffnen Sie Cloud Workstations in der Cloud Console. Warten Sie, bis der Cluster den Status READY hat.

Workstationkonfiguration erstellen

Wenn die Verbindung zu Ihrer Cloud Shell-Sitzung getrennt wurde, klicken Sie auf „Wieder verbinden“. und führen Sie dann den Befehl „gcloud cli“ aus, um die Projekt-ID festzulegen. Ersetzen Sie die Beispiel-Projekt-ID unten durch Ihre Qwiklabs-Projekt-ID, bevor Sie den Befehl ausführen.

gcloud config set project qwiklabs-gcp-project-id

Laden Sie das folgende Skript herunter und führen Sie es im Terminal aus, um die Cloud Workstations-Konfiguration zu erstellen.

wget https://raw.githubusercontent.com/GoogleCloudPlatform/container-developer-workshop/main/labs/nodejs/workstation_config_setup.sh
chmod +x workstation_config_setup.sh
./workstation_config_setup.sh

Überprüfen Sie die Ergebnisse im Abschnitt „Konfigurationen“. Es dauert 2 Minuten, bis der Status BEREIT aktiviert ist.

Öffnen Sie Cloud Workstations in der Console und erstellen Sie eine neue Instanz.

Ändern Sie den Namen in my-workstation und wählen Sie die vorhandene Konfiguration aus: codeoss-js.

Prüfen Sie die Ergebnisse im Abschnitt „Workstations“.

Workstation starten

Starten und starten Sie die Workstation. Es dauert einige Minuten, bis die Workstation gestartet wird.

Du kannst Cookies von Drittanbietern zulassen, indem du auf das Symbol in der Adressleiste klickst.

Klicken Sie auf „Website funktioniert nicht?“.

Klicke auf „Cookies zulassen“.

Sobald die Workstation gestartet wurde, wird Code OSS IDE angezeigt. Klicken Sie auf „Als erledigt markieren“. auf der Seite „Erste Schritte“.

3. Neue Nodejs-Startanwendung erstellen

In diesem Abschnitt erstellen Sie eine neue Nodejs-Anwendung.

Öffnen Sie ein neues Terminal.

Erstellen Sie in Cloud Shell ein neues Verzeichnis namens mynodejsapp

mkdir mynodejsapp

Wenn diese Meldung angezeigt wird, klicken Sie auf die Schaltfläche „Zulassen“, damit Sie das Einfügen auf die Workstation kopieren können.

Wechseln Sie zu diesem Verzeichnis und öffnen Sie es als Arbeitsbereich. Dadurch wird der Editor neu geladen, indem eine Arbeitsbereichskonfiguration im neu erstellten Ordner erstellt wird.

cd mynodejsapp && code-oss-cloud-workstations -r --folder-uri="$PWD"

Öffnen Sie ein neues Terminal. Node und NPM mit NVM installieren

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.2/install.sh | bash
        
        # This loads nvm bash_completion
export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"  # This loads nvm
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"  

nvm install stable

nvm alias default stable

4. Neue Start-App erstellen

Anwendung initialisieren

Mit dem folgenden Befehl eine package.json-Datei erstellen

npm init

    Choose the `entry point: (index.js) src/index.js` and leave default values for the rest of the parameters. This will create the `package.json` file with following contents

{
  "name": "mynodejsapp",
  "version": "1.0.0",
  "description": "",
  "main": "src/index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}

Einstiegspunkt hinzufügen

Öffnen und bearbeiten Sie die Datei package.json in der IDE, um den Startbefehl in das Skript "start": "node src/index.js", aufzunehmen. Nach der Änderung sollten die Skripts wie das folgende Code-Snippet aussehen:

"scripts": {
    "start": "node src/index.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  },

Express-Abhängigkeit hinzufügen

Der Code, den wir hinzufügen, verwendet ebenfalls express. Lassen Sie uns diese Abhängigkeit zu dieser package.json-Datei hinzufügen. Nach allen Änderungen sollte die Datei package.json also so aussehen:

{
 "name": "mynodejsapp",
 "version": "1.0.0",
 "description": "",
 "main": "src/index.js",
 "scripts": {
   "start": "node src/index.js",
   "test": "echo \"Error: no test specified\" && exit 1"
 },
 "author": "",
 "license": "ISC",
 "dependencies": {
   "express": "^4.17.3"
 }
}

Datei "index.js" erstellen

Erstellen Sie ein Quellverzeichnis mit dem Namen „src“, indem Sie in der Explorer-Ansicht „Neuer Ordner“ auswählen.

Datei "src/index.js" erstellen

durch den folgenden Code

const express = require('express');
const app = express();
const PORT = 8080;

app.get('/', (req, res) => {
    var message="Greetings from Node";
    res.send({ message: message });
  });

app.listen(PORT, () => {
  console.log(`Server running at: http://localhost:${PORT}/`);

});

Für PORT ist der Wert 8080 festgelegt.

Manifeste generieren

Skaffold bietet integrierte Tools zur Vereinfachung der Containerentwicklung. In diesem Schritt initialisieren Sie Skaffold, wodurch automatisch grundlegende Kubernetes-YAML-Dateien erstellt werden. Führen Sie den folgenden Befehl aus, um den Prozess zu starten.

Führen Sie den folgenden Befehl im Terminal aus

skaffold init --generate-manifests

Tun Sie Folgendes, wenn Sie dazu aufgefordert werden:

Geben Sie 8080 als Port ein.
Geben Sie y ein, um die Konfiguration zu speichern

Der Arbeitsbereichvisualisierung werden zwei Dateien hinzugefügt: skaffold.yaml und deployment.yaml

App-Name aktualisieren

Die in der Konfiguration enthaltenen Standardwerte stimmen derzeit nicht mit dem Namen Ihrer Anwendung überein. Aktualisieren Sie die Dateien so, dass sie auf den Namen Ihrer Anwendung anstatt auf die Standardwerte verweisen.

Einträge in der Skaffold-Konfiguration ändern

„skaffold.yaml“ öffnen
Wählen Sie den Image-Namen aus, der derzeit als package-json-image festgelegt ist
Klicken Sie mit der rechten Maustaste und wählen Sie „Alle Vorkommen ändern“ aus.
Geben Sie den neuen Namen als mynodejsapp ein.

Einträge in der Kubernetes-Konfiguration ändern

Datei „deployment.yaml“ öffnen
Wählen Sie den Image-Namen aus, der derzeit als package-json-image festgelegt ist
Klicken Sie mit der rechten Maustaste und wählen Sie „Alle Vorkommen ändern“ aus.
Geben Sie den neuen Namen als mynodejsapp ein.

Beachten Sie, dass in der Datei skaffold.yaml im Abschnitt build buildpacks verwendet wird, um die Anwendung zu containerisieren. Dieser Code hat kein Dockerfile und der Entwickler benötigt keine Kenntnisse von Docker, um diese Anwendung zu containerisieren.

Außerdem wird durch diese Skaffold-Konfiguration automatisch die Hot-Sync zwischen dem Editor und dem ausgeführten Container aktiviert. Zum Aktivieren der Hot Sync ist keine zusätzliche Konfiguration erforderlich.

5. Der Entwicklungsprozess

In diesem Abschnitt führen Sie einige Schritte mit dem Cloud Code-Plug-in durch, um die grundlegenden Prozesse kennenzulernen und die Konfiguration und Einrichtung Ihrer Startanwendung zu validieren.

Cloud Code lässt sich in Skaffold einbinden, um den Entwicklungsprozess zu optimieren. Wenn Sie in den folgenden Schritten ein Deployment in GKE ausführen, erstellen Cloud Code und Skaffold automatisch das Container-Image, übertragen es per Push in eine Container Registry und stellen die Anwendung dann in GKE bereit. Dies geschieht im Hintergrund und abstrahiert die Details außerhalb des Entwicklungsablaufs. Cloud Code verbessert außerdem Ihren Entwicklungsprozess, indem es herkömmliche Debugging- und Hotsync-Funktionen für die containerbasierte Entwicklung bereitstellt.

Klicken Sie auf das Cloud Code-Symbol und wählen Sie „In Google Cloud anmelden“ aus:

Klicken Sie auf „Zur Anmeldung fortfahren“.

Prüfen Sie die Ausgabe im Terminal und öffnen Sie den Link:

Melden Sie sich mit den Anmeldedaten Ihrer Qwiklabs-Teilnehmer an.

Wählen Sie "Zulassen" aus:

Kopieren Sie den Bestätigungscode und kehren Sie zum Tab „Workstation“ zurück.

Füge den Bestätigungscode ein und drücke die Eingabetaste.

Kubernetes-Cluster hinzufügen

Cluster hinzufügen

Wählen Sie Google Kubernetes Engine aus:

Projekt auswählen.

Wählen Sie „mycluster“ aus die bei der Ersteinrichtung erstellt wurde.

Der Cluster wird jetzt in der Liste der Kubernetes-Cluster unter Cloud Code angezeigt. Von hier aus können Sie den Cluster aufrufen und untersuchen.

Aktuelle Projekt-ID mit gcloud cli festlegen

Kopieren Sie die Projekt-ID für dieses Lab von der Qwiklabs-Seite.

Führen Sie im Terminal den Befehl „gcloud cli“ aus, um die Projekt-ID festzulegen. Ersetzen Sie die Beispielprojekt-ID, bevor Sie den Befehl ausführen. WECHSELN Sie die Projekt-ID, bevor Sie den folgenden Befehl ausführen.

gcloud config set project qwiklabs-gcp-project-id

In Kubernetes bereitstellen

Wählen Sie unten im Cloud Shell-Editor den Bereich „Cloud Code“ aus.

Wählen Sie im Bereich, der oben unter ENTWICKLUNGSsitzungen erscheint, die Option Auf Kubernetes ausführen aus. Wenn Sie dazu aufgefordert werden, wählen Sie „Ja“ aus, um den aktuellen Kubernetes-Kontext zu verwenden.

Wenn Sie den Befehl zum ersten Mal ausführen, wird oben auf dem Bildschirm eine Eingabeaufforderung angezeigt, in der Sie gefragt werden, ob Sie den aktuellen Kubernetes-Kontext verwenden möchten. Wählen Sie „Yes“ (Ja) aus. den aktuellen Kontext akzeptieren und nutzen.

Als Nächstes wird eine Eingabeaufforderung angezeigt, in der Sie gefragt werden, welche Container Registry verwendet werden soll. Drücken Sie die Eingabetaste, um den angegebenen Standardwert zu übernehmen

Wählen Sie im unteren Bereich den Tab „Output“ (Ausgabe) und im Drop-down-Menü Kubernetes: Run/Debug (Kubernetes: Ausführen/Debuggen) aus, um den Fortschritt und Benachrichtigungen anzusehen.

Wählen Sie „Kubernetes: Run/Debug – Detail“ aus. im Drop-down-Menü „Kanal“ rechts, um zusätzliche Details und Logs aufzurufen, die live aus den Containern gestreamt werden

Kehren Sie zur vereinfachten Ansicht zurück, indem Sie „Kubernetes: Run/Debug“ auswählen. aus dem Drop-down-Menü
Wenn der Build und die Tests abgeschlossen sind, wird auf dem Tab „Ausgabe“ Resource deployment/mynodejsapp status completed successfully angezeigt und die URL wird aufgeführt: „Forwarded URL from service demo-app: http://localhost:8080“
Bewegen Sie den Mauszeiger im Cloud Code-Terminal auf die URL in der Ausgabe (http://localhost:8080) und wählen Sie in der angezeigten Kurzinfo „Link folgen“ aus.

Die Antwort lautet:

{"message":"Greetings from Node"}

Heiße Aufladung

Rufen Sie src/index.js auf. Code der Begrüßungsnachricht in 'Hello from Node' ändern

Sie sehen sofort, dass der Watcher im Output-Fenster in der Ansicht Kubernetes: Run/Debug die aktualisierten Dateien mit dem Container in Kubernetes synchronisiert.

Update initiated
File sync started for 1 files for gcr.io/myproject/mynodejsapp:latest@sha256:f554756b3b4d6c301c4b26ef96102227cfa2833270db56241248ae42baa1971a
File sync succeeded for 1 files for gcr.io/myproject/mynodejsapp:latest@sha256:f554756b3b4d6c301c4b26ef96102227cfa2833270db56241248ae42baa1971a
Update succeeded

Wenn Sie zur Ansicht Kubernetes: Run/Debug - Detailed wechseln, werden Sie feststellen, dass Dateiänderungen erkannt werden und der Knoten neu gestartet wird.

files modified: [src/index.js]
Copying files:map[src/index.js:[/workspace/src/index.js]]togcr.io/myproject/mynodejsapp:latest@sha256:f554756b3b4d6c301c4b26ef96102227cfa2833270db56241248ae42baa1971a
Syncing 1 files for gcr.io/myproject/mynodejsapp:latest@sha256:f554756b3b4d6c301c4b26ef96102227cfa2833270db56241248ae42baa1971a
Watching for changes...
[mynodejsapp]
[mynodejsapp]> mynodejsapp@1.0.0 start /workspace
[mynodejsapp]> node src/index.js
[mynodejsapp]
[mynodejsapp]Server running at: http://localhost:8080/

Aktualisieren Sie Ihren Browser, um die aktualisierten Ergebnisse zu sehen.

Debugging

Rufen Sie die Debug-Ansicht auf und beenden Sie den aktuellen Thread .
Klicken Sie im Menü unten auf Cloud Code und wählen Sie Debug on Kubernetes aus, um die Anwendung im debug-Modus auszuführen.

In der Ansicht Kubernetes Run/Debug - Detailed des Fensters Output sehen Sie, dass Skaffold diese Anwendung im Debug-Modus bereitstellt.
Es dauert einige Minuten, bis die Anwendung erstellt und bereitgestellt ist. Diesmal sehen Sie einen Debugger.

Port forwarding pod/mynodejsapp-6bbcf847cd-vqr6v in namespace default, remote port 9229 -> http://127.0.0.1:9229
[mynodejsapp]Debugger attached.

Die Farbe der unteren Statusleiste wechselt von Blau zu Orange, was darauf hinweist, dass der Debug-Modus aktiviert ist.

Beachten Sie in der Ansicht Kubernetes Run/Debug, dass ein Debug-fähiger Container gestartet wird.

**************URLs*****************
Forwarded URL from service mynodejsapp-service: http://localhost:8080
Debuggable container started pod/mynodejsapp-deployment-6bc7598798-xl9kj:mynodejsapp (default)
Update succeeded
***********************************

Haltepunkte verwenden

Öffne src/index.js
Suchen Sie die Anweisung var message="Hello from Node";.
Fügen Sie dieser Zeile einen Haltepunkt hinzu, indem Sie auf den leeren Bereich links neben der Zeilennummer klicken. Ein roter Indikator wird angezeigt, um darauf hinzuweisen, dass der Haltepunkt eingerichtet ist.
Laden Sie Ihren Browser neu. Der Debugger stoppt den Prozess am Haltepunkt und ermöglicht es Ihnen, die Variablen und den Status der Anwendung zu untersuchen, die remote in GKE ausgeführt wird.
Klicken Sie im Bereich „Variablen“ nach unten, bis Sie die Variable "message" finden.
Führen Sie die Zeile aus, indem Sie auf „Schritt über “ klicken
Beobachten, wie sich der aktuelle Wert der Variablen "message" in "Hello from Node" ändert
Doppelklicken Sie auf den Variablennamen „target“. und ändern Sie im Pop-up-Menü den Wert in einen anderen Wert, z. B. "Hi from Node".
Klicken Sie im Steuerfeld zur Fehlerbehebung auf die Schaltfläche Weiter .
Sehen Sie sich die Antwort in Ihrem Browser an. Sie enthält jetzt den aktualisierten Wert, den Sie gerade eingegeben haben.
„Fehlerbehebung“ beenden indem Sie die Stopp-Schaltfläche drücken. Entfernen Sie den Haltepunkt, indem Sie noch einmal auf den Haltepunkt klicken.

6. Entwickeln eines einfachen CRUD Rest-Dienstes

Jetzt ist Ihre Anwendung vollständig für die Containerentwicklung konfiguriert und Sie haben den grundlegenden Entwicklungsworkflow mit Cloud Code durchgegangen. In den folgenden Abschnitten wenden Sie das Gelernte an. Dazu fügen Sie REST-Dienstendpunkte hinzu, die eine Verbindung zu einer verwalteten Datenbank in Google Cloud herstellen.

Abhängigkeiten konfigurieren

Der Anwendungscode verwendet eine Datenbank, um die übrigen Dienstdaten zu speichern. Sorgen Sie dafür, dass die Abhängigkeiten verfügbar sind, indem Sie in der Datei package.json Folgendes hinzufügen:

Fügen Sie der Datei package.json zwei weitere Abhängigkeiten pg und sequelize hinzu, um eine Postgres-Anwendung mit der CRUD-Anwendung zu erstellen. Nach der Aktualisierung sieht der Abschnitt „Abhängigkeiten“ so aus.

    "dependencies": {
    "express": "^4.17.3",
    "pg": "^8.8.0",
    "sequelize": "^6.25.7"
  }

REST-Dienst codieren

CRUD-Anwendungscode zu dieser Anwendung hinzufügen

wget -O app.zip https://github.com/GoogleCloudPlatform/container-developer-workshop/raw/main/labs/nodejs/app.zip

unzip app.zip

Dieser Code enthält

Ordner models mit dem Entitätsmodell für item
controllers-Ordner mit dem Code, der CRUD-Vorgänge ausführt
routes-Ordner, der bestimmte URL-Muster an verschiedene Aufrufe weiterleitet
Ordner config mit Details zur Datenbankverbindung

Die Datenbankkonfiguration in der Datei db.config.js bezieht sich auf die Umgebungsvariablen, die bereitgestellt werden müssen, um eine Verbindung zur Datenbank herzustellen. Außerdem musst du die eingehende Anfrage für die URL-Codierung parsen.
Fügen Sie das folgende Code-Snippet in src/index.js ein, um eine Verbindung zum CRUD-Code aus Ihrer Haupt-JavaScript-Datei direkt vor dem letzten Abschnitt herzustellen, der mit app.listen(PORT, () => { beginnt.

const bodyParser = require('body-parser')
app.use(bodyParser.json())
app.use(
 bodyParser.urlencoded({
   extended: true,
 })
)
const db = require("../app/models");
db.sequelize.sync();
require("../app/routes/item.routes")(app);

Bearbeiten Sie die Bereitstellung in der Datei deployment.yaml und fügen Sie die Umgebungsvariablen für die Informationen zur Datenbankverbindung hinzu.

Aktualisieren Sie den Spezifikationseintrag am Ende der Datei, damit er der folgenden Definition entspricht

    spec:
      containers:
      - name: mynodejsapp
        image: mynodejsapp
        env:
        - name: DB_HOST
          value: ${DB_INSTANCE_IP}        
        - name: DB_PORT
          value: "5432"  
        - name: DB_USER
          valueFrom:
            secretKeyRef:
              name: gke-cloud-sql-secrets
              key: username
        - name: DB_PASS
          valueFrom:
            secretKeyRef:
              name: gke-cloud-sql-secrets
              key: password
        - name: DB_NAME
          valueFrom:
            secretKeyRef:
              name: gke-cloud-sql-secrets
              key: database

Ersetzen Sie den Wert DB_HOST durch die Adresse Ihrer Datenbank

export DB_INSTANCE_IP=$(gcloud sql instances describe mytest-instance \
    --format=json | jq \
    --raw-output ".ipAddresses[].ipAddress")

envsubst < deployment.yaml > deployment.new && mv deployment.new deployment.yaml

Anwendung bereitstellen und validieren

Wählen Sie unten im Cloud Shell-Editor Cloud Code und dann oben Debug on Kubernetes aus.
Wenn der Build und die Tests abgeschlossen sind, wird auf dem Tab „Ausgabe“ Resource deployment/mynodejsapp status completed successfully angezeigt und die URL wird aufgeführt: „Forwarded URL from service mynodejsapp: http://localhost:8080“
Fügen Sie einige Elemente hinzu.

Führen Sie im Cloud Shell-Terminal die folgenden Befehle aus

URL=localhost:8080
curl -X POST $URL/items -d '{"itemName":"Body Spray", "itemPrice":3.2}' -H "Content-Type: application/json"
curl -X POST $URL/items -d '{"itemName":"Nail Cutter", "itemPrice":2.5}' -H "Content-Type: application/json"

Testen Sie die GET-Anfrage, indem Sie $URL/items im Browser ausführen. Sie können den curl-Befehl auch über die Befehlszeile ausführen

curl -X GET $URL/items

Löschen testen: Versuchen Sie nun, ein Element zu löschen, indem Sie den folgenden Befehl ausführen. Ändern Sie gegebenenfalls den Wert von „item-id“.

curl -X DELETE $URL/items/1

    This throws an error message

{"message":"Could not delete Item with id=[object Object]"}

Problem ermitteln und beheben

Die Anwendung wird im Debug-Modus ausgeführt. Verwenden Sie also Haltepunkte, um das Problem zu finden. Hier einige Tipps:

Uns ist bewusst, dass mit der DELETE-Anfrage etwas nicht stimmt, da nicht das gewünschte Ergebnis zurückgegeben wird. In diesem Fall würden Sie den Haltepunkt in der Methode itemcontroller.js->exports.delete festlegen.
Führen Sie eine Schritt-für-Schritt-Ausführung aus und beobachten Sie die Variablen bei jedem Schritt, um die Werte der lokalen Variablen im linken Fenster zu beobachten.
Wenn Sie bestimmte Werte wie request.params beobachten möchten, fügen Sie diese Variable dem Beobachtungszeitraum hinzu.

Beachten Sie, dass der Wert für id undefined ist. Ändern Sie den Code, um das Problem zu beheben.

Das feste Code-Snippet sieht dann so aus:

// Delete a Item with the specified id in the request
exports.delete = (req, res) => {
    const id = req.params.id;

Testen Sie die Anwendung nach dem Neustart noch einmal, indem Sie versuchen, die Anwendung zu löschen.
Beenden Sie die Fehlerbehebungssitzung durch Klicken auf das rote Quadrat in der Debugging-Symbolleiste .

7. Bereinigen

Glückwunsch! In diesem Lab haben Sie eine neue Nodejs-Anwendung erstellt und so konfiguriert, dass sie im Hot-Deployment-Modus mit Containern funktioniert. Anschließend haben Sie Ihre Anwendung in einem Remote-GKE-Cluster bereitgestellt und entsprechende Fehler behoben. Dabei folgten Sie dem Entwicklerablauf, der auch in herkömmlichen Anwendungspaketen verwendet wird.

So bereinigen Sie nach Abschluss des Labs:

Die im Lab verwendeten Dateien löschen

cd ~ && rm -rf mynodejsapp && rm -f setup.sh

Löschen Sie das Projekt, um alle zugehörigen Infrastrukturen und Ressourcen zu entfernen.