Google używa technologii AI do tłumaczenia treści na Twój preferowany język. Tłumaczenia wygenerowane przez AI mogą zawierać błędy.

Programowanie w InnerLoop z użyciem Cloud Workstations z NodeJS

1. Przegląd

W tym laboratorium poznasz funkcje i możliwości, które usprawniają proces tworzenia aplikacji w środowisku skonteneryzowanym dla inżynierów oprogramowania zajmujących się opracowywaniem aplikacji w NodeJS. Typowe tworzenie kontenerów wymaga od użytkownika znajomości szczegółów dotyczących kontenerów i procesu kompilacji kontenerów. Deweloperzy muszą też zwykle przerywać pracę i opuszczać IDE, aby testować i debugować aplikacje w środowiskach zdalnych. Dzięki narzędziom i technologiom wymienionym w tym samouczku deweloperzy mogą efektywnie pracować z aplikacjami w kontenerach bez opuszczania środowiska IDE.

Czego się nauczysz

Z tego modułu dowiesz się, jak tworzyć aplikacje w kontenerach w Google Cloud, w tym:

Tworzenie aplikacji startowej w Node.js
Konfigurowanie aplikacji Node.js na potrzeby tworzenia kontenerów
Kodowanie prostej usługi REST CRUD
Wdrażanie w GKE
Debugowanie stanu błędu
Korzystanie z punktu przerwania lub logów
Szybkie wdrażanie zmian z powrotem w GKE
Opcjonalnie: integracja CloudSQL na potrzeby trwałości backendu

2. Konfiguracja i wymagania

Samodzielne konfigurowanie środowiska

Zaloguj się w konsoli Google Cloud i utwórz nowy projekt lub użyj istniejącego. Jeśli nie masz jeszcze konta Gmail lub Google Workspace, musisz je utworzyć.

Nazwa projektu to wyświetlana nazwa dla uczestników tego projektu. Jest to ciąg znaków, który nie jest używany przez interfejsy API Google. Możesz ją zaktualizować w dowolnym momencie.
Identyfikator projektu jest unikalny we wszystkich projektach Google Cloud i nie można go zmienić po ustawieniu. Konsola Cloud automatycznie generuje unikalny ciąg znaków. Zwykle nie musisz się nim przejmować. W większości przewodników programowania musisz odwoływać się do identyfikatora projektu (zwykle jest on oznaczony jako PROJECT_ID). Jeśli wygenerowany identyfikator Ci się nie podoba, możesz wygenerować inny losowy identyfikator. Możesz też spróbować utworzyć własny adres i sprawdzić, czy jest dostępny. Po tym kroku nie można go zmienić i będzie obowiązywać przez cały czas trwania projektu.
Warto wiedzieć, że istnieje trzecia wartość, numer projektu, której używają niektóre interfejsy API. Więcej informacji o tych 3 wartościach znajdziesz w dokumentacji.

Następnie musisz włączyć płatności w konsoli Cloud, aby korzystać z zasobów i interfejsów API Google Cloud. Ukończenie tego laboratorium nie powinno wiązać się z dużymi kosztami, a nawet z żadnymi. Aby wyłączyć zasoby i uniknąć naliczania opłat po zakończeniu tego samouczka, możesz usunąć utworzone zasoby lub cały projekt. Nowi użytkownicy Google Cloud mogą skorzystać z programu bezpłatnego okresu próbnego, w którym mają do dyspozycji środki w wysokości 300 USD.

Uruchamianie edytora Cloud Shell

Ten moduł został zaprojektowany i przetestowany pod kątem używania w edytorze Google Cloud Shell. Aby uzyskać dostęp do edytora:

uzyskać dostęp do projektu Google na stronie https://console.cloud.google.com;
W prawym górnym rogu kliknij ikonę edytora Cloud Shell.

U dołu okna otworzy się nowy panel.
Kliknij przycisk Otwórz edytor.

Edytor otworzy się z eksploratorem po prawej stronie i edytorem w środkowej części.
U dołu ekranu powinien być też dostępny panel terminala.
Jeśli terminal NIE jest otwarty, użyj kombinacji klawiszy „Ctrl+`”, aby otworzyć nowe okno terminala.

Konfigurowanie gcloud

W Cloud Shell ustaw identyfikator projektu i region, w którym chcesz wdrożyć aplikację. Zapisz je jako zmienne PROJECT_ID i REGION.

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

wdrożyć infrastrukturę używaną w tym module;

W tym module wdrożysz kod w GKE i uzyskasz dostęp do danych przechowywanych w bazie danych Cloud SQL. Poniższy skrypt konfiguracji przygotuje tę infrastrukturę.

Pobierz skrypt konfiguracji i ustaw go jako wykonywalny.

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

Otwórz plik setup_with_cw.sh i edytuj wartości haseł, które są obecnie ustawione na CHANGEME.
Uruchom skrypt konfiguracji, aby utworzyć klaster GKE i bazę danych Cloud SQL, które będą używane w tym module.

./setup_with_cw.sh &

Klaster Cloud Workstations

Otwórz Cloud Workstations w Cloud Console. Poczekaj, aż klaster osiągnie stan READY.

Tworzenie konfiguracji stacji roboczych

Jeśli sesja Cloud Shell została odłączona, kliknij „Połącz ponownie”, a następnie uruchom polecenie gcloud cli, aby ustawić identyfikator projektu. Przed uruchomieniem polecenia zastąp przykładowy identyfikator projektu poniżej identyfikatorem projektu Qwiklabs.

gcloud config set project qwiklabs-gcp-project-id

Aby utworzyć konfigurację Cloud Workstations, pobierz i uruchom w terminalu poniższy skrypt.

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

Sprawdź wyniki w sekcji Konfiguracje. Przejście do stanu GOTOWY zajmie 2 minuty.

Otwórz Cloud Workstations w konsoli i utwórz nową instancję.

Zmień nazwę na my-workstation i wybierz istniejącą konfigurację: codeoss-js.

Sprawdź wyniki w sekcji Stacje robocze.

Uruchom stację roboczą

Uruchom stację roboczą. Uruchomienie stacji roboczej zajmie kilka minut.

Zezwól na pliki cookie innych firm, klikając ikonę na pasku adresu.

Kliknij „Strona nie działa?”.

Kliknij „Zezwalaj na pliki cookie”.

Po uruchomieniu stacji roboczej pojawi się środowisko IDE Code OSS. Na stronie Wprowadzenie w środowisku IDE stacji roboczej kliknij „Oznacz jako gotowe”.

3. Tworzenie nowej aplikacji startowej Node.js

W tej sekcji utworzysz nową aplikację Node.js.

Otwórz nowy terminal.

W Cloud Shell utwórz nowy katalog o nazwie mynodejsapp.

mkdir mynodejsapp

Jeśli zobaczysz ten komunikat, kliknij przycisk Zezwól, aby móc kopiować i wklejać na stacji roboczej.

Przejdź do tego katalogu i otwórz go jako obszar roboczy. Spowoduje to ponowne wczytanie edytora przez utworzenie konfiguracji obszaru roboczego w nowo utworzonym folderze.

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

Ponownie otwórz nowy terminal. Zainstaluj Node i NPM za pomocą 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. Tworzenie nowej aplikacji startowej

Zainicjuj aplikację

Utwórz plik package.json, uruchamiając to polecenie:

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"
}

Dodawanie punktu wejścia

Otwórz i edytuj plik package.json w IDE, aby uwzględnić polecenie startowe w skrypcie "start": "node src/index.js",. Po zmianie skrypty powinny wyglądać tak, jak w poniższym fragmencie kodu:

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

Dodawanie zależności Express

Dodawany przez nas kod również korzysta z express, więc dodajmy tę zależność do pliku package.json. Po wprowadzeniu wszystkich zmian plik package.json powinien wyglądać jak poniżej.

{
 "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"
 }
}

Utwórz plik index.js

Utwórz katalog źródłowy o nazwie src, wybierając Nowy folder w widoku eksploratora.

Utwórz plik src/index.js

z tym kodem

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

});

Zwróć uwagę, że PORT ma wartość 8080

Generowanie plików manifestu

Skaffold udostępnia zintegrowane narzędzia, które upraszczają tworzenie kontenerów. W tym kroku zainicjujesz Skaffold, który automatycznie utworzy podstawowe pliki YAML Kubernetes. Aby rozpocząć proces, wykonaj poniższe polecenie.

Uruchom w terminalu to polecenie:

skaffold init --generate-manifests

Gdy pojawi się odpowiedni komunikat:

Wpisz 8080 jako numer portu.
Wpisz y, aby zapisać konfigurację.

Do obszaru roboczego zostaną dodane 2 pliki: skaffold.yaml i deployment.yaml.

Aktualizowanie nazwy aplikacji

Wartości domyślne uwzględnione w konfiguracji nie pasują obecnie do nazwy Twojej aplikacji. Zaktualizuj pliki, aby odwoływały się do nazwy aplikacji, a nie do wartości domyślnych.

Zmiana wpisów w konfiguracji Skaffold

Otwórz: skaffold.yaml
Wybierz nazwę obrazu, która jest obecnie ustawiona jako package-json-image.
Kliknij prawym przyciskiem myszy i wybierz Zmień wszystkie wystąpienia.
Wpisz nową nazwę w formacie mynodejsapp

Zmiana wpisów w konfiguracji Kubernetes

Otwórz plik deployment.yaml
Wybierz nazwę obrazu, która jest obecnie ustawiona jako package-json-image.
Kliknij prawym przyciskiem myszy i wybierz Zmień wszystkie wystąpienia.
Wpisz nową nazwę w formacie mynodejsapp

Zwróć uwagę, że w pliku skaffold.yaml sekcja build używa buildpacks do umieszczania aplikacji w kontenerze. Ten kod nie ma pliku Dockerfile, a deweloper nie musi znać Dockera, aby umieścić tę aplikację w kontenerze.

Ta konfiguracja Skaffold automatycznie włącza też szybką synchronizację między edytorem a działającym kontenerem. Aby włączyć szybką synchronizację, nie musisz niczego dodatkowo konfigurować.

5. Omówienie procesu tworzenia

W tej sekcji wykonasz kilka czynności za pomocą wtyczki Cloud Code, aby poznać podstawowe procesy i sprawdzić konfigurację aplikacji startowej.

Cloud Code jest zintegrowany ze Skaffold, aby usprawnić proces programowania. Gdy w kolejnych krokach wdrożysz aplikację w GKE, Cloud Code i Skaffold automatycznie skompilują obraz kontenera, wypchną go do Container Registry, a następnie wdrożą aplikację w GKE. Dzieje się to za kulisami, co pozwala deweloperowi skupić się na innych aspektach. Cloud Code usprawnia też proces programowania, zapewniając tradycyjne funkcje debugowania i szybkiej synchronizacji w przypadku programowania opartego na kontenerach.

Kliknij ikonę Cloud Code i wybierz „Zaloguj się w Google Cloud”:

Kliknij „Przejdź do logowania”.

Sprawdź dane wyjściowe w terminalu i otwórz link:

Zaloguj się, używając danych logowania ucznia Qwiklabs.

Wybierz „Zezwól”:

Skopiuj kod weryfikacyjny i wróć na kartę stacji roboczej.

Wklej kod weryfikacyjny i naciśnij Enter.

Dodawanie klastra Kubernetes

Dodawanie klastra

Wybierz Google Kubernetes Engine:

Wybierz projekt.

Wybierz „mycluster” utworzony podczas konfiguracji początkowej.

Klaster pojawi się teraz na liście klastrów Kubernetes w Cloud Code. Możesz tu poruszać się po klastrze i go poznawać.

Ustawianie bieżącego identyfikatora projektu za pomocą gcloud CLI

Skopiuj identyfikator projektu na potrzeby tego modułu ze strony Qwiklabs.

W terminalu uruchom polecenie gcloud CLI, aby ustawić identyfikator projektu. Przed uruchomieniem polecenia zastąp przykładowy identyfikator projektu. Przed uruchomieniem polecenia poniżej ZASTĄP identyfikator projektu.

gcloud config set project qwiklabs-gcp-project-id

Wdrażanie w Kubernetes

W panelu u dołu edytora Cloud Shell wybierz Cloud Code

W panelu, który pojawi się u góry w sekcji SESJE DEWELOPERSKIE, kliknij Uruchom w Kubernetes. Jeśli pojawi się taka prośba, wybierz Yes (Tak), aby użyć bieżącego kontekstu Kubernetes.

Gdy po raz pierwszy uruchomisz to polecenie, u góry ekranu pojawi się pytanie, czy chcesz użyć bieżącego kontekstu Kubernetes. Aby zaakceptować i użyć bieżącego kontekstu, kliknij „Yes” (Tak).

Następnie pojawi się pytanie o to, którego repozytorium kontenerów chcesz użyć. Naciśnij Enter, aby zaakceptować podaną wartość domyślną.

Wybierz kartę Output (Dane wyjściowe) w dolnym okienku i Kubernetes: Run/Debug (Kubernetes: uruchom/debuguj) w menu, aby wyświetlić postęp i powiadomienia.

Aby wyświetlić dodatkowe szczegóły i dzienniki przesyłane strumieniowo na żywo z kontenerów, w menu po prawej stronie wybierz „Kubernetes: Run/Debug - Detailed” (Kubernetes: uruchamianie/debugowanie – szczegółowe).

Aby wrócić do widoku uproszczonego, w menu wybierz „Kubernetes: Uruchom/Debuguj”.
Po zakończeniu kompilacji i testów na karcie Wyniki pojawi się komunikat Resource deployment/mynodejsapp status completed successfully i adres URL: „Forwarded URL from service demo-app: http://localhost:8080” (Przekierowany adres URL z usługi demo-app: http://localhost:8080).
W terminalu Cloud Code najedź kursorem na adres URL w danych wyjściowych (http://localhost:8080), a następnie w wyświetlonej etykiecie narzędzia wybierz Follow Link (Otwórz link).

Odpowiedź będzie następująca:

{"message":"Greetings from Node"}

Gorące przeładowanie

Wejdź na src/index.js. Edytuj kod wiadomości powitalnej: 'Hello from Node'

Zauważ, że w oknie Output, w widoku Kubernetes: Run/Debug, obserwator synchronizuje zaktualizowane pliki z kontenerem w 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

Jeśli przełączysz się na widok Kubernetes: Run/Debug - Detailed, zauważysz, że rozpoznaje on zmiany w pliku i ponownie uruchamia węzeł.

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/

Aby zobaczyć zaktualizowane wyniki, odśwież przeglądarkę.

Debugowanie

Otwórz widok debugowania i zatrzymaj bieżący wątek .
Kliknij Cloud Code w menu u dołu i wybierz Debug on Kubernetes, aby uruchomić aplikację w trybie debug.

W widoku Kubernetes Run/Debug - Detailed okna Output zauważ, że Skaffold wdroży tę aplikację w trybie debugowania.
Tworzenie i wdrażanie aplikacji zajmie kilka minut. Tym razem zobaczysz dołączony debuger.

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

Dolny pasek stanu zmieni kolor z niebieskiego na pomarańczowy, co oznacza, że jest w trybie debugowania.

W widoku Kubernetes Run/Debug zobaczysz, że uruchomiono kontener z możliwością debugowania.

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

Wykorzystywanie punktów przerwania

Otwórz src/index.js
Znajdź zdanie var message="Hello from Node";.
Dodaj punkt przerwania do tego wiersza, klikając puste miejsce po lewej stronie numeru wiersza. Pojawi się czerwony wskaźnik, który oznacza, że punkt przerwania został ustawiony.
Odśwież przeglądarkę i zwróć uwagę, że debuger zatrzymuje proces w punkcie przerwania i umożliwia zbadanie zmiennych oraz stanu aplikacji, która działa zdalnie w GKE.
Klikaj w sekcji zmiennych, aż znajdziesz zmienną "message".
Wykonaj wiersz, klikając Krok dalej .
Obserwuj, jak bieżąca wartość zmiennej "message" zmienia się na "Hello from Node".
Kliknij dwukrotnie nazwę zmiennej „target” i w wyskakującym okienku zmień wartość na inną, np. "Hi from Node".
Na panelu sterowania debugowaniem kliknij przycisk Dalej.
Sprawdź odpowiedź w przeglądarce, w której powinna się teraz wyświetlać wpisana przez Ciebie zaktualizowana wartość.
Zatrzymaj tryb „Debug” (Debugowanie), naciskając przycisk zatrzymania , i usuń punkt przerwania, klikając go ponownie.

6. Tworzenie prostej usługi REST CRUD

Na tym etapie aplikacja jest w pełni skonfigurowana pod kątem tworzenia skonteneryzowanych aplikacji, a Ty znasz już podstawowy przepływ pracy programisty w Cloud Code. W kolejnych sekcjach przećwiczysz zdobytą wiedzę, dodając punkty końcowe usługi REST łączące się z zarządzaną bazą danych w Google Cloud.

Konfigurowanie zależności

Kod aplikacji używa bazy danych do przechowywania danych usługi REST. Upewnij się, że zależności są dostępne, dodając w pliku package.json ten kod:

Dodaj do pliku package.json jeszcze 2 zależności: pg i sequelize, aby utworzyć aplikację CRUD Postgres. Sekcja zależności po opublikowaniu zmian będzie wyglądać tak:

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

Kodowanie usługi REST

Dodawanie do tej aplikacji kodu aplikacji CRUD

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

unzip app.zip

Ten kod ma

folder models z modelem jednostki dla item;
folder controllers z kodem, który wykonuje operacje CRUD;
folder routes, który kieruje określone wzorce adresów URL do różnych wywołań;
Folder config ze szczegółami połączenia z bazą danych.

Zwróć uwagę, że konfiguracja bazy danych w pliku db.config.js odnosi się do zmiennych środowiskowych, które należy podać, aby połączyć się z bazą danych. Musisz też przeanalizować żądanie przychodzące pod kątem kodowania adresu URL.
Dodaj poniższy fragment kodu w src/index.js, aby móc połączyć się z kodem CRUD z głównego pliku JavaScript tuż przed ostatnią sekcją, która zaczyna się od app.listen(PORT, () => {

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);

Edytuj wdrożenie w pliku deployment.yaml, aby dodać zmienne środowiskowe, które będą zawierać informacje o połączeniu z bazą danych.

Zaktualizuj wpis specyfikacji na końcu pliku, aby pasował do tej definicji:

    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

Zastąp wartość DB_HOST adresem bazy danych.

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

Wdrażanie i weryfikowanie aplikacji

W panelu u dołu edytora Cloud Shell kliknij Cloud Code, a następnie u góry ekranu kliknij Debug on Kubernetes.
Po zakończeniu kompilacji i testów na karcie Wyniki pojawi się komunikat Resource deployment/mynodejsapp status completed successfully oraz adres URL: „Forwarded URL from service mynodejsapp: http://localhost:8080”.
Dodaj kilka produktów.

W terminalu Cloud Shell uruchom te polecenia:

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"

Sprawdź żądanie GET, uruchamiając $URL/items w przeglądarce. Polecenie curl możesz też uruchomić z wiersza poleceń.

curl -X GET $URL/items

Test Delete: teraz spróbuj usunąć element, uruchamiając to polecenie: W razie potrzeby zmień wartość identyfikatora produktu.

curl -X DELETE $URL/items/1

    This throws an error message

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

Identyfikowanie i rozwiązywanie problemu

Aplikacja działa w trybie debugowania. Użyj punktów przerwania, aby znaleźć problem. Oto kilka porad:

Wiemy, że z metodą DELETE jest coś nie tak, ponieważ nie zwraca ona oczekiwanego wyniku. Punkt przerwania należy ustawić w metodzie itemcontroller.js->exports.delete.
Uruchom wykonywanie krok po kroku i obserwuj zmienne na każdym etapie, aby zobaczyć wartości zmiennych lokalnych w oknie po lewej stronie.
Aby obserwować konkretne wartości, np. request.params, dodaj tę zmienną do okna Obserwowanie.

Zwróć uwagę, że wartość przypisana do id to undefined. Zmień kod, aby rozwiązać problem.

Poprawiony fragment kodu wyglądałby tak:

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

Po ponownym uruchomieniu aplikacji spróbuj usunąć plik.
Zakończ sesję debugowania, klikając czerwony kwadrat na pasku narzędzi debugowania .

7. Czyszczenie

Gratulacje! W tym module udało Ci się utworzyć od podstaw nową aplikację Node.js i skonfigurować ją do pracy w trybie wdrożenia na gorąco z kontenerami. Następnie wdrożono i debugowano aplikację w zdalnym klastrze GKE, korzystając z tego samego przepływu pracy dewelopera, który jest stosowany w tradycyjnych stosach aplikacji.

Aby zwolnić miejsce po ukończeniu modułu:

Usuwanie plików użytych w module

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

Usuwanie projektu w celu usunięcia całej powiązanej infrastruktury i zasobów