InnerLoop-Entwicklung mit Cloud Workstations und NodeJS

1. Übersicht

In diesem Lab werden Funktionen und Möglichkeiten vorgestellt, die den Entwicklungsablauf für Softwareentwickler optimieren sollen, die NodeJS-Anwendungen in einer Containerumgebung entwickeln. Für die typische Containerentwicklung muss der Nutzer Details zu Containern und zum Container-Build-Prozess kennen. Außerdem müssen Entwickler ihren Workflow in der Regel unterbrechen und ihre IDE verlassen, um ihre Anwendungen in Remote-Umgebungen zu testen und zu debuggen. Mit den in diesem Tutorial erwähnten Tools und Technologien können Entwickler effektiv mit containerisierten Anwendungen 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-Starteranwendung erstellen
Node.js-Anwendung für die Containerentwicklung konfigurieren
Einen einfachen CRUD-REST-Dienst programmieren
In GKE bereitstellen
Fehlerstatus beheben
Haltepunkte / Logs verwenden
Änderungen per Hot-Deployment in GKE bereitstellen
Optional: CloudSQL für die Backend-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. Wenn Sie noch kein Gmail- oder Google Workspace-Konto haben, müssen Sie eines erstellen.

Der Projektname ist der Anzeigename für die Teilnehmer dieses Projekts. Es handelt sich um einen String, der nicht von Google APIs verwendet wird. Sie können ihn jederzeit aktualisieren.
Die Projekt-ID ist für alle Google Cloud-Projekte eindeutig und unveränderlich (kann nach dem Festlegen nicht mehr geändert werden). In der Cloud Console wird automatisch ein eindeutiger String generiert. Normalerweise ist es nicht wichtig, wie dieser String aussieht. In den meisten Codelabs müssen Sie auf die Projekt-ID verweisen (sie wird in der Regel als PROJECT_ID angegeben). Wenn Ihnen die generierte ID nicht gefällt, können Sie eine andere zufällige ID generieren. Alternativ können Sie es mit einem eigenen versuchen und sehen, ob es verfügbar ist. Sie kann nach diesem Schritt nicht mehr geändert werden und bleibt für die Dauer des Projekts bestehen.
Zur Information: Es gibt einen dritten Wert, die Projektnummer, die von einigen APIs verwendet wird. Weitere Informationen zu diesen drei Werten

Als Nächstes müssen Sie die Abrechnung in der Cloud Console aktivieren, um Cloud-Ressourcen/-APIs zu verwenden. Die Durchführung dieses Codelabs sollte keine oder nur geringe Kosten verursachen. Wenn Sie Ressourcen herunterfahren möchten, damit Ihnen nach Abschluss dieser Anleitung keine Kosten mehr in Rechnung gestellt werden, können Sie die von Ihnen erstellten Ressourcen oder das gesamte Projekt löschen. Neue Nutzer von Google Cloud kommen für das Programm für kostenlose Testversionen mit einem Guthaben von 300$ infrage.

Cloud Shell-Editor starten

Dieses Lab wurde für die Verwendung mit 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 oben rechts auf das Cloud Shell Editor-Symbol.

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 auch ein Terminalbereich verfügbar sein.
Wenn das Terminal NICHT geöffnet ist, verwenden Sie 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 Ihre Anwendung bereitstellen möchten. Speichern Sie diese als die Variablen PROJECT_ID und REGION ab.

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

Die 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. Das folgende Setupscript bereitet diese Infrastruktur für Sie vor.

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

Öffnen Sie die Datei setup_with_cw.sh und bearbeiten Sie die Werte der Passwörter, die derzeit auf CHANGEME festgelegt sind.
Führen Sie das Einrichtungsskript aus, um einen GKE-Cluster und eine Cloud SQL-Datenbank zu erstellen, die Sie in diesem Lab verwenden.

./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 Ihre Cloud Shell-Sitzung getrennt wurde, klicken Sie auf „Reconnect“ (Wiederverbinden) und führen Sie dann den gcloud-CLI-Befehl aus, um die Projekt-ID festzulegen. Ersetzen Sie die Beispielprojekt-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 eine 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 Bereich „Konfigurationen“. Es dauert 2 Minuten, bis der Status zu „BEREIT“ wechselt.

Ö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 codeoss-js aus.

Prüfen Sie die Ergebnisse im Bereich „Arbeitsstationen“.

Workstation starten

Starten Sie die Workstation. Es kann einige Minuten dauern, bis die Workstation gestartet ist.

Erlauben Sie Drittanbieter-Cookies, indem Sie in der Adressleiste auf das Symbol klicken.

Klicken Sie auf „Website funktioniert nicht?“.

Klicken Sie auf „Cookies zulassen“.

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

3. Neue Node.js-Starteranwendung erstellen

In diesem Abschnitt erstellen Sie eine neue Node.js-Anwendung.

Öffnen Sie ein neues Terminal.

Erstellen Sie in Cloud Shell ein neues Verzeichnis mit dem Namen mynodejsapp.

mkdir mynodejsapp

Klicken Sie auf die Schaltfläche „Zulassen“, wenn diese Meldung angezeigt wird, damit Sie Inhalte in die Workstation kopieren und einfügen können.

Wechseln Sie in dieses Verzeichnis und öffnen Sie es als Arbeitsbereich. Dadurch wird der Editor neu geladen und eine Arbeitsbereichskonfiguration im neu erstellten Ordner erstellt.

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

Öffnen Sie noch einmal ein neues Terminal. Installieren Sie Node und NPM mit NVM.

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 Starteranwendung erstellen

Anwendung initialisieren

Erstellen Sie mit dem folgenden Befehl eine package.json-Datei:

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 Sie die Datei package.json in der IDE und bearbeiten Sie sie, um den Startbefehl in das Skript "start": "node src/index.js", aufzunehmen. Nach der Änderung sollten die Skripts so 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 werden, verwendet auch express. Fügen wir also diese Abhängigkeit in die Datei package.json ein. Nach allen Änderungen sollte die package.json-Datei wie unten dargestellt 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

mit dem 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}/`);

});

Der PORT ist auf den Wert 8080 festgelegt.

Manifeste generieren

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

Führen Sie im Terminal den folgenden Befehl aus.

skaffold init --generate-manifests

Tun Sie Folgendes, wenn Sie dazu aufgefordert werden:

Geben Sie 8080 für den Port ein.
Geben Sie y ein, um die Konfiguration zu speichern.

Der Arbeitsbereichsvisualisierung 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 Ihren Anwendungsnamen und nicht auf die Standardwerte verweisen.

Einträge in der Skaffold-Konfiguration ändern

skaffold.yaml öffnen
Wählen Sie den Bildnamen 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

deployment.yaml-Datei öffnen
Wählen Sie den Bildnamen 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 im Abschnitt build der Datei skaffold.yaml buildpacks verwendet wird, um die Anwendung in einem Container zu hosten. Dieser Code hat kein Dockerfile und der Entwickler benötigt keine Docker-Kenntnisse, um diese Anwendung zu containerisieren.

Außerdem wird durch diese Skaffold-Konfiguration die Hot-Synchronisierung zwischen dem Editor und dem laufenden Container automatisch aktiviert. Für die Aktivierung der Hot-Synchronisierung ist keine zusätzliche Konfiguration erforderlich.

5. Entwicklungsprozess durchlaufen

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

Cloud Code lässt sich in Skaffold einbinden, um den Entwicklungsprozess zu optimieren. Wenn Sie Ihre Anwendung in den folgenden Schritten in GKE bereitstellen, erstellen Cloud Code und Skaffold automatisch Ihr Container-Image, übertragen es per Push in eine Container Registry und stellen Ihre Anwendung dann in GKE bereit. Dies geschieht im Hintergrund und die Details werden vom Entwicklerfluss abstrahiert. Cloud Code verbessert Ihren Entwicklungsprozess auch durch die Bereitstellung herkömmlicher Debugging- und Hotsync-Funktionen für die containerbasierte Entwicklung.

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

Klicken Sie auf „Weiter zur Anmeldung“.

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

Melden Sie sich mit den Anmeldedaten Ihres Qwiklabs-Schülerkontos an.

Wählen Sie „Zulassen“ aus:

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

Fügen Sie den Bestätigungscode ein und drücken Sie die Eingabetaste.

Kubernetes-Cluster hinzufügen

Cluster hinzufügen

Wählen Sie Google Kubernetes Engine aus:

Wählen Sie ein Projekt aus.

Wählen Sie „mycluster“ aus, das 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 der gcloud CLI festlegen

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

Führen Sie im Terminal den gcloud CLI-Befehl aus, um die Projekt-ID festzulegen. Ersetzen Sie die Beispielprojekt-ID, bevor Sie den Befehl ausführen. Ersetzen 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 im Bereich unten im Cloud Shell-Editor Cloud Code aus.

Wählen Sie im Feld, das oben unter „ENTWICKLERSESSIONS“ angezeigt wird, In 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 Aufforderung angezeigt, in der Sie gefragt werden, ob Sie den aktuellen Kubernetes-Kontext verwenden möchten. Wählen Sie „Ja“ aus, um den aktuellen Kontext zu akzeptieren und zu verwenden.

Als Nächstes werden Sie gefragt, welche Container Registry Sie verwenden möchten. Drücken Sie die Eingabetaste, um den angegebenen Standardwert zu übernehmen.

Wählen Sie im unteren Bereich den Tab „Ausgabe“ und im Drop-down-Menü Kubernetes: Ausführen/Debuggen aus, um den Fortschritt und die Benachrichtigungen zu sehen.

Wählen Sie im Drop-down-Menü rechts „Kubernetes: Run/Debug – Detailed“ (Kubernetes: Ausführen/Debuggen – Detailliert) aus, um zusätzliche Details und Logs zu sehen, die live aus den Containern gestreamt werden.

Kehren Sie zur vereinfachten Ansicht zurück, indem Sie im Drop-down-Menü „Kubernetes: Ausführen/Debuggen“ auswählen.
Wenn der Build und die Tests abgeschlossen sind, wird auf dem Tab „Ausgabe“ Resource deployment/mynodejsapp status completed successfully angezeigt und es wird eine URL aufgeführt: „Weitergeleitete URL vom Dienst 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 dann im angezeigten Kurzinfo-Fenster „Link öffnen“ aus.

Die Antwort lautet:

{"message":"Greetings from Node"}

Hot Reload

Rufen Sie src/index.js auf. Code der Begrüßungsnachricht für 'Hello from Node' bearbeiten

Im Output-Fenster, Kubernetes: Run/Debug-Ansicht, synchronisiert der Watcher die aktualisierten Dateien mit dem Container in Kubernetes.

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 Kubernetes: Run/Debug - Detailed-Ansicht wechseln, werden Sie feststellen, dass Dateiveränderungen erkannt 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 unteren Menü auf Cloud Code und wählen Sie Debug on Kubernetes aus, um die Anwendung im debug-Modus auszuführen.

Im Kubernetes Run/Debug - Detailed-Bereich des Output-Fensters sehen Sie, dass Skaffold diese Anwendung im Debugmodus bereitstellt.
Es dauert einige Minuten, bis die Anwendung erstellt und bereitgestellt wird. Diesmal ist ein Debugger angehängt.

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

Die untere Statusleiste ändert ihre Farbe von Blau zu Orange, was darauf hinweist, dass sie sich im Debug-Modus befindet.

In der Ansicht Kubernetes Run/Debug sehen Sie, dass ein debugfähiger Container gestartet wurde.

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

Haltepunkte verwenden

Öffnen Sie src/index.js.
Suchen Sie die Aussage var message="Hello from Node";.
Fügen Sie der Zeile einen Haltepunkt hinzu, indem Sie auf den leeren Bereich links neben der Zeilennummer klicken. Eine rote Markierung zeigt an, dass der Haltepunkt festgelegt ist.
Laden Sie den Browser neu. Der Debugger hält den Prozess am Haltepunkt an 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 „Überspringen“ drücken.
Beobachten Sie, wie sich der aktuelle Wert der Variablen "message" in "Hello from Node" ändert.
Doppelklicken Sie auf den Variablennamen „target“ und ändern Sie den Wert im Pop-up-Fenster in einen anderen Wert, z. B. "Hi from Node".
Klicken Sie im Debugging-Steuerfeld auf die Schaltfläche „Weiter“.
Sehen Sie sich die Antwort in Ihrem Browser an. Dort wird jetzt der aktualisierte Wert angezeigt, den Sie gerade eingegeben haben.
Beenden Sie den Debug-Modus, indem Sie auf die Stopptaste drücken, und entfernen Sie den Haltepunkt, indem Sie noch einmal darauf klicken.

6. Einfachen CRUD-REST-Dienst entwickeln

Ihre Anwendung ist jetzt vollständig für die containerisierte Entwicklung konfiguriert und Sie haben den grundlegenden Entwicklungs-Workflow mit Cloud Code durchlaufen. In den folgenden Abschnitten wenden Sie das Gelernte an, indem Sie REST-Dienstendpunkte hinzufügen, die eine Verbindung zu einer verwalteten Datenbank in Google Cloud herstellen.

Abhängigkeiten konfigurieren

Im Anwendungscode wird eine Datenbank verwendet, um die Daten des REST-Dienstes zu speichern. Prüfen Sie, ob die Abhängigkeiten verfügbar sind, indem Sie Folgendes in die Datei package.json einfügen:

Fügen Sie der Datei package.json zwei weitere Abhängigkeiten pg und sequelize hinzu, um eine CRUD-Anwendung für Postgres zu erstellen. Nach dem Posten der Änderungen würde der Abschnitt „Abhängigkeiten“ so aussehen:

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

REST-Dienst codieren

Fügen Sie dieser Anwendung den CRUD-Anwendungscode hinzu.

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

unzip app.zip

Dieser Code hat

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

Die Datenbankkonfiguration in der Datei db.config.js verweist auf die Umgebungsvariablen, die für die Verbindung mit der Datenbank angegeben werden müssen. Außerdem müssen Sie die eingehende Anfrage auf URL-Codierung parsen.
Fügen Sie das folgende Code-Snippet in src/index.js ein, damit Sie vor dem letzten Abschnitt, der mit app.listen(PORT, () => { beginnt, eine Verbindung zum CRUD-Code aus Ihrer JavaScript-Hauptdatei herstellen können.

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, um die Umgebungsvariablen für die Datenbankverbindungsinformationen hinzuzufügen.

Aktualisieren Sie den Spezifikationseintrag am Ende der Datei so, dass 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 DB_HOST-Wert 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 im Bereich unten im Cloud Shell-Editor Cloud Code und dann oben auf dem Bildschirm 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 eine URL wird aufgeführt: „Weitergeleitete URL vom Dienst ‚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 den GET-Vorgang, 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

Test Delete: Versuchen Sie nun, ein Element zu löschen, indem Sie den folgenden Befehl ausführen. Ändern Sie bei Bedarf 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 identifizieren und beheben

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

Wir wissen, dass mit dem DELETE-Befehl etwas nicht stimmt, da er nicht das gewünschte Ergebnis zurückgibt. Sie würden den Breakpoint also in der Methode itemcontroller.js->exports.delete festlegen.
Führen Sie das Programm schrittweise aus und beobachten Sie die Variablen in jedem Schritt, um die Werte der lokalen Variablen im linken Fenster zu sehen.
Wenn Sie bestimmte Werte wie request.params beobachten möchten, fügen Sie diese Variable dem Überwachungsfenster hinzu.

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

Das korrigierte Code-Snippet sieht so aus:

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

Wenn die Anwendung neu gestartet wurde, versuchen Sie noch einmal, die Datei zu löschen.
Beenden Sie die Debugging-Sitzung, indem Sie in der Debug-Symbolleiste auf das rote Quadrat klicken.

7. Bereinigen

Glückwunsch! In diesem Lab haben Sie eine neue Node.js-Anwendung von Grund auf 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 dort Fehler behoben. Dabei haben Sie denselben Entwickler-Workflow verwendet, der auch bei herkömmlichen Anwendungsstacks zum Einsatz kommt.

So bereinigen Sie die Umgebung nach Abschluss des Labs:

Im Lab verwendete Dateien löschen

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

Projekt löschen, um alle zugehörigen Infrastrukturen und Ressourcen zu entfernen