InnerLoop-Entwicklung mit Cloud Workstations mit Python

1. Übersicht

In diesem Lab werden Funktionen und Möglichkeiten vorgestellt, mit denen Softwareentwickler den Entwicklungsworkflow für die Entwicklung von Python-Anwendungen in einer Containerumgebung optimieren können. 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 GCP kennen, darunter:

• Neue Python-Startanwendung erstellen
• Den Entwicklungsprozess durchgehen
• Einfachen CRUD-Restdienst entwickeln
• In GKE bereitstellen
• Debugging eines Fehlerstatus
• Haltepunkt / Logs verwenden
• Heiß-Deployment von Änderungen zurück in GKE

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

Achtung:Eine Projekt-ID ist global eindeutig und kann nach der Auswahl von niemandem verwendet werden. Sie sind der einzige Nutzer dieser ID. Selbst wenn ein Projekt gelöscht wurde, kann die ID nicht mehr verwendet werden

Hinweis:Wenn Sie ein Gmail-Konto verwenden, können Sie die Standardeinstellung Keine Organisation beibehalten. 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 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:

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

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 außerdem ein Terminalbereich verfügbar sein.
7. Wenn das Terminal NICHT geöffnet ist, verwende die Tastenkombination „Strg +“, um ein neues Terminalfenster zu öffnen

Umgebung einrichten

Legen Sie in Cloud Shell Ihre Projekt-ID und die Projektnummer für Ihr Projekt fest. Speichern Sie sie als Variablen des Typs PROJECT_ID und PROJECT_ID.

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 Spanner-Datenbank gespeichert sind. Außerdem verwenden Sie Cloud-Workstations als IDE. Mit dem Einrichtungsskript unten wird diese Infrastruktur für Sie vorbereitet.

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

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

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

./setup_with_cw.sh &

Cloud Workstations-Cluster

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

Workstationkonfiguration erstellen

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

2. 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/python/workstation_config_setup.sh
chmod +x workstation_config_setup.sh
./workstation_config_setup.sh

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

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

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

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

Workstation starten

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

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

3. Klicken Sie auf „Website funktioniert nicht?“.

4. Klicke auf „Cookies zulassen“.

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

3. Neue Python-Startanwendung erstellen

In diesem Abschnitt erstellen Sie eine neue Python-Anwendung.

1. Öffnen Sie ein neues Terminal.

2. Neues Verzeichnis erstellen und als Arbeitsbereich öffnen

mkdir music-service && cd music-service

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

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

3. Erstellen Sie eine Datei mit dem Namen requirements.txt und kopieren Sie den folgenden Inhalt in diese Datei

Flask
gunicorn
google-cloud-spanner
ptvsd==4.3.2

4. Erstellen Sie eine Datei mit dem Namen app.py und fügen Sie den folgenden Code in diese ein

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. Erstellen Sie eine Datei mit dem Namen Dockerfile und fügen Sie Folgendes ein:

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

Hinweis: Mit FLASK_DEBUG=1 können Sie Codeänderungen an einer Python flask-Anwendung automatisch neu laden. Mit diesem Dockerfile können Sie diesen Wert als Build-Argument übergeben.

Manifeste generieren

Führen Sie in Ihrem Terminal den folgenden Befehl aus, um eine standardmäßige skaffold.yaml-Datei und einedeployment.yaml zu generieren.

1. Initialisieren Sie Skaffold mit dem folgenden Befehl

skaffold init --generate-manifests

Wenn Sie dazu aufgefordert werden, bewegen Sie den Cursor mit den Pfeilen und die Leertaste, um die gewünschten Optionen auszuwählen.

Wählen Sie aus:

• 8080 für den Anschluss
• y zum Speichern der Konfiguration

Skaffold-Konfigurationen aktualisieren

• Standard-App-Namen ändern
• „skaffold.yaml“ öffnen
• Wählen Sie den Image-Namen aus, der derzeit als dockerfile-image festgelegt ist
• Klicken Sie mit der rechten Maustaste und wählen Sie „Alle Vorkommen ändern“ aus.
• Geben Sie den neuen Namen als python-app ein.
• Bearbeiten Sie den Build-Abschnitt weiter,
• docker.buildArgs hinzufügen, um FLASK_DEBUG=1 zu bestehen
• Einstellungen synchronisieren, um Änderungen an *.py-Dateien aus der IDE in den laufenden Container zu laden

Nach der Bearbeitung sieht der Build-Abschnitt in der Datei skaffold.yaml so aus:

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

Kubernetes-Konfigurationsdatei ändern

1. Standardnamen ändern

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

4. Der Entwicklungsprozess

Mit der hinzugefügten Geschäftslogik können Sie Ihre Anwendung jetzt bereitstellen und testen. Im folgenden Abschnitt wird die Verwendung des Cloud Code-Plug-ins beschrieben. Dieses Plug-in lässt sich unter anderem in Skaffold einbinden, um Ihren Entwicklungsprozess zu optimieren. Wenn Sie in den folgenden Schritten ein Deployment in GKE vornehmen, erstellen Cloud Code und Skaffold automatisch das Container-Image, übertragen es per Push in eine Container Registry und stellen dann die your-Anwendung in GKE bereit. Das geschieht im Hintergrund und abstrahiert die Details außerhalb des Entwicklungsablaufs.

In Google Cloud anmelden

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

2. Klicken Sie auf „Zur Anmeldung fortfahren“.

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

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

5. Wählen Sie „Zulassen“ aus:

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

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

Kubernetes-Cluster hinzufügen

1. Cluster hinzufügen

2. Wählen Sie Google Kubernetes Engine aus:

3. Projekt auswählen.

4. Wählen Sie „Python-Cluster“ aus. die bei der Ersteinrichtung erstellt wurde.

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

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

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

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

2. Wählen Sie im daraufhin angezeigten Steuerfeld Run on Kubernetes aus. Wenn Sie dazu aufgefordert werden, wählen Sie „Ja“ aus, um den aktuellen Kubernetes-Kontext zu verwenden.

Dieser Befehl startet einen Build des Quellcodes und führt dann die Tests aus. Die Ausführung des Builds und der Tests dauert einige Minuten. Diese Tests umfassen Einheitentests und einen Validierungsschritt, mit dem die für die Bereitstellungsumgebung festgelegten Regeln geprüft werden. Dieser Validierungsschritt ist bereits konfiguriert und stellt sicher, dass Sie vor Bereitstellungsproblemen eine Warnung erhalten, auch wenn Sie noch in der Entwicklungsumgebung arbeiten.

3. 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.
4. 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
5. Wählen Sie das Feld „Output“ (Ausgabe) aus. , um den Fortschritt und Benachrichtigungen anzuzeigen. Wählen Sie im Drop-down-Menü die Option „Kubernetes: Run/Debug“ aus.

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

Wenn der Build und die Tests abgeschlossen sind, enthalten die Logs auf dem Tab „Output“ (Ausgabe) die URL http://localhost:8080 in „Kubernetes: Run/Debug“. Ansicht.

7. Bewegen Sie den Mauszeiger im Cloud Code-Terminal auf die erste URL in der Ausgabe (http://localhost:8080) und wählen Sie dann in der angezeigten Kurzinfo „Webvorschau öffnen“ aus.
8. Ein neuer Browsertab mit der Meldung „Hello, World!“ wird geöffnet

Heiße Aufladung

1. Öffnen Sie die Datei app.py.
2. Begrüßungsnachricht in Hello from Python ä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
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. Wenn Sie zur Ansicht Kubernetes: Run/Debug - Detailed wechseln, werden Sie feststellen, dass Dateiänderungen erkannt werden und die App erstellt und noch einmal bereitgestellt wird.

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. Aktualisieren Sie den Browsertab, in dem Sie vorherige Ergebnisse gesehen haben, um die aktualisierten Ergebnisse zu sehen.

Debugging

1. Rufen Sie die Debug-Ansicht auf und beenden Sie den aktuellen Thread . Wenn Sie dazu aufgefordert werden, können Sie nach jeder Ausführung eine Bereinigung durchführen.
2. 
3. 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.

4. Wenn der Prozess abgeschlossen ist. Sie sehen, dass ein Debugger angehängt ist, auf dem Tab "Output" (Ausgabe) Attached debugger to container "python-app-8476f4bbc-h6dsl" successfully. angezeigt wird und die URL http://localhost:8080 aufgeführt ist.

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

5. Die Farbe der unteren Statusleiste wechselt von Blau zu Orange, was darauf hinweist, dass der Debug-Modus aktiviert ist.
6. Beachten Sie in der Ansicht Kubernetes Run/Debug, dass ein Debug-fähiger Container gestartet wird.

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

Haltepunkte verwenden

1. Öffnen Sie die Datei app.py.
2. Suchen Sie die Anweisung return message.
3. 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.
4. Wenn Sie dies zum ersten Mal ausführen, werden Sie in einer Eingabeaufforderung gefragt, wo sich die Quelle im Container befindet. Dieser Wert bezieht sich auf die Verzeichnisse im Dockerfile.

Drücken Sie die Eingabetaste, um die Standardeinstellung zu übernehmen

Es dauert einige Minuten, bis die Anwendung erstellt und bereitgestellt ist.

5. 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.
6. Klicken Sie auf den Abschnitt VARIABLES
7. Klicken Sie auf „Lokales“. Dort finden Sie die Variable "message".
8. Doppelklicken Sie auf den Variablennamen „message“. und ändern Sie im Pop-up-Menü den Wert in einen anderen Wert, z. B. "Greetings from Python".
9. Klicken Sie im Steuerfeld zur Fehlerbehebung auf die Schaltfläche „Weiter“ .
10. Sehen Sie sich die Antwort in Ihrem Browser an. Sie enthält jetzt den aktualisierten Wert, den Sie gerade eingegeben haben.
11. „Fehlerbehebung“ beenden indem Sie die Stopp-Schaltfläche drücken. Entfernen Sie den Haltepunkt, indem Sie noch einmal auf den Haltepunkt klicken.

5. Entwickeln eines einfachen CRUD-Restdiensts

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 üben Sie das Gelernte. Sie fügen Dienstendpunkte hinzu, die eine Verbindung zu einer verwalteten Datenbank in Google Cloud herstellen.

Restdienst programmieren

Mit dem folgenden Code wird ein einfacher Ruhedienst erstellt, der Spanner als Datenbank für die Anwendung verwendet. Erstellen Sie die Anwendung, indem Sie den folgenden Code in Ihre Anwendung kopieren.

1. Erstellen Sie die Hauptanwendung, indem Sie app.py durch den folgenden Inhalt ersetzen

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)

Datenbankkonfigurationen hinzufügen

Richten Sie die Anwendung für die Verwendung von Arbeitslastidentitäten ein, um eine sichere Verbindung zu Spanner herzustellen. Dadurch kann Ihre Anwendung als eigenes Dienstkonto fungieren und individuelle Berechtigungen beim Zugriff auf die Datenbank haben.

1. deployment.yaml aktualisieren. Fügen Sie am Ende der Datei den folgenden Code ein. Achten Sie dabei darauf, die Tab-Einzüge im Beispiel unten beizubehalten.

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

Nach den Änderungen sollte der Abschnitt mit den Spezifikationen wie folgt aussehen:

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

Anwendung bereitstellen und validieren

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

Führen Sie im Cloud Shell-Terminal den folgenden Befehl aus:

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

4. Testen Sie den GET-Befehl, indem Sie den folgenden Befehl im Terminal ausführen

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

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

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

    This throws an error message

500 Internal Server Error

Problem ermitteln und beheben

1. Debug-Modus und suchen Sie nach dem Problem. 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 app.py in der Methode delete_singer 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 singer_id und request.args beobachten möchten, fügen Sie diese Variablen dem Beobachtungsfenster hinzu.

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

Das feste Code-Snippet sieht dann so aus:

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

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

6. Bereinigen

Glückwunsch! In diesem Lab haben Sie eine neue Python-Anwendung von Grund auf neu erstellt und so konfiguriert, dass sie effektiv 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:

1. Die im Lab verwendeten Dateien löschen

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

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