Programowanie InnerLoop z użyciem Cloud Workstations w Pythonie

1. Przegląd

W tym module dowiesz się o funkcjach i możliwościach, które usprawniają proces tworzenia aplikacji w Pythonie w środowisku skonteneryzowanym. 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

W tym module poznasz metody tworzenia aplikacji w kontenerach w GCP, w tym:

• Tworzenie nowej aplikacji startowej w Pythonie
• Omów proces tworzenia
• Tworzenie 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

2. Konfiguracja i wymagania

Samodzielne konfigurowanie środowiska

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

Ostrzeżenie: identyfikator projektu jest unikalny na całym świecie i po jego wybraniu nie może być używany przez nikogo innego. Jesteś jedynym użytkownikiem tego identyfikatora. Nawet jeśli projekt zostanie usunięty, identyfikator nie będzie już nigdy używany.

Uwaga: jeśli używasz konta Gmail, możesz pozostawić domyślną lokalizację ustawioną na Brak organizacji. Jeśli używasz konta Google Workspace, wybierz lokalizację odpowiednią dla Twojej organizacji.

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

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

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

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

Konfiguracja środowiska

W Cloud Shell ustaw identyfikator projektu i numer projektu. Zapisz je jako zmienne PROJECT_ID i PROJECT_ID.

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 Spanner. Jako środowiska IDE będziesz też używać stacji roboczych w chmurze. Poniższy skrypt konfiguracji przygotuje tę infrastrukturę.

1. Pobierz skrypt konfiguracji i ustaw go jako wykonywalny.

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

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

./setup_with_cw.sh &

Klaster Cloud Workstations

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

Tworzenie konfiguracji stacji roboczych

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

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

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

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

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

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

6. Sprawdź wyniki w sekcji Stacje robocze.

Uruchom stację roboczą

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

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

3. Kliknij „Strona nie działa?”.

4. Kliknij „Zezwalaj na pliki cookie”.

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

W tej sekcji utworzysz nową aplikację w Pythonie.

1. Otwórz nowy terminal.

2. Utwórz nowy katalog i otwórz go jako obszar roboczy

mkdir music-service && cd music-service

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

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

3. Utwórz plik o nazwie requirements.txt i skopiuj do niego tę treść:

Flask
gunicorn
google-cloud-spanner
ptvsd==4.3.2

4. Utwórz plik o nazwie app.py i wklej do niego ten kod:

import os
from flask import Flask, request, jsonify
from google.cloud import spanner

app = Flask(__name__)

@app.route("/")
def hello_world():
    message="Hello, World!"
    return message

if __name__ == '__main__':
    server_port = os.environ.get('PORT', '8080')
    app.run(debug=False, port=server_port, host='0.0.0.0')

5. Utwórz plik o nazwie Dockerfile i wklej do niego ten kod:

FROM python:3.8
ARG FLASK_DEBUG=0
ENV FLASK_DEBUG=$FLASK_DEBUG
ENV FLASK_APP=app.py
WORKDIR /app
COPY requirements.txt .
RUN pip install --trusted-host pypi.python.org -r requirements.txt
COPY . .
ENTRYPOINT ["python3", "-m", "flask", "run", "--port=8080", "--host=0.0.0.0"]

Uwaga: FLASK_DEBUG=1 umożliwia automatyczne ponowne wczytywanie zmian w kodzie aplikacji Flask w języku Python. Ten plik Dockerfile umożliwia przekazywanie tej wartości jako argumentu kompilacji.

Generowanie plików manifestu

W terminalu uruchom to polecenie, aby wygenerować domyślne pliki skaffold.yaml i deployment.yaml:

1. Zainicjuj Skaffold za pomocą tego polecenia:

skaffold init --generate-manifests

Gdy pojawi się odpowiedni komunikat, użyj strzałek, aby przesunąć kursor, a spacji, aby wybrać opcje.

Wybierz:

• 8080 za port
• y, aby zapisać konfigurację.

Aktualizowanie konfiguracji Skaffold

• Zmiana nazwy aplikacji domyślnej
• Otwórz: skaffold.yaml
• Wybierz nazwę obrazu, która jest obecnie ustawiona jako dockerfile-image.
• Kliknij prawym przyciskiem myszy i wybierz Zmień wszystkie wystąpienia.
• Wpisz nową nazwę w formacie python-app
• Dalsze edytowanie sekcji kompilacji
• dodaj docker.buildArgs do karty FLASK_DEBUG=1
• Synchronizuj ustawienia, aby wczytać zmiany w plikach *.py z IDE do uruchomionego kontenera.

Po wprowadzeniu zmian sekcja kompilacji w pliku skaffold.yaml będzie wyglądać tak:

build:
 artifacts:
 - image: python-app
   docker:
     buildArgs:
       FLASK_DEBUG: "1"
     dockerfile: Dockerfile
   sync:
     infer:
     - '**/*.py'

Modyfikowanie pliku konfiguracyjnego Kubernetes

1. Zmiana domyślnej nazwy

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

4. Omówienie procesu tworzenia

Po dodaniu logiki biznesowej możesz wdrożyć i przetestować aplikację. W sekcji poniżej pokazujemy, jak używać wtyczki Cloud Code. Ta wtyczka jest między innymi zintegrowana z narzędziem Skaffold, aby usprawnić proces tworzenia. 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ę your w GKE. Dzieje się to za kulisami, co pozwala deweloperowi skupić się na innych aspektach.

Logowanie się do Google Cloud

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

2. Kliknij „Przejdź do logowania”.

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

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

5. Wybierz „Zezwól”:

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

7. Wklej kod weryfikacyjny i naciśnij Enter.

Dodawanie klastra Kubernetes

1. Dodawanie klastra

2. Wybierz Google Kubernetes Engine:

3. Wybierz projekt.

4. Wybierz „python-cluster”, który został utworzony podczas konfiguracji początkowej.

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

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

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

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

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

To polecenie rozpoczyna kompilację kodu źródłowego, a następnie uruchamia testy. Kompilacja i testy potrwają kilka minut. Obejmują one testy jednostkowe i krok weryfikacji, który sprawdza reguły ustawione dla środowiska wdrażania. Ten krok weryfikacji jest już skonfigurowany i zapewnia, że otrzymasz ostrzeżenie o problemach z wdrożeniem, nawet jeśli nadal pracujesz w środowisku programistycznym.

3. 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).
4. Następnie pojawi się pytanie o to, którego repozytorium kontenerów chcesz użyć. Naciśnij Enter, aby zaakceptować podaną wartość domyślną.
5. Aby wyświetlić postęp i powiadomienia, w dolnym panelu kliknij kartę „Dane wyjściowe”. Z menu wybierz „Kubernetes: Run/Debug” (Kubernetes: uruchom/debuguj).

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

Po zakończeniu kompilacji i testów w logach na karcie Dane wyjściowe w widoku „Kubernetes: Run/Debug” (Kubernetes: uruchamianie/debugowanie) pojawi się adres URL http://localhost:8080.

7. W terminalu Cloud Code najedź kursorem na pierwszy adres URL w danych wyjściowych (http://localhost:8080), a następnie w wyświetlonej etykiecie narzędzia wybierz Otwórz podgląd w przeglądarce.
8. Otworzy się nowa karta przeglądarki z komunikatem Hello, World!.

Gorące przeładowanie

1. Otwórz plik app.py.
2. Zmień wiadomość powitalną na Hello from Python

Zauważ, że w oknie Output, w widoku Kubernetes: Run/Debug, obserwator synchronizuje zaktualizowane pliki z kontenerem w Kubernetes.

Update initiated
Build started for artifact python-app
Build completed for artifact python-app

Deploy started
Deploy completed

Status check started
Resource pod/python-app-6f646ffcbb-tn7qd status updated to In Progress
Resource deployment/python-app status updated to In Progress
Resource deployment/python-app status completed successfully
Status check succeeded
...

3. Jeśli przejdziesz do widoku Kubernetes: Run/Debug - Detailed, zauważysz, że rozpoznaje on zmiany w pliku, a następnie kompiluje i ponownie wdraża aplikację.

files modified: [app.py]
Syncing 1 files for gcr.io/veer-pylab-01/python-app:3c04f58-dirty@sha256:a42ca7250851c2f2570ff05209f108c5491d13d2b453bb9608c7b4af511109bd
Copying files:map[app.py:[/app/app.py]]togcr.io/veer-pylab-01/python-app:3c04f58-dirty@sha256:a42ca7250851c2f2570ff05209f108c5491d13d2b453bb9608c7b4af511109bd
Watching for changes...
[python-app] * Detected change in '/app/app.py', reloading
[python-app] * Restarting with stat
[python-app] * Debugger is active!
[python-app] * Debugger PIN: 744-729-662

4. Odśwież kartę przeglądarki, na której były wyświetlane poprzednie wyniki, aby zobaczyć zaktualizowane wyniki.

Debugowanie

1. Otwórz widok debugowania i zatrzymaj bieżący wątek . Jeśli pojawi się odpowiednie pytanie, możesz wybrać opcję zwalniania miejsca po każdym uruchomieniu.
2. 
3. 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.

4. Po zakończeniu procesu. Zauważysz, że dołączony jest debuger, a na karcie Dane wyjściowe wyświetla się komunikat Attached debugger to container "python-app-8476f4bbc-h6dsl" successfully. i adres URL http://localhost:8080.

Port forwarding pod/python-app-8bd64cf8b-cskfl in namespace default, remote port 5678 -> http://127.0.0.1:5678

5. Dolny pasek stanu zmieni kolor z niebieskiego na pomarańczowy, co oznacza, że jest w trybie debugowania.
6. W widoku Kubernetes Run/Debug zobaczysz, że uruchomiono kontener z możliwością debugowania.

**************URLs*****************
Forwarded URL from service python-app: http://localhost:8080
Debuggable container started pod/python-app-8bd64cf8b-cskfl:python-app (default)
Update succeeded
***********************************

Wykorzystywanie punktów przerwania

1. Otwórz plik app.py.
2. Znajdź zdanie return message.
3. 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.
4. Przy pierwszym uruchomieniu pojawi się pytanie, gdzie w kontenerze znajduje się źródło. Ta wartość jest powiązana z katalogami w pliku Dockerfile.

Naciśnij Enter, aby zaakceptować wartość domyślną.

Kompilacja i wdrożenie aplikacji zajmie kilka minut.

5. 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.
6. Kliknij sekcję ZMIENNE.
7. Kliknij Locals (Lokalne), aby znaleźć zmienną "message".
8. Kliknij dwukrotnie nazwę zmiennej „message” i w wyskakującym okienku zmień wartość na inną, np. "Greetings from Python".
9. W panelu sterowania debugowaniem kliknij przycisk Dalej.
10. Sprawdź odpowiedź w przeglądarce, w której powinna się teraz wyświetlać wpisana przez Ciebie zaktualizowana wartość.
11. Zatrzymaj tryb „Debug” (Debugowanie), naciskając przycisk zatrzymania , i usuń punkt przerwania, klikając go ponownie.

5. 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, które łączą się z zarządzaną bazą danych w Google Cloud.

Kodowanie usługi REST

Poniższy kod tworzy prostą usługę REST, która używa Spannera jako bazy danych obsługującej aplikację. Utwórz aplikację, kopiując do niej poniższy kod.

1. Utwórz główną aplikację, zastępując app.py poniższą treścią.

import os
from flask import Flask, request, jsonify
from google.cloud import spanner


app = Flask(__name__)


instance_id = "music-catalog"

database_id = "musicians"

spanner_client = spanner.Client()
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)


@app.route("/")
def hello_world():
    return "<p>Hello, World!</p>"

@app.route('/singer', methods=['POST'])
def create():
    try:
        request_json = request.get_json()
        singer_id = request_json['singer_id']
        first_name = request_json['first_name']
        last_name = request_json['last_name']
        def insert_singers(transaction):
            row_ct = transaction.execute_update(
                f"INSERT Singers (SingerId, FirstName, LastName) VALUES" \
                f"({singer_id}, '{first_name}', '{last_name}')"
            )
            print("{} record(s) inserted.".format(row_ct))

        database.run_in_transaction(insert_singers)

        return {"Success": True}, 200
    except Exception as e:
        return e



@app.route('/singer', methods=['GET'])
def get_singer():

    try:
        singer_id = request.args.get('singer_id')
        def get_singer():
            first_name = ''
            last_name = ''
            with database.snapshot() as snapshot:
                results = snapshot.execute_sql(
                    f"SELECT SingerId, FirstName, LastName FROM Singers " \
                    f"where SingerId = {singer_id}",
                    )
                for row in results:
                    first_name = row[1]
                    last_name = row[2]
                return (first_name,last_name )
        first_name, last_name = get_singer()  
        return {"first_name": first_name, "last_name": last_name }, 200
    except Exception as e:
        return e


@app.route('/singer', methods=['PUT'])
def update_singer_first_name():
    try:
        singer_id = request.args.get('singer_id')
        request_json = request.get_json()
        first_name = request_json['first_name']
        
        def update_singer(transaction):
            row_ct = transaction.execute_update(
                f"UPDATE Singers SET FirstName = '{first_name}' WHERE SingerId = {singer_id}"
            )

            print("{} record(s) updated.".format(row_ct))

        database.run_in_transaction(update_singer)
        return {"Success": True}, 200
    except Exception as e:
        return e


@app.route('/singer', methods=['DELETE'])
def delete_singer():
    try:
        singer_id = request.args.get('singer')
    
        def delete_singer(transaction):
            row_ct = transaction.execute_update(
                f"DELETE FROM Singers WHERE SingerId = {singer_id}"
            )
            print("{} record(s) deleted.".format(row_ct))

        database.run_in_transaction(delete_singer)
        return {"Success": True}, 200
    except Exception as e:
        return e

port = int(os.environ.get('PORT', 8080))
if __name__ == '__main__':
    app.run(threaded=True, host='0.0.0.0', port=port)

Dodawanie konfiguracji bazy danych

Aby bezpiecznie połączyć się z usługą Spanner, skonfiguruj aplikację tak, aby korzystała z tożsamości obciążeń. Dzięki temu aplikacja może działać jako własne konto usługi i mieć indywidualne uprawnienia dostępu do bazy danych.

1. Zaktualizuj deployment.yaml. Na końcu pliku dodaj ten kod (pamiętaj, aby zachować wcięcia w przykładzie poniżej):

      serviceAccountName: python-ksa
      nodeSelector:
        iam.gke.io/gke-metadata-server-enabled: "true" 

Po wprowadzeniu zmian sekcja specyfikacji powinna wyglądać tak:

   spec:
     containers:
     - name: python-app
       image: python-app
     serviceAccountName: python-ksa
     nodeSelector:
       iam.gke.io/gke-metadata-server-enabled: "true"

Wdrażanie i weryfikowanie aplikacji

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

W terminalu Cloud Shell uruchom to polecenie:

curl -X POST http://localhost:8080/singer -H 'Content-Type: application/json' -d '{"first_name":"Cat","last_name":"Meow", "singer_id": 6}'

4. Przetestuj żądanie GET, uruchamiając w terminalu to polecenie:

curl -X GET http://localhost:8080/singer?singer_id=6

5. Testowanie usuwania: spróbuj teraz usunąć wpis, uruchamiając to polecenie. W razie potrzeby zmień wartość identyfikatora produktu.

curl -X DELETE http://localhost:8080/singer?singer_id=6

    This throws an error message

500 Internal Server Error

Identyfikowanie i rozwiązywanie problemu

1. Użyj trybu debugowania, 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 app.py w metodzie delete_singer.
• 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, takie jak singer_id i request.args, dodaj te zmienne do okna Obserwuj.

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

Poprawiony fragment kodu wyglądałby tak:

@app.route('/delete-singer', methods=['DELETE', 'GET'])
def delete_singer():
    try:
        singer_id = request.args.get('singer_id')

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

6. Czyszczenie

Gratulacje! W tym module udało Ci się utworzyć od podstaw nową aplikację w Pythonie i skonfigurować ją tak, aby skutecznie działała 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:

1. Usuwanie plików użytych w module

cd ~ && rm -rf ~/music-service

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