InnerLoop-Entwicklung mit 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 der GCP 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

1. 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 und den Sie jederzeit aktualisieren können.
• Die Projekt-ID muss für alle Google Cloud-Projekte eindeutig sein und ist unveränderlich (kann nach der Festlegung nicht mehr geändert werden). In der Cloud Console wird automatisch ein eindeutiger String generiert. Normalerweise ist es nicht wichtig, wie dieser aussieht. In den meisten Codelabs müssen Sie auf die Projekt-ID verweisen (die in der Regel als PROJECT_ID angegeben wird). Wenn Ihnen die ID nicht gefällt, können Sie eine andere zufällige ID generieren oder eine eigene ID ausprobieren und sehen, ob sie verfügbar ist. Nachdem das Projekt erstellt wurde, wird es „eingefroren“.
• Es gibt einen dritten Wert, die Projektnummer, die von einigen APIs verwendet wird. Weitere Informationen zu diesen drei Werten

Achtung:Eine Projekt-ID muss global eindeutig sein und kann nach der Auswahl nicht mehr von anderen verwendet werden. Sie sind der einzige Nutzer dieser ID. Wenn ein Projekt gelöscht wird, kann die ID nie wieder verwendet werden.

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 Cloud-Ressourcen/-APIs verwenden zu können. Die Durchführung dieses Codelabs sollte keine oder nur geringe Kosten verursachen. Wenn Sie Ressourcen herunterfahren möchten, damit nach Abschluss dieses Codelabs keine Gebühren anfallen, folgen Sie den Bereinigungsanweisungen am Ende des Codelabs. 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:

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

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

5. Der Editor wird mit einem Explorer auf der rechten Seite und dem Editor im mittleren Bereich geöffnet.
6. Unten auf dem Bildschirm sollte auch ein Terminalbereich verfügbar sein.
7. 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)')

GKE-Cluster und Datenbank einrichten

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

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

Die in diesem Lab verwendete Infrastruktur bereitstellen

In diesem Lab stellen Sie Code in GKE bereit und greifen auf Daten zu, die in einer Spanner-Datenbank gespeichert sind. Das folgende Setupscript bereitet diese Infrastruktur für Sie vor.

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

./setup.sh

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

mkdir mynodejsapp

4. 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 && cloudshell workspace .

5. Installieren Sie Node und NPM mit NVM.

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/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

3. Neue Starteranwendung erstellen

1. Anwendung initialisieren

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

npm init

    Choose the entry point: (index.js) src/index.js and default values for the rest of the parameters. This will create the 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"
}

2. Einstiegspunkt hinzufügen

Bearbeiten Sie diese Datei, um den Startbefehl in das Script "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"
  },

3. 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": "Your Name",
  "license": "ISC",
  "dependencies": {
    "express": "^4.16.4"
  }
}

4. Datei „index.js“ erstellen

Quelldateiverzeichnis „src“ erstellen

Erstellen Sie die Datei „src/index.js“ 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.

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

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

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

In Kubernetes bereitstellen

1. Wählen Sie im Bereich unten im Cloud Shell-Editor Cloud Code  aus.

2. Wählen Sie im Feld oben In Kubernetes ausführen aus. Wenn Sie dazu aufgefordert werden, wählen Sie „Ja“ aus, um den aktuellen Kubernetes-Kontext zu verwenden.

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

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

5. Wählen Sie im unteren Bereich den Tab „Ausgabe“ aus, um den Fortschritt und Benachrichtigungen zu sehen.

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

7. Kehren Sie zur vereinfachten Ansicht zurück, indem Sie im Drop-down-Menü „Kubernetes: Ausführen/Debuggen“ auswählen.
8. 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“.
9. Bewegen Sie den Mauszeiger im Cloud Code-Terminal auf die URL in der Ausgabe (http://localhost:8080) und wählen Sie dann in der angezeigten Kurzinfo die Option „Webvorschau öffnen“ aus.

Die Antwort lautet:

{"message":"Greetings from Node"}

Hot Reload

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

2. 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/

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

Debugging

1. Rufen Sie die Debug-Ansicht auf und beenden Sie den aktuellen Thread .
2. 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.

3. Die untere Statusleiste ändert ihre Farbe von Blau zu Orange, was darauf hinweist, dass sie sich im Debug-Modus befindet.
4. 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

1. Öffnen Sie src/index.js.
2. Suchen Sie die Aussage var message="Greetings from Node";.
3. 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.
4. 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.
5. Klicken Sie im Bereich „Variablen“ nach unten, bis Sie die Variable "message" finden.
6. Führen Sie die Zeile aus, indem Sie auf „Überspringen“  drücken.
7. Beobachten Sie, wie sich der aktuelle Wert der Variablen "message" in "Greetings from Node" ändert.
8. Doppelklicken Sie auf den Variablennamen „target“ und ändern Sie den Wert im Pop-up-Fenster in einen anderen Wert, z. B. "Hello from Node".
9. Klicken Sie im Debugging-Steuerfeld auf die Schaltfläche „Weiter“.
10. Sehen Sie sich die Antwort in Ihrem Browser an. Dort wird jetzt der aktualisierte Wert angezeigt, den Sie gerade eingegeben haben.
11. Beenden Sie den Debug-Modus, indem Sie auf die Stopptaste  drücken, und entfernen Sie den Haltepunkt, indem Sie noch einmal darauf klicken.

5. 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:

1. 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.16.4",
    "pg": "^8.7.3",
    "sequelize": "^6.17.0"
  }

REST-Dienst codieren

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

2. 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.
3. 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);

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

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

1. Wählen Sie im Bereich unten im Cloud Shell-Editor Cloud Code und dann oben auf dem Bildschirm Debug on Kubernetes aus.
2. 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“.
3. 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"

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

5. Löschen testen: Versuchen Sie nun, ein Element zu löschen. Ä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

1. Starten Sie die Anwendung im Debug-Modus neu und suchen Sie nach dem Problem. 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.

2. 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;

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

6. 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:

1. Im Lab verwendete Dateien löschen

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

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