InnerLoop-Entwicklung mit Cloud Workstations mit Python

1. Übersicht

In diesem Lab werden Funktionen und Möglichkeiten vorgestellt, die den Entwicklungsablauf für Softwareentwickler optimieren sollen, die Python-Anwendungen in einer containerisierten Umgebung 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:

• Neue Python-Starteranwendung erstellen
• Entwicklungsprozess durchlaufen
• Einfachen REST-CRUD-Dienst entwickeln
• In GKE bereitstellen
• Fehlerstatus beheben
• Haltepunkte / Logs verwenden
• Änderungen per Hot-Deployment in GKE bereitstellen

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

Achtung:Eine Projekt-ID ist global eindeutig und kann nach der Auswahl nicht mehr von anderen verwendet werden. Sie sind der einzige Nutzer dieser ID. Auch 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 zu verwenden. Die Durchführung dieses Codelabs sollte keine oder nur geringe Kosten verursachen. Wenn Sie Ressourcen herunterfahren möchten, damit Ihnen nach Abschluss dieser Anleitung keine Kosten mehr in Rechnung gestellt werden, können Sie die von Ihnen erstellten Ressourcen oder das gesamte Projekt löschen. Neue Nutzer von Google Cloud kommen für das Programm für kostenlose Testversionen mit einem Guthaben von 300$ infrage.

Cloud Shell-Editor starten

Dieses Lab wurde für die Verwendung mit Google Cloud Shell Editor entwickelt und getestet. So greifen Sie auf den Editor zu:

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.

Umgebung einrichten

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

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

Die in diesem Lab verwendete Infrastruktur bereitstellen

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

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. Öffnen Sie die Datei setup_with_cw.sh und bearbeiten Sie die Werte der Passwörter, die derzeit auf CHANGEME festgelegt sind.
3. Führen Sie das Einrichtungsskript aus, um einen GKE-Cluster und eine Spanner-Datenbank zu erstellen, die Sie in diesem Lab verwenden.

./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 Ihre Cloud Shell-Sitzung getrennt wurde, klicken Sie auf „Reconnect“ (Wiederverbinden) und führen Sie dann den gcloud-CLI-Befehl aus, um die Projekt-ID festzulegen. Ersetzen Sie die Beispielprojekt-ID unten durch Ihre Qwiklabs-Projekt-ID, bevor Sie den Befehl ausführen.

gcloud config set project qwiklabs-gcp-project-id

2. Laden Sie das folgende Skript herunter und führen Sie es im Terminal aus, um eine Cloud Workstations-Konfiguration zu erstellen.

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

3. Überprüfen Sie die Ergebnisse im Bereich „Konfigurationen“. Es dauert 2 Minuten, bis der Status zu „BEREIT“ wechselt.

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 codeoss-python aus.

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

Workstation starten

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

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

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

4. Klicken Sie auf „Cookies zulassen“.

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

3. Neue Python-Starteranwendung 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"

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

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

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 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 in einer Python Flask-App automatisch neu laden. Mit diesem Dockerfile können Sie diesen Wert als Build-Argument übergeben.

Manifeste generieren

Führen Sie im Terminal den folgenden Befehl aus, um eine Standarddatei „skaffold.yaml“ und „deployment.yaml“ zu generieren.

1. Initialisieren Sie Skaffold mit dem folgenden Befehl:

skaffold init --generate-manifests

Wenn Sie dazu aufgefordert werden, verwenden Sie die Pfeiltasten, um den Cursor zu bewegen, und die Leertaste, um die Optionen auszuwählen.

Wählen Sie aus:

• 8080 für den Port
• y, um die Konfiguration zu speichern

Skaffold-Konfigurationen aktualisieren

• Standardmäßigen Anwendungsnamen ändern
• skaffold.yaml öffnen
• Wählen Sie den Bildnamen 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, um
• docker.buildArgs zur Karte FLASK_DEBUG=1 hinzufügen
• Synchronisieren Sie die Einstellungen, um Änderungen an *.py-Dateien aus der IDE in den laufenden Container zu laden.

Nach den Änderungen 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. Standardname ändern

• deployment.yaml-Datei öffnen
• Wählen Sie den Bildnamen 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. Entwicklungsprozess durchlaufen

Nachdem Sie die Geschäftslogik hinzugefügt haben, können Sie Ihre Anwendung bereitstellen und testen. Im folgenden Abschnitt wird die Verwendung des Cloud Code-Plug-ins beschrieben. Dieses Plug-in ist unter anderem in Skaffold integriert, um Ihren Entwicklungsprozess zu optimieren. Wenn Sie die Bereitstellung in GKE in den folgenden Schritten vornehmen, erstellen Cloud Code und Skaffold automatisch Ihr Container-Image, übertragen es per Push in eine Container Registry und stellen dann die your-Anwendung in GKE bereit. Dies geschieht im Hintergrund und die Details werden vom Entwicklerfluss abstrahiert.

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 „Weiter zur Anmeldung“.

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

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

5. Wählen Sie „Zulassen“ aus:

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

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

Kubernetes-Cluster hinzufügen

1. Cluster hinzufügen

2. Wählen Sie Google Kubernetes Engine aus:

3. Wählen Sie ein Projekt aus.

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

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

2. Führen Sie im Terminal den gcloud CLI-Befehl aus, um die Projekt-ID festzulegen. Ersetzen Sie die Beispielprojekt-ID, bevor Sie den Befehl ausführen. Ersetzen Sie die Projekt-ID, bevor Sie den folgenden Befehl ausführen.

gcloud config set project qwiklabs-gcp-project-id

In Kubernetes bereitstellen

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

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

Mit diesem Befehl wird der Quellcode erstellt und dann werden die Tests ausgeführt. Das Erstellen und Testen dauert einige Minuten. Diese Tests umfassen Unittests und einen Validierungsschritt, mit dem die für die Bereitstellungsumgebung festgelegten Regeln geprüft werden. Dieser Validierungsschritt ist bereits konfiguriert und sorgt dafür, dass Sie vor Bereitstellungsproblemen gewarnt werden, auch wenn Sie noch in Ihrer Entwicklungsumgebung arbeiten.

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. Wählen Sie im Drop-down-Menü „Kubernetes: Run/Debug“ aus.

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.

Wenn der Build und die Tests abgeschlossen sind, wird in den Logs auf dem Tab „Ausgabe“ die URL „http://localhost:8080“ in der Ansicht „Kubernetes: Ausführen/Debuggen“ aufgeführt.

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 die Option „Webvorschau öffnen“ aus.
8. Ein neuer Browsertab wird geöffnet und die Meldung Hello, World! wird angezeigt.

Hot Reload

1. Öffnen Sie die Datei app.py.
2. Ändere den Begrüßungstext in Hello from Python.

Im Output-Fenster, Kubernetes: Run/Debug-Ansicht, synchronisiert der Watcher die aktualisierten Dateien mit dem Container in 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. Wenn Sie zur Ansicht Kubernetes: Run/Debug - Detailed wechseln, werden Sie feststellen, dass Dateiänderungen erkannt und die App dann neu erstellt und 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 Browser-Tab, auf dem Sie die vorherigen 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 jedem Lauf eine Reinigung durchführen.
2. 
3. 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.

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

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

5. Die untere Statusleiste ändert ihre Farbe von Blau zu Orange, was darauf hinweist, dass sie sich im Debug-Modus befindet.
6. In der Ansicht Kubernetes Run/Debug sehen Sie, dass ein debugfähiger Container gestartet wurde.

**************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 Aussage return message.
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. Wenn das Skript zum ersten Mal ausgeführt wird, werden Sie aufgefordert, den Speicherort der Quelle im Container anzugeben. Dieser Wert bezieht sich auf die Verzeichnisse im Dockerfile.

Eingabetaste drücken, um den Standardwert zu übernehmen

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

5. 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.
6. Klicken Sie auf den Abschnitt „VARIABLEN“.
7. Klicken Sie auf „Locals“. Dort finden Sie die Variable "message".
8. Doppelklicken Sie auf den Variablennamen „message“ und ändern Sie den Wert im Pop-up-Fenster in einen anderen Wert, z. B. "Greetings from Python".
9. Klicken Sie in der Debugging-Steuerung 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.

Rest-Dienst programmieren

Mit dem folgenden Code wird ein einfacher REST-Dienst 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

Wenn Sie eine sichere Verbindung zu Cloud Spanner herstellen möchten, richten Sie die Anwendung für die Verwendung von Workload Identities ein. So kann Ihre Anwendung als eigenes Dienstkonto fungieren und beim Zugriff auf die Datenbank individuelle Berechtigungen haben.

1. deployment.yaml aktualisieren. Fügen Sie am Ende der Datei den folgenden Code ein (achten Sie darauf, dass die Tabulatoren im folgenden Beispiel erhalten bleiben).

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

Nach den Änderungen sollte der Abschnitt „spec“ so 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 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/python-app status completed successfully angezeigt und eine URL wird aufgeführt: „Weitergeleitete URL vom Dienst 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-Vorgang, indem Sie den folgenden Befehl im Terminal ausführen.

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

5. Testen Sie das Löschen: Versuchen Sie nun, einen Eintrag zu löschen, indem Sie den folgenden Befehl ausführen. Ändern Sie bei Bedarf 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 identifizieren und beheben

1. Fehlerbehebungsmodus aktivieren und das Problem finden Hier einige Tipps:

• Wir wissen, dass mit dem DELETE-Befehl etwas nicht stimmt, da er nicht das gewünschte Ergebnis zurückgibt. Sie würden den Haltepunkt also in app.py in der Methode delete_singer 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 singer_id und request.args beobachten möchten, fügen Sie diese Variablen dem Fenster „Überwachen“ hinzu.

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

Das korrigierte Code-Snippet sieht so aus:

@app.route('/delete-singer', methods=['DELETE', 'GET'])
def delete_singer():
    try:
        singer_id = request.args.get('singer_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 Python-Anwendung von Grund auf erstellt und so konfiguriert, dass sie effektiv mit Containern zusammenarbeitet. 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 ~/music-service

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