Entwicklungs-Workflow mit Gemini Code Assist optimieren

1. Einführung

In diesem Codelab sehen Sie sich an, wie Gemini Code Assist Sie in wichtigen Phasen des Software Development Life Cycle (SDLC) wie Design, Entwicklung und Test sowie Bereitstellung unterstützen kann. Wir entwerfen und entwickeln eine vollständige Anwendung und stellen sie in Google Cloud bereit.

Wir entwickeln eine API und eine Anwendung, mit denen sich in den Sessions einer technischen Veranstaltung suchen lässt. Jede Sitzung hat einen Titel, eine Zusammenfassung, eine Dauer, Kategorien und einen oder mehrere Referenten.

Aufgaben

Webanwendung basierend auf einer OpenAPI-Spezifikation von Grund auf entwerfen, erstellen, testen und bereitstellen

Lerninhalte

OpenAPI-Spezifikation mit Gemini Code Assist generieren
Gemini Code Assist-Funktionen zur Codegenerierung verwenden, um eine Python Flask-Anwendung für die OpenAPI-Spezifikation zu entwickeln
Mit Gemini Code Assist ein Web-Frontend für die Python Flask-Anwendung generieren
Gemini Code Assist verwenden, um Hilfe beim Bereitstellen der Anwendung in Google Cloud Run zu erhalten
Gemini Code Assist-Funktionen wie „Code erklären“ und „Testfallgenerierung“ beim Erstellen und Testen der Anwendung verwenden

Voraussetzungen

Chrome-Webbrowser
Ein Gmail-Konto
Ein Cloud-Projekt mit aktivierter Abrechnung
Gemini Code Assist für Ihr Cloud-Projekt aktiviert

Dieses Lab richtet sich an Entwickler aller Erfahrungsstufen, auch an Anfänger. Obwohl die Beispielanwendung in Python geschrieben ist, müssen Sie sich nicht mit der Python-Programmierung auskennen, um zu verstehen, was passiert. Wir konzentrieren uns darauf, die Funktionen von Gemini Code Assist kennenzulernen.

2. Gemini Code Assist einrichten

In diesem Abschnitt erfahren Sie alles, was Sie für den Einstieg in dieses Lab benötigen.

Gemini Code Assist in der Cloud Shell-IDE aktivieren

Für den Rest des Codelabs verwenden wir die Cloud Shell IDE, eine vollständig verwaltete Entwicklungsumgebung, die auf Code OSS basiert. Wir müssen Code Assist in der Cloud Shell-IDE aktivieren und konfigurieren. Die Schritte dazu sind unten aufgeführt:

Rufen Sie ide.cloud.google.com auf. Es kann eine Weile dauern, bis die IDE angezeigt wird. Bitte haben Sie etwas Geduld und akzeptieren Sie alle Standardeinstellungen. Falls Sie eine Anleitung zum Einrichten der IDE sehen, folgen Sie ihr und verwenden Sie die Standardeinstellungen.
Klicken Sie unten in der Statusleiste auf die Schaltfläche Cloud Code – Anmelden (siehe Abbildung). Autorisieren Sie das Plug-in wie beschrieben. Wenn in der Statusleiste Cloud Code – kein Projekt angezeigt wird, wählen Sie diese Option aus und wählen Sie dann das Google Cloud-Projekt aus der Liste der Projekte aus, mit denen Sie arbeiten möchten.

Klicken Sie rechts unten auf die Schaltfläche Code Assist (siehe Abbildung) und wählen Sie noch einmal das richtige Google Cloud-Projekt aus. Wenn Sie aufgefordert werden, die Cloud AI Companion API zu aktivieren, tun Sie dies und fahren Sie fort.
Nachdem Sie Ihr Google Cloud-Projekt ausgewählt haben, prüfen Sie, ob es in der Cloud Code-Statusmeldung in der Statusleiste angezeigt wird und ob Code Assist rechts in der Statusleiste aktiviert ist (siehe unten):

Gemini Code Assist ist einsatzbereit.

3. Firestore einrichten

Cloud Firestore ist eine vollständig verwaltete serverlose Dokumentendatenbank, die wir als Backend für unsere Anwendungsdaten verwenden. Daten in Cloud Firestore sind in Sammlungen von Dokumenten strukturiert.

Wir müssen in unserer Standard-Firestore-Datenbank eine Sammlung mit dem Namen sessions erstellen. Diese Sammlung enthält Beispieldaten (Dokumente), die wir dann in unserer Anwendung verwenden.

Öffnen Sie das Terminal in der Cloud Shell-IDE über das Hauptmenü, wie unten dargestellt:

Wir müssen eine Sammlung mit dem Namen sessions erstellen. Hier finden Sie eine Liste mit Beispieldokumenten für Sitzungen. Jedes Dokument hat die folgenden Attribute:

title: String
categories: Stringarray
speakers: Array aus Strings
duration: String
summary: String

Wir füllen diese Sammlung mit Beispieldaten, indem wir eine Datei mit den Beispieldaten in einen Bucket in Ihrem eigenen Projekt kopieren. Von dort aus können Sie die Sammlung dann mit dem Befehl gcloud firestore import importieren.

Firestore-Datenbank initialisieren

Rufen Sie in der Cloud Console die Seite Firestore auf.

Wenn Sie noch keine Firestore-Datenbank im Projekt initialisiert haben, erstellen Sie die default-Datenbank. Verwenden Sie beim Erstellen der Datenbank die folgenden Werte:

Firestore-Modus: Native
Standort: Wählen Sie als Standorttyp Region aus und wählen Sie die Region aus, die für Ihre Anwendung geeignet ist. Notieren Sie sich diesen Speicherort, da Sie ihn im nächsten Schritt für den Bucket-Speicherort benötigen.
Erstellen Sie die Datenbank.

Wir erstellen jetzt die Sammlung sessions. Folgen Sie dazu der Anleitung unten:

Erstellen Sie mit dem unten angegebenen Befehl gsutil einen Bucket in Ihrem Projekt. Ersetzen Sie die Variable <PROJECT_ID> im folgenden Befehl durch Ihre Google Cloud-Projekt-ID. Ersetzen Sie <BUCKET_LOCATION> durch einen Regionsnamen, der dem geografischen Gebiet Ihrer standardmäßigen Firestore-Datenbank entspricht (wie im vorherigen Schritt angegeben). Dies kann US-WEST1, EUROPE-WEST1 oder ASIA-EAST1 sein :

gsutil mb -l <BUCKET-LOCATION> gs://<PROJECT_ID>-my-bucket

Nachdem der Bucket erstellt wurde, müssen wir den vorbereiteten Datenbankexport in diesen Bucket kopieren, bevor wir ihn in die Firebase-Datenbank importieren können. Verwenden Sie den folgenden Befehl:

gsutil cp -r gs://sessions-master-database-bucket/2024-03-26T09:28:15_95256  gs://<PROJECT_ID>-my-bucket

Nachdem wir nun die zu importierenden Daten haben, können wir mit dem letzten Schritt fortfahren: dem Import der Daten in die von uns erstellte Firebase-Datenbank (default).

Verwenden Sie den unten angegebenen gcloud-Befehl:

gcloud firestore import gs://<PROJECT_ID>-my-bucket/2024-03-26T09:28:15_95256

Der Import dauert einige Sekunden. Danach können Sie Ihre Firestore-Datenbank und die Sammlung unter https://console.cloud.google.com/firestore/databases validieren. Wählen Sie dazu die Datenbank default und die Sammlung sessions aus, wie unten dargestellt:

Damit ist die Firestore-Sammlung, die wir in unserer Anwendung verwenden, erstellt.

4. Anwendungsvorlage erstellen

Wir erstellen eine Beispielanwendung (eine Python Flask-Anwendung), die wir im restlichen Codelab verwenden. Diese Anwendung durchsucht alle Sitzungen, die auf einer technischen Konferenz angeboten werden.

Gehen Sie so vor:

Klicken Sie in der Statusleiste unten auf den Google Cloud-Projektnamen.

Eine Liste mit Optionen wird angezeigt. Klicken Sie in der Liste unten auf Neue Anwendung.

Wählen Sie Cloud Run-Anwendung aus. Dies ist die Laufzeit für unsere App.
Wählen Sie die Anwendungsvorlage Python (Flask): Cloud Run aus.
Geben Sie der Anwendung einen Namen und speichern Sie sie am gewünschten Ort.
In einer Benachrichtigung wird bestätigt, dass die Anwendung erstellt wurde, und ein neues Fenster mit der geladenen Anwendung wird geöffnet (siehe unten). Eine README.md-Datei wird geöffnet. Sie können diese Ansicht jetzt schließen.

5. Mit Gemini Code Assist interagieren

In diesem Lab verwenden wir den Gemini Code Assist-Chat, der in der Cloud Shell-IDE als Teil der Cloud Code-Erweiterung in VS Code verfügbar ist. Sie können sie aufrufen, indem Sie in der linken Navigationsleiste auf die Schaltfläche „Code Assist“ klicken. Suchen Sie in der linken Navigationsleiste nach dem Code Assist-Symbol und klicken Sie darauf.

Dadurch wird das Code Assist-Chatfenster in der Cloud Shell-IDE geöffnet und Sie können mit Code Assist chatten.

Oben sehen Sie das Papierkorbsymbol. Damit können Sie den Kontext für den Code Assist-Chatverlauf zurücksetzen. Beachten Sie auch, dass sich diese Chat-Interaktion auf die Dateien bezieht, an denen Sie in der IDE arbeiten.

6. API-Design

Im ersten Schritt nutzen wir Gemini Code Assist in der Designphase. In diesem Schritt generieren wir eine OpenAPI-Spezifikation für die Entitäten (technische Sessions in einem Event), die wir durchsuchen möchten.

Geben Sie den folgenden Prompt ein:

Generate an Open API spec that will allow me to retrieve all sessions, sessions by category, session by id. Each session has the following attributes: id, title, list of speakers, list of categories, summary and duration.

Dadurch sollte eine OpenAPI-Spezifikation für die Suche in Sitzungen über verschiedene Abfrageparameter generiert werden. Unten sehen Sie ein Beispiel für die Spezifikation:

openapi: 3.0.0
info:
 title: Sessions API
 description: This API allows you to retrieve all sessions, sessions by category, and session by id.
 version: 1.0.0
servers:
 - url: https://sessions.example.com
paths:
 /sessions:
   get:
     summary: Get all sessions
     operationId: getSessions
     responses:
       '200':
         description: OK
         content:
           application/json:
             schema:
               type: array
               items:
                 $ref: '#/components/schemas/Session'
 /sessions/{id}:
   get:
     summary: Get session by id
     operationId: getSessionById
     parameters:
       - name: id
         in: path
         required: true
         description: The id of the session
         schema:
           type: string
     responses:
       '200':
         description: OK
         content:
           application/json:
             schema:
               $ref: '#/components/schemas/Session'
 /sessions/categories/{category}:
   get:
     summary: Get sessions by category
     operationId: getSessionsByCategory
     parameters:
       - name: category
         in: path
         required: true
         description: The category of the sessions
         schema:
           type: string
     responses:
       '200':
         description: OK
         content:
           application/json:
             schema:
               type: array
               items:
                 $ref: '#/components/schemas/Session'
components:
 schemas:
   Session:
     type: object
     properties:
       id:
         type: string
         description: The id of the session
       title:
         type: string
         description: The title of the session
       speakers:
         type: array
         items:
           type: string
         description: The list of speakers for the session
       categories:
         type: array
         items:
           type: string
         description: The list of categories for the session
       summary:
         type: string
         description: The summary of the session
       duration:
         type: string
         description: The duration of the session

Die Spezifikation enthält Folgendes:

Ein für den Sitzungstyp definiertes Schema.
Mehrere API-Pfade definiert:
/sessions
/sessions/{id}
/sessions/categories/{category}

Erstellen Sie im obersten Ordner eine Datei mit dem Namen sessionsapi.yaml und kopieren Sie den Inhalt aus dem Code Assist-Chatfenster mit der Option „In aktuelle Datei einfügen“ (die Schaltfläche +). Lassen Sie die Datei in der Cloud Shell IDE geöffnet.

An dieser Stelle können Sie eine interessante Funktion von Gemini Code Assist sehen: Zitierung. Diese Informationen werden dem Entwickler angezeigt, wenn der generierte Code längere Zitate direkt aus einer anderen Quelle übernimmt, wie beispielsweise aus vorhandenem Open-Source-Code. Sie enthält die Quelle und die Lizenz, damit der Entwickler entscheiden kann, was er damit tun möchte.

Wenn wir mit den generierten Inhalten zufrieden sind, können wir dieses Spezifikationsdokument verwenden, um eine Python Flask-Anwendung dafür zu generieren.

7. Anwendung generieren

Wir bitten Code Assist nun, die Anwendung zu generieren. Geben Sie den folgenden Prompt ein, während die Datei sessionsapi.yaml geöffnet ist.

Generate a Python Application using the Flask framework, based on the sessionsapi.yaml file. This application uses a local in memory list of sessions. Do not use any Flask extensions.

Dadurch erhalten Sie ein Gerüst für die Python Flask-Anwendung, das auf den in der OpenAPI-Spezifikationsdatei angegebenen Funktionen und Pfaden basiert.

Der bereitgestellte Python Flask-Anwendungscode sollte in etwa so aussehen:

from flask import Flask, jsonify, request

app = Flask(__name__)

sessions = [
    {
        "id": "1",
        "title": "Session 1",
        "speakers": ["Speaker 1", "Speaker 2"],
        "categories": ["Category 1", "Category 2"],
        "summary": "This is a summary of session 1.",
        "duration": "1 hour",
    },
    {
        "id": "2",
        "title": "Session 2",
        "speakers": ["Speaker 3", "Speaker 4"],
        "categories": ["Category 3", "Category 4"],
        "summary": "This is a summary of session 2.",
        "duration": "1 hour 30 minutes",
    },
]

@app.route('/sessions', methods=['GET'])
def get_sessions():
    return jsonify(sessions)

@app.route('/sessions/<id>', methods=['GET'])
def get_session_by_id(id):
    session = next((session for session in sessions if session['id'] == id), None)
    if session is None:
        return jsonify({}), 404
    return jsonify(session)

@app.route('/sessions/categories/<category>', methods=['GET'])
def get_sessions_by_category(category):
    sessions_by_category = [session for session in sessions if category in session['categories']]
    return jsonify(sessions_by_category)

if __name__ == '__main__':
    app.run()

Es gibt eine vorhandene app.py-Datei, die im vorherigen Schritt generiert wurde. Ersetzen Sie einfach den Inhalt durch den von Code Assist generierten Code und speichern Sie die Datei.

Wir möchten die app.run()-Zeile so ändern, dass Port 8080 und die Hostadresse 0.0.0.0 verwendet werden und die Ausführung lokal im Debug-Modus erfolgt. So geht das: Zuerst markieren wir die Zeile:

app.run()

Geben Sie dann in der Code Assist-Chatoberfläche den Prompt Explain this. ein.

Dort sollte eine detaillierte Erklärung der jeweiligen Zeile angezeigt werden. Ein Beispiel sehen Sie unten:

Verwenden Sie jetzt den folgenden Prompt:

update the code to run the application on port 8080, host address 0.0.0.0, and in debug mode

Der generierte Vorschlag für den Code sollte so aussehen:

app.run(host='0.0.0.0', port=8080, debug=True)

Denken Sie daran, die Datei app.py mit diesem Snippet zu aktualisieren.

Anwendung lokal ausführen

Lassen Sie uns die Anwendung jetzt lokal ausführen, um die Anwendungsanforderungen gemäß dem zu validieren, womit wir begonnen haben.

Im ersten Schritt wird eine virtuelle Python-Umgebung erstellt, in der die Python-Paketabhängigkeiten in requirements.txt installiert werden. Rufen Sie dazu in der Cloud Shell IDE die Befehlspalette (Strg+Umschalt+P) auf und geben Sie Create Python environment (Python-Umgebung erstellen) ein. Führen Sie die folgenden Schritte aus, um eine virtuelle Umgebung (venv), einen Python 3.x-Interpreter und die Datei requirements.txt auszuwählen.

Sobald die Umgebung erstellt wurde, öffnen Sie ein neues Terminalfenster (Strg + Umschalt +`) und geben Sie den folgenden Befehl ein:

python app.py

Unten sehen Sie ein Beispiel für die Ausführung:

(.venv) romin@cloudshell: $ python app.py 
 * Serving Flask app 'app'
 * Debug mode: on
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
 * Running on all addresses (0.0.0.0)
 * Running on http://127.0.0.1:8080
 * Running on http://10.88.0.3:8080
Press CTRL+C to quit
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 132-247-368

Sie können sich die API jetzt unter den folgenden URLs ansehen. Wir gehen davon aus, dass Ihr Entwicklungsserver auf Port 8080 ausgeführt wird. Falls nicht, ändern Sie sie in die entsprechende Portnummer.

https://<host-name>:8080/sessions
https://<host-name>:8080/sessions/{id}
https://<host-name>:8080/sessions/categories/{category}

Gehen Sie so vor, um sicherzustellen, dass Sie die JSON-Daten in der Datei app.py über diese URLs abrufen können:

Öffnen Sie ein neues Terminalfenster und versuchen Sie es mit einem der folgenden Befehle:

curl -X GET http://127.0.0.1:8080/sessions
curl -X GET http://127.0.0.1:8080/sessions/<ID>
curl -X GET http://127.0.0.1:8080/sessions/categories/<CATEGORY_NAME>

8. Code-Refaktorierung

Anstatt die hartcodierten JSON-Beispieldaten in app.py zu speichern, sollten wir sie wahrscheinlich in ein anderes Modul auslagern, um eine saubere Trennung zwischen Code und Daten zu erreichen. Los gehts!

Lassen Sie die Datei app.py geöffnet und geben Sie den folgenden Prompt ein:

Can I improve this code and separate out the sessions data from this app.py file?

Hier finden Sie einige Vorschläge dazu. Unten sehen Sie einen Beispielvorschlag, den wir erhalten haben. Sie sollten etwas Ähnliches erhalten:

Wir folgen dieser Empfehlung und trennen unsere Daten in eine sessions.py-Datei auf, wie von Code Assist vorgeschlagen.

Erstellen Sie eine neue Datei mit dem Namen sessions.py.

,deren Inhalt die JSON-Liste ist, wie unten dargestellt:

sessions = [
   {
       "id": "1",
       "title": "Session 1",
       "speakers": ["Speaker 1", "Speaker 2"],
       "categories": ["Category 1", "Category 2"],
       "summary": "This is a summary of session 1.",
       "duration": "1 hour",
   },
   {
       "id": "2",
       "title": "Session 2",
       "speakers": ["Speaker 3", "Speaker 4"],
       "categories": ["Category 3", "Category 4"],
       "summary": "This is a summary of session 2.",
       "duration": "1 hour 30 minutes",
   },
]

Die app.py-Datei ist jetzt viel einfacher und wird unten dargestellt:

from flask import Flask, jsonify, request
from sessions import sessions

app = Flask(__name__)

@app.route('/sessions', methods=['GET'])
def get_sessions():
   return jsonify(sessions.sessions)

@app.route('/sessions/<id>', methods=['GET'])
def get_session_by_id(id):
   session = next((session for session in sessions.sessions if session['id'] == id), None)
   if session is None:
       return jsonify({}), 404
   return jsonify(session)

@app.route('/sessions/categories/<category>', methods=['GET'])
def get_sessions_by_category(category):
   sessions_by_category = [session for session in sessions.sessions if category in session['categories']]
   return jsonify(sessions_by_category)

if __name__ == '__main__':
   app.run(host='0.0.0.0', port=8080, debug=True)

Prüfen Sie, ob Sie die Anwendung weiterhin lokal ausführen und die API mit diesen refaktorierten Änderungen verwenden können. Der Python-Entwicklungsserver wird wahrscheinlich noch ausgeführt. Sie müssen also nur die curl-Befehle aus dem vorherigen Schritt aufrufen.

9. In Firestore-Sammlung einbinden

Als Nächstes müssen wir die lokale In-Memory-JSON-Liste für unsere Sitzungen verlassen und unsere Anwendung mit der Sammlung sessions in der Firestore-Datenbank verbinden, die wir am Anfang dieses Codelabs erstellt haben.

Lassen Sie die Datei sessions.py geöffnet und geben Sie den folgenden Prompt ein:

Can you further refactor the sessions.py code to read from a Firestore database that has a collection named sessions. The collection has the same attributes as the session object that we have defined. Use the Python module google-cloud-firestore.

Wir haben den folgenden Vorschlag erhalten, alle Sitzungen aus der Firestore-Sammlung zu lesen:

import google.cloud.firestore

# Create a Firestore client
db = google.cloud.firestore.Client()

# Get the sessions collection
sessions_collection = db.collection("sessions")

# Create a list of sessions
sessions = []

# Iterate over the documents and add them to the list
for doc in sessions_collection.stream():
   session = doc.to_dict()
   session["id"] = doc.id
   sessions.append(session)

Fügen Sie den Code in sessions.py ein.

Wenn Sie den Flask-Entwicklungsserver lokal ausführen, wurde Ihre Anwendung möglicherweise geschlossen, weil das Python-Modul nicht gefunden wurde.

Sie können Code Assist beispielsweise fragen, welches Python-Modul der Datei requirements.txt hinzugefügt werden muss:

Which Python package needs to be installed to make the firestore code work?

So erhalten Sie den Namen des Python-Moduls (z.B. google-cloud-firestore). Fügen Sie ihn der Datei requirements.txt hinzu.

Sie müssen die Python-Umgebung mit dem neu hinzugefügten Modul (google-cloud-firestore) neu erstellen. Geben Sie dazu den folgenden Befehl im vorhandenen Terminalfenster ein:

pip install -r requirements.txt

Führen Sie die Anwendung noch einmal aus (starten Sie sie mit python app.py neu) und rufen Sie die URL /sessions auf. Sie sollten jetzt die Beispieldokumente sehen, die wir der Sammlung sessions hinzugefügt haben.

Sie können auch andere URIs abfragen, um bestimmte Sitzungen oder alle Sitzungen für eine bestimmte Kategorie abzurufen, wie in den vorherigen Schritten beschrieben.

10. Erläuterung zum Code:

Jetzt ist ein guter Zeitpunkt, um die Funktion "Explain this" von Gemini Code Assist zu verwenden, um den Code besser zu verstehen. Sie können die Dateien öffnen oder bestimmte Code-Snippets auswählen und Code Assist mit dem folgenden Prompt fragen: Explain this.

Rufen Sie als Übung die Datei sessions.py auf, markieren Sie den Firestore-spezifischen Code und lassen Sie sich den Code erklären. Probieren Sie diese Funktion auch für andere Dateien in Ihrem Projekt aus, nicht nur für Python-Code.

11. Webanwendung generieren

Nachdem wir die API generiert und in eine aktive Firestore-Sammlung eingebunden haben, generieren wir ein webbasiertes Frontend für die Anwendung. Unser Web-Frontend wird derzeit auf ein Minimum an Funktionen beschränkt, d.h. es kann nach Sitzungen gesucht werden, die zu einer bestimmten Kategorie gehören. Dafür gibt es einen API-Pfad, nämlich /sessions/categories/{category}. Unsere Webanwendung sollte diesen aufrufen und die Ergebnisse abrufen.

Kommen wir also gleich zur Sache. Geben Sie den folgenden Prompt in Code Assist ein:

Generate a web application that allows me to search for sessions by category and uses the Flask application that we created. Please use basic HTML, CSS and JS. Embed all the Javascript and CSS code into a single HTML file only.

Dadurch wird der HTML-Code der Webanwendung mit dem eingebetteten JavaScript- und CSS-Code generiert. Sie werden auch aufgefordert, der Datei app.py eine neue Route hinzuzufügen, damit Nutzern, die die Stamm- oder Basis-URL aufrufen, die Startseite angezeigt wird. Wenn diese Informationen nicht erwähnt werden, fragen Sie danach oder verwenden Sie den unten stehenden Ausschnitt:

@app.route('/')
def index():
   return render_template('index.html')

Sie können diese Datei als index.html speichern, haben aber möglicherweise eine Frage dazu, wo diese Datei gespeichert werden soll (d.h. in welchem Ordner). Wir können Code Assist eine Folgefrage stellen.

Given that I am using the flask framework, where should I put the index.html file?

Daraus sollte klar hervorgehen, dass das render_template-Framework verwendet wird und die Datei „index.html“ daher im Ordner templates platziert werden muss. Dieser Ordner ist verfügbar, da wir zu Beginn dieses Codelabs eine Anwendung auf Grundlage der Flask-Vorlage generiert haben. Daher ist bereits eine index.html-Datei vorhanden. Sie müssen lediglich ihren Inhalt durch den neuen ersetzen, der hier generiert wurde. Code Assist weist Sie auch darauf hin, dass Sie render_template in Ihre app.py-Datei importieren müssen.

Speichern Sie den Webanwendungscode in der Datei index.html und legen Sie diese Datei im Ordner templates ab.

Anwendung lokal ausführen

Lassen Sie uns die Anwendung jetzt lokal ausführen, um die Anwendungsanforderungen gemäß dem zu validieren, womit wir begonnen haben.

Prüfen Sie, ob der lokale Flask-Server noch ausgeführt wird und keine Fehler angezeigt werden. Beheben Sie alle Fehler und starten Sie den Server.

Rufen Sie nach der Einrichtung die Start-URL der Anwendung auf. Die index.html-Datei sollte wie unten dargestellt angezeigt werden:

Geben Sie eine der Kategorien aus den Daten als Eingabe an (z.B. AI) und klicken Sie auf die Schaltfläche Search. Es sollten die Sitzungen angezeigt werden, die mit der Kategorie AI getaggt sind.

Als optionale Übung können Sie für jede Sitzung zusätzliche Metadaten wie Dauer, Kategorien, Referenten und Zusammenfassung anzeigen.

12. Testlaufgenerierung

Wir haben die Sessions API generiert. Jetzt ist es an der Zeit, mit Gemini Code Assist Unittest-Fälle für die verschiedenen API-Pfade zu generieren.

Lassen Sie die Datei app.py geöffnet und geben Sie den folgenden Prompt ein:

Generate unit test cases for app routes. Use unittest module.

Wir haben die folgende Antwort erhalten:

import unittest
from app import app

class FlaskAppTestCase(unittest.TestCase):

    def test_index(self):
        tester = app.test_client()
        response = tester.get('/')
        self.assertEqual(response.status_code, 200)

    def test_get_sessions(self):
        tester = app.test_client()
        response = tester.get('/sessions')
        self.assertEqual(response.status_code, 200)

    def test_get_session_by_id(self):
        tester = app.test_client()
        response = tester.get('/sessions/1')
        self.assertEqual(response.status_code, 200)

    def test_get_sessions_by_category(self):
        tester = app.test_client()
        response = tester.get('/sessions/categories/category1')
        self.assertEqual(response.status_code, 200)

if __name__ == '__main__':
    unittest.main()

Erstellen Sie eine Datei mit dem Namen tests.py und dem oben genannten Code.

Hinweis zur Testlaufgenerierung

Möglicherweise wird ein anderer Code als oben aufgeführt angezeigt. Das kann zu Problemen beim Ausführen der Testläufe führen. In einigen unserer Läufe wurden beispielsweise die folgenden wichtigen Codeabschnitte ausgelassen:

from app import app

Der obige Code ist erforderlich, um die vorhandene Flask-App zu importieren, für die wir die Testläufe aufrufen.

if __name__ == '__main__':

`unittest.main()`

Der oben genannte Code ist erforderlich, um die Testläufe auszuführen.

Wir empfehlen, sich jeden Testfall anzusehen und die assertEqual und andere Bedingungen im generierten Code zu prüfen, um sicherzugehen, dass er funktioniert. Da die Daten in einer externen Firestore-Sammlung gespeichert sind, hat die Funktion möglicherweise keinen Zugriff darauf und verwendet stattdessen Dummy-Daten. Dadurch können die Tests fehlschlagen. Passen Sie Ihre Testläufe entsprechend an oder kommentieren Sie einige der Testläufe aus, die Sie möglicherweise nicht sofort benötigen.

Zur Demonstration haben wir die Testläufe mit dem folgenden Befehl ausgeführt. Achten Sie darauf, den lokalen Entwicklungsserver auszuführen, da Aufrufe an die lokalen API-Endpunkte erfolgen:

python tests.py

Wir haben das folgende Zusammenfassungsergebnis erhalten:

Ran 4 tests in 0.274s

FAILED (failures=2)

Das ist richtig, da die Sitzungs-ID im dritten Test nicht korrekt war und es keine Kategorie mit dem Namen category1 gibt.

Passen Sie die Testläufe entsprechend an und probieren Sie es aus.

13. Testgesteuerte Entwicklung

Sehen wir uns nun an, wie wir unserer Sessions API eine neue Suchmethode hinzufügen. Dabei folgen wir der Methodik der testgetriebenen Entwicklung (Test-Driven Development, TDD). Das bedeutet, dass wir zuerst Testläufe schreiben, die aufgrund fehlender Implementierung fehlschlagen, und dann Gemini Code Assist verwenden, um die fehlende Implementierung zu generieren, damit der Test erfolgreich ist.

Rufen Sie die Datei „tests.py“ auf (vorausgesetzt, Sie haben die Datei tests.py so korrigiert, dass alle Tests bestanden werden). Stellen Sie Code Assist den folgenden Prompt:

Generate a new test case to search for sessions by speaker

Daraus ergab sich die folgende Testlaufimplementierung, die wir in die Datei tests.py eingefügt haben.

  def test_get_sessions_by_speaker(self):
        tester = app.test_client()
        response = tester.get('/sessions/speakers/speaker1')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json, [sessions.sessions[0], sessions.sessions[1]])

Wenn Sie die Tests ausführen, sollte der folgende Fehler angezeigt werden:

$ python tests.py 
.F.
======================================================================
FAIL: test_get_sessions_by_speaker (__main__.FlaskAppTestCase)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/home/romin/hello-world-5/tests.py", line 21, in test_get_sessions_by_speaker
    self.assertEqual(response.status_code, 200)
AssertionError: 404 != 200

----------------------------------------------------------------------
Ran 3 tests in 0.010s

FAILED (failures=1)

Das liegt daran, dass im Testlauf der folgende Pfad (/sessions/speakers/) aufgerufen wurde, der in app.py nicht implementiert ist.

Wir bitten Code Assist, uns eine Implementierung zu liefern. Rufen Sie die Datei app.py auf und geben Sie den folgenden Prompt für Code Assist ein:

Add a new route to search for sessions by a specific speaker

Code Assist hat die folgende Implementierung vorgeschlagen, die wir der Datei app.py hinzugefügt haben:

@app.route('/sessions/speakers/<speaker>', methods=['GET'])
def get_sessions_by_speaker(speaker):
    sessions_by_speaker = [session for session in sessions.sessions if speaker in session['speakers']]
    return jsonify(sessions_by_speaker)

Wir haben die Datei tests.py noch einmal überprüft und unseren Testlauf für einen schnellen Check wie folgt angepasst:

   def test_get_sessions_by_speaker(self):
       tester = app.test_client()
       response = tester.get('/sessions/speakers/Romin Irani')
       self.assertEqual(response.status_code, 200)
       self.assertEqual(len(response.json), 1)

Der Test wurde erfolgreich ausgeführt. Es liegt an Ihnen, sich die generierten Testläufe anzusehen, sie je nach den Daten, die Sie in Firestore haben, etwas anzupassen und die entsprechenden assert*-Methoden in den Python-Einheitentests zu verwenden.

14. In Google Cloud Run bereitstellen

Nachdem wir uns von der Qualität unserer Entwicklung überzeugt haben, stellen wir die Anwendung in Google Cloud Run bereit. Aber vielleicht sollten wir Code Assist zur Sicherheit fragen, ob wir etwas vergessen haben. Geben Sie in app.py den folgenden Prompt ein :

Is there something here I should change before I deploy to production?

Gut, dass du gefragt hast, denn wir haben vergessen, das Debugging-Flag zu deaktivieren :

Deaktivieren Sie das Debugging und bitten Sie Gemini Code Assist um Hilfe beim gcloud-Befehl, mit dem die Anwendung direkt aus dem Quellcode in Cloud Run bereitgestellt werden kann (ohne dass zuerst ein Container erstellt werden muss).

Geben Sie den folgenden Prompt ein:

I would like to deploy the application to Cloud Run directly from source. What is the gcloud command to do that?

Probieren Sie einige Varianten des oben genannten Prompts aus. Ein weiteres Beispiel:

I would like to deploy this application to Cloud Run. I don't want to build a container image locally but deploy directly from source to Cloud Run. What is the gcloud command for that?

Im Idealfall sollten Sie den folgenden gcloud-Befehl erhalten:

gcloud run deploy sessions --source .

Außerdem können Sie Folgendes erhalten:

gcloud run deploy <service-name> --source . \
—-platform managed \
—-allow-unauthenticated

Führen Sie den oben genannten Befehl im Stammordner der Anwendung aus. Wenn Sie nach region gefragt werden, wählen Sie us-central1 aus. Wenn Sie gefragt werden, ob Sie unauthenticated invocations zulassen möchten, wählen Sie Y aus. Sie werden möglicherweise auch aufgefordert, Google Cloud APIs wie Artifact Registry, Cloud Build und Cloud Run zu aktivieren und die Berechtigung zum Erstellen eines Artifact Registry-Repositorys zu erteilen.

Das Deployment dauert etwa zwei Minuten.

Nach der erfolgreichen Bereitstellung wird die Cloud Run-Dienst-URL angezeigt. Wenn Sie diese öffentliche URL aufrufen, sollten Sie dieselbe Webanwendung sehen, die bereitgestellt wurde und erfolgreich ausgeführt wird.

Herzlichen Glückwunsch!

15. Optional: Cloud Logging verwenden

Wir können Logging in unsere Anwendung einführen, sodass die Anwendungslogs in einem der Google Cloud-Dienste (Cloud Logging) zentralisiert werden. Wir können dann auch die Gemini-Funktion für Observability verwenden, um Logeinträge zu analysieren.

Dazu müssen wir zuerst eine vorhandene Python Cloud Logging-Bibliothek von Google Cloud verwenden und damit Informations-, Warn- oder Fehlermeldungen protokollieren (je nach Log- bzw. Schweregrad).

Fragen wir Code Assist zuerst danach. Probieren Sie den folgenden Prompt aus:

How do I use the google-cloud-logging package in Python?

Sie sollten eine Antwort mit einigen Informationen dazu erhalten, wie unten dargestellt:

Fügen wir der Funktion, die nach Sitzungen nach Kategorie sucht, Protokollanweisungen hinzu.

Fügen Sie zuerst das Python-Paket google-cloud-logging in die Datei requirements.txt ein.

Als Nächstes sehen Sie ein Code-Snippet, das zeigt, wie wir den Code zur Implementierung der Protokollierung integriert haben:

...
from google.cloud import logging
...
app = Flask(__name__)

# Create a logger
logger = logging.Client().logger('my-log')

@app.route('/sessions/categories/<category>', methods=['GET'])
def get_sessions_by_category(category):
   logger.log_text(f"Fetching sessions with category {category}")
   sessions_by_category = [session for session in sessions.sessions if category in session['categories']]
   logger.log_text(f'Found {len(sessions_by_category)} sessions with category {category}')
   return jsonify(sessions_by_category)

# # Other App Routes

Stellen Sie den Dienst noch einmal in Cloud Run bereit. Verwenden Sie dazu denselben Befehl wie im vorherigen Abschnitt. Führen Sie nach der Bereitstellung einige Aufrufe des Endpunkts /sessions/categories/<category> aus.

Rufen Sie Cloud Console → Logs Explorer auf.

Sie sollten diese Protokollanweisungen wie unten gezeigt filtern können:

Sie können auf eine der Log-Anweisungen klicken, sie maximieren und dann auf Explain this log entry klicken. Gemini erklärt dann den Logeintrag. Wenn Sie Gemini for Google Cloud nicht aktiviert haben, werden Sie aufgefordert, die Cloud AI Companion API zu aktivieren. Bitte führen Sie die Schritte wie beschrieben aus.

Eine Beispielantwort sehen Sie hier:

16. Glückwunsch

Sie haben erfolgreich eine Anwendung von Grund auf erstellt und Gemini Code Assist in verschiedenen Phasen des SDLC verwendet, darunter Design, Entwicklung, Tests und Bereitstellung.

Nächste Schritte

Hier finden Sie einige Codelabs:

Entwicklungs-Workflow mit Gemini Code Assist optimieren

1. Einführung

Aufgaben

Lerninhalte

Voraussetzungen

2. Gemini Code Assist einrichten

Gemini Code Assist in der Cloud Shell-IDE aktivieren

3. Firestore einrichten

Firestore-Datenbank initialisieren

4. Anwendungsvorlage erstellen

5. Mit Gemini Code Assist interagieren

6. API-Design

7. Anwendung generieren

Anwendung lokal ausführen

8. Code-Refaktorierung

9. In Firestore-Sammlung einbinden

10. Erläuterung zum Code:

11. Webanwendung generieren

Anwendung lokal ausführen

12. Testlaufgenerierung

Hinweis zur Testlaufgenerierung

13. Testgesteuerte Entwicklung

14. In Google Cloud Run bereitstellen

15. Optional: Cloud Logging verwenden

16. Glückwunsch

Nächste Schritte

Referenzdokumente