1. Zielsetzungen
Ziel dieses Workshops ist es, Nutzern und Fachkräften praktische Informationen zu Duet-KI zu bieten.
In diesem Codelab lernen Sie Folgendes:
- Aktivieren Sie Duet AI in Ihrem GCP-Projekt und konfigurieren Sie es für die Verwendung in einer IDE und in der Cloud Console.
- Verwenden Sie Duet-KI zum Generieren, Vervollständigen und Erklärungen von Code.
- Mit Duet-KI ein Anwendungsproblem erklären und beheben
- Duet AI-Funktionen wie IDE-Chat und Chat in mehreren Schritten, Chat- und Inline-Codegenerierung, intelligente Aktionen wie Codeerklärung und Rezitationsbestätigung.
Narrative
Um zu zeigen, wie Duet AI für Entwickler authentisch in der täglichen Entwicklung eingesetzt wird, finden die Aktivitäten in diesem Workshop in einem erzählerischen Kontext statt.
Eine neue Entwicklerin stößt in ein E-Commerce-Unternehmen. Sie sollen der bestehenden E-Commerce-Anwendung, die aus mehreren Diensten besteht, einen neuen Dienst hinzufügen. Der neue Dienst bietet zusätzliche Informationen (Abmessungen, Gewicht usw.) zu Produkten im Produktkatalog. Dieser Service ermöglicht bessere/günstigere Versandkosten je nach Produktabmessungen und -gewicht.
Da der Entwickler neu im Unternehmen ist, wird er Duet AI zum Generieren, Erklärungen und Dokumentationen von Code verwenden.
Nach der Codierung des Dienstes verwendet ein Plattformadministrator Duet-KI (Chat), um das Artefakt (Docker-Container) und die Ressourcen zu erstellen, die zum Bereitstellen des Artefakts auf der GCP erforderlich sind (z. B. Artifact Registry, IAM-Berechtigungen, ein Code-Repository, Compute-Infrastruktur wie GKE oder CloudRun usw.).
Sobald die Anwendung auf der GCP bereitgestellt wurde, verwendet ein Anwendungsoperator/SRE Duet-KI (und Cloud Ops), um einen Fehler im neuen Dienst zu beheben.
Identität
Der Workshop umfasst die folgenden Persona:
- Anwendungsentwickler: Es sind Programmier- und Softwarekenntnisse erforderlich.
Diese Variante des Duet AI-Workshops ist nur für Entwickler gedacht. Es sind keine Kenntnisse der GCP-Cloud-Ressourcen erforderlich. Die Skripts zum Erstellen der erforderlichen GCP-Ressourcen zum Ausführen dieser Anwendung finden Sie hier. Sie können dieser Anleitung folgen, um die erforderlichen GCP-Ressourcen bereitzustellen.
2. Umgebung vorbereiten
Duet AI aktivieren
Sie können Duet-KI in einem GCP-Projekt aktivieren, entweder über die API (gcloud- oder IaC-Tools wie Terraform) oder über die Benutzeroberfläche der Cloud Console.
Zum Aktivieren von Duet AI in einem Google Cloud-Projekt aktivieren Sie die Cloud AI Companion API und gewähren Nutzern die IAM-Rollen (Identity and Access Management) „Cloud AI Companion User“ und „Service Usage Viewer“.
Über gcloud
Aktivieren Sie Cloud Shell:
Konfigurieren Sie PROJECT_ID
und USER
und aktivieren Sie die Cloud AI Companion API.
export PROJECT_ID=<YOUR PROJECT ID> export USER=<YOUR USERNAME> # Use your full LDAP, e.g. name@example.com gcloud config set project ${PROJECT_ID} gcloud services enable cloudaicompanion.googleapis.com --project ${PROJECT_ID}
Die Ausgabe sieht so aus:
Updated property [core/project]. Operation "operations/acat.p2-60565640195-f37dc7fe-b093-4451-9b12-934649e2a435" finished successfully.
Gewähren Sie dem USER-Konto die IAM-Rollen „Cloud AI Companion User“ und „Service Usage Viewer“. Die Cloud Companion API befindet sich hinter den Funktionen in der IDE und in der Konsole, die wir verwenden werden. Die Berechtigung „Service Usage Viewer“ wird als Schnellprüfung verwendet, bevor die Benutzeroberfläche in der Console aktiviert wird. So wird die Duet-UI nur in Projekten angezeigt, in denen die API aktiviert ist.
gcloud projects add-iam-policy-binding ${PROJECT_ID} \ --member=user:${USER} --role=roles/cloudaicompanion.user gcloud projects add-iam-policy-binding ${PROJECT_ID} \ --member=user:${USER} --role=roles/serviceusage.serviceUsageViewer
Die Ausgabe sieht so aus:
... - members: - user:<YOUR USER ACCOUNT> role: roles/cloudaicompanion.user ... - members: - user:<YOUR USER ACCOUNT> role: roles/serviceusage.serviceUsageViewer
Über die Cloud Console
Rufen Sie zum Aktivieren der API in der Google Cloud Console die Seite „Cloud AI Companion API“ auf.
Wählen Sie in der Projektauswahl ein Projekt aus.
Klicken Sie auf Aktivieren.
Die Seite wird aktualisiert und der Status Aktiviert wird angezeigt. Duet AI ist jetzt im ausgewählten Google Cloud-Projekt für alle Nutzer mit den erforderlichen IAM-Rollen verfügbar.
Rufen Sie die Seite IAM auf, um die IAM-Rollen zu gewähren, die zur Verwendung von Duet AI erforderlich sind.
Suchen Sie in der Spalte Hauptkonto den NUTZER, für den Sie den Zugriff auf Duet AI aktivieren möchten, und klicken Sie dann in dieser Zeile auf das Stiftsymbol ✏️ Hauptkonto bearbeiten.
Klicken Sie im Bereich Zugriff bearbeiten auf Weitere Rolle hinzufügen.
Wählen Sie unter „Rolle auswählen“ die Option Cloud AI Companion-Nutzer aus.
Klicken Sie auf Weitere Rolle hinzufügen und wählen Sie Service Usage Viewer aus.
Klicken Sie auf Speichern.
IDE einrichten
Entwickler können aus einer Vielzahl von IDEs wählen, die am besten zu ihren Anforderungen passen. Duet AI-Codeunterstützung ist in mehreren IDEs verfügbar, z. B. in Visual Studio Code, JetBrains-IDEs (IntelliJ, PyCharm, GoLand, WebStorm und mehr), Cloud Workstations und Cloud Shell Editor.
In diesem Lab können Sie entweder Cloud Workstations oder den Cloud Shell-Editor verwenden.
In diesem Workshop wird der Cloud Shell-Editor verwendet.
Die Einrichtung von Cloud Workstations kann 20 bis 30 Minuten dauern.
Wenn Sie sie sofort verwenden möchten, verwenden Sie den Cloud Shell-Editor.
Öffnen Sie den Cloud Shell-Editor. Klicken Sie dazu in der oberen Menüleiste von Cloud Shell auf das Stiftsymbol Semikolon.
Die Benutzeroberfläche und UX des Cloud Shell-Editors sind denen von VSCode sehr ähnlich.
Drücken Sie Strg (Windows)/CMD (Mac) + , (Komma), um den Bereich „Einstellungen“ aufzurufen.
Geben Sie in der Suchleiste „duet ai“ ein.
Achten oder aktivieren Sie Cloudcode › Duet AI: Enable und Cloudcode › Duet AI › Inline-Vorschläge: Automatische Aktivierung
Klicken Sie in der Statusleiste unten auf Cloud Code – Sign In (Cloud Code – Anmelden) und folgen Sie dem Anmeldeworkflow.
Wenn Sie bereits angemeldet sind, wird in der Statusleiste Cloud Code – Kein Projekt angezeigt.
Klicken Sie auf „Cloud Code – No Projekt“ (Cloud Code – Kein Projekt). Daraufhin wird oben ein Drop-down-Menü für die Aktion angezeigt. Klicken Sie auf Google Cloud-Projekt auswählen.
Beginnen Sie mit der Eingabe der PROJEKT-ID. Ihr Projekt sollte in der Liste angezeigt werden.
Wählen Sie Ihre PROJECT_ID aus der Projektliste aus.
In der unteren Statusleiste wird nun Ihre Projekt-ID angezeigt. Ist dies nicht der Fall, müssen Sie möglicherweise den Tab mit dem Cloud Shell-Editor aktualisieren.
Klicken Sie in der linken Menüleiste auf das Duet AI-Symbol . Daraufhin wird das Duet AI-Chatfenster angezeigt. Die Meldung „GCP-Projekt auswählen“ wird angezeigt. Klicken Sie auf das Projekt und wählen Sie es noch einmal aus.
Sie sehen jetzt das Duet AI-Chatfenster
3. Infrastruktur einrichten
Sie benötigen die folgenden GCP-Ressourcen, um den neuen Versandservice in der GCP ausführen zu können:
- Eine Cloud SQL-Instanz mit einer Datenbank.
- Ein GKE-Cluster zum Ausführen des containerisierten Dienstes.
- Eine Artifact Registry zum Speichern des Docker-Images.
- Ein Cloud Source Repository für den Code.
Klonen Sie im Cloud Shell-Terminal das folgende Repository und führen Sie die folgenden Befehle aus, um die Infrastruktur in Ihrem GCP-Projekt einzurichten.
# Set your project export PROJECT_ID=<INSERT_YOUR_PROJECT_ID> gcloud config set core/project ${PROJECT_ID} # Enable Cloudbuild and grant Cloudbuild SA owner role export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format 'value(projectNumber)') gcloud services enable cloudbuild.googleapis.com gcloud projects add-iam-policy-binding ${PROJECT_ID} --member serviceAccount:${PROJECT_NUMBER}@cloudbuild.gserviceaccount.com --role roles/owner # Clone the repo git clone https://github.com/duetailabs/dev.git ~/duetaidev cd ~/duetaidev # Run Cloudbuild to create the necessary resources gcloud builds submit --substitutions=_PROJECT_ID=${PROJECT_ID} # To destroy all GCP resources, run the following # gcloud builds submit --substitutions=_PROJECT_ID=${PROJECT_ID} --config=cloudbuild_destroy.yaml
4. Python Flask-Dienst entwickeln
Der Dienst, den wir entwickeln, besteht letztendlich aus den folgenden Dateien. Sie müssen diese Dateien nicht jetzt erstellen. Erstellen Sie sie einzeln, indem Sie der Anleitung unten folgen:
package-service.yaml
: Eine Open API-Spezifikation für den Paketdienst mit Daten wie Höhe, Breite und Gewicht sowie spezielle Hinweise zur Handhabung.data_model.py
– Datenmodell für die Package-Service-API-Spezifikation Erstellt außerdem die Tabellepackages
in der Datenbank „product_details“.connect_connector.py
– Cloud SQL-Verbindung (definiert Engine, Sitzung und Basis-ORM)db_init.py
: Generiert Beispieldaten in der Tabellepackages
.main.py
: Ein Python Flask-Dienst mit einemGET
-Endpunkt, um Paketdetails aus denpackages
-Daten basierend auf der „product_id“ abzurufen.test.py
– Einheitentestrequirement.txt
: Python-AnforderungenDockerfile
– Zum Containerisieren dieser Anwendung
Sollten während der Übungen Probleme auftreten, finden Sie die endgültigen Dateien als Referenz im ANHANG dieses Codelabs.
Im vorherigen Schritt haben Sie ein Cloud Source Repository erstellt. Klonen Sie das Repository. Sie erstellen die Anwendungsdateien im geklonten Repository-Ordner.
Führen Sie im Cloud Shell-Terminal den folgenden Befehl aus, um das Repository zu klonen.
cd ~ gcloud source repos clone shipping shipping cd ~/shipping
Öffnen Sie im linken Menü des Cloud Shell-Editors die Duet AI-Chatseitenleiste. Das Symbol sieht aus wie . Sie können jetzt Duet-KI zur Codeunterstützung verwenden.
package-service.yaml
Wenn keine Dateien geöffnet sind, bitten Sie Duet, eine Open API-Spezifikation für den Versandservice zu generieren.
Aufgabe 1: Generieren Sie eine OpenAPI-YAML-Spezifikation für einen Dienst, der Versand- und Paketinformationen anhand einer numerischen Produkt-ID bereitstellt. Der Service sollte Informationen zu Höhe, Breite, Tiefe und Gewicht des Pakets sowie spezielle Hinweise zur Handhabung enthalten.
Oben rechts im Fenster mit dem generierten Code werden drei Optionen angezeigt.
Du kannst den Code entweder COPY
und in eine Datei einfügen.
Sie können den Code mit ADD
in die aktuell geöffnete Datei im Editor einfügen.
Alternativ können Sie den Code in einer neuen Datei mit OPEN
speichern.
Klicken Sie auf OPEN
den Code in einer neuen Datei.
Klicken Sie auf CTRL/CMD + s
, um die Datei zu speichern, und speichern Sie sie im Anwendungsordner unter dem Dateinamen package-service.yaml
. Klicken Sie auf "OK".
Die letzte Datei befindet sich im Abschnitt „ANHANG“ dieses Codelabs. Ist dies nicht der Fall, nehmen Sie die entsprechenden Änderungen manuell vor.
Sie können auch verschiedene Prompts ausprobieren, um die Antworten von Duet AI zu sehen.
Setzen Sie das Duet AI-Chatprotokoll zurück, indem Sie oben in der Duet AI-Seitenleiste auf das Papierkorbsymbol klicken.
data_model.py
Als Nächstes erstellen Sie die Python-Datenmodelldatei für den Dienst, die auf der OpenAPI-Spezifikation basiert.
Geben Sie bei geöffneter Datei package-service.yaml
den folgenden Prompt ein.
Aufgabe 1: Generieren Sie mit Python sqlalchemy ORM ein Datenmodell für diesen API-Dienst. Fügen Sie außerdem eine separate Funktion und einen Haupteinstiegspunkt hinzu, über den die Datenbanktabellen erstellt werden.
Schauen wir uns die einzelnen Teile an, die generiert wurden. Duet AI ist nach wie vor ein Assistent. Sie können damit schnell Code erstellen, sollten aber trotzdem generierte Inhalte prüfen und verstehen, während Sie sie verwenden.
Zuerst gibt es eine Klasse mit dem Namen Package
von Art Base
, die das Datenmodell für die Datenbank packages
so definiert:
class Package(Base):
__tablename__ = 'packages'
id = Column(Integer, primary_key=True)
product_id = Column(String(255))
height = Column(Float)
width = Column(Float)
depth = Column(Float)
weight = Column(Float)
special_handling_instructions = Column(String(255))
Als Nächstes benötigen Sie eine Funktion, die die Tabelle in der Datenbank wie die folgende erstellt:
def create_tables(engine):
Base.metadata.create_all(engine)
Schließlich benötigen Sie eine Hauptfunktion, die die create_tables
-Funktion ausführt, um die Tabelle tatsächlich in der Cloud SQL-Datenbank zu erstellen. Beispiel:
if __name__ == '__main__':
from sqlalchemy import create_engine
engine = create_engine('sqlite:///shipping.db')
create_tables(engine)
print('Tables created successfully.')
Die Funktion main
erstellt eine Suchmaschine mithilfe einer lokalen sqlite
-Datenbank. Sie müssen ihn ändern, um Cloud SQL verwenden zu können. Das tun Sie etwas später.
Verwenden Sie OPEN
den Code wie zuvor in einem neuen Dateiworkflow. Speichern Sie den Code in einer Datei namens
data_model.py
. Beachten Sie dabei den Unterstrich und nicht den Bindestrich.
Setzen Sie das Duet AI-Chatprotokoll zurück, indem Sie oben in der Duet AI-Seitenleiste auf das Papierkorbsymbol klicken.
connect-connector.py
Erstellen Sie den CloudSQL-Connector.
Öffnen Sie die Datei data_model.py
und geben Sie die folgenden Aufforderungen ein.
Aufgabe 1: Generieren Sie mit der Cloud SQL-Python-Connector-Bibliothek eine Funktion, die einen Verbindungspool für eine Cloud SQL-Instanz von Postgres initialisiert.
Beachten Sie, dass in der Antwort nicht die cloud-sql-python-connector
-Bibliothek verwendet wird. Sie können Prompts optimieren, um Duet einen Vorgeschmack zu geben, indem Sie demselben Chat-Thread Details hinzufügen.
Verwenden wir einen anderen Prompt.
Aufgabe 2: Muss die Cloud-SQL-Python-Connector-Bibliothek verwenden.
Achte darauf, dass die cloud-sql-python-connector
-Bibliothek verwendet wird.
Verwenden Sie OPEN
den Code wie zuvor in einem neuen Dateiworkflow. Speichern Sie den Code in einer Datei mit dem Namen
connect_conector.py
. Möglicherweise musst du die pg8000
-Bibliothek manuell importieren (siehe Datei unten).
Löschen Sie den Duet AI-Chatverlauf und generieren Sie bei geöffneter Datei connect_connector.py
den ORM DB engine
, sessionmaker
und base
, der in der App verwendet werden soll.
Aufgabe 1: Engine, Sessionmaker-Klasse und Base ORM mit der Methode „connect_with_connector“ erstellen
Durch die Antwort werden möglicherweise engine
, Session
und Base
an die Datei connect_connector.py
angehängt.
Die letzte Datei befindet sich im Abschnitt „ANHANG“ dieses Codelabs. Ist dies nicht der Fall, nehmen Sie die entsprechenden Änderungen manuell vor.
Sie können auch verschiedene Prompts ausprobieren, um die mögliche Variante der Antworten von Duet AI zu sehen.
Setzen Sie das Duet AI-Chatprotokoll zurück, indem Sie oben in der Duet AI-Seitenleiste auf das Papierkorbsymbol klicken.
data_model.py wird aktualisiert
Sie müssen die Suchmaschine verwenden, die Sie im vorherigen Schritt erstellt haben (in der Datei connect_connector.py
), um eine Tabelle in der Cloud SQL-Datenbank zu erstellen.
Löschen Sie das Duet AI-Chatprotokoll. Öffnen Sie die Datei data_model.py
. Versuchen Sie es mit dem folgenden Prompt.
Aufgabe 1: Importieren und verwenden Sie die Engine aus „connect_connector.py“ in der Hauptfunktion
Die Antwort sollte angezeigt werden, wenn engine
aus connect_connector
(für Cloud SQL) importiert wird. Die create_table
verwendet diese Engine (anstelle der standardmäßigen lokalen sqlite
-Datenbank).
Datei „data_model.py
“ aktualisieren.
Die letzte Datei befindet sich im Abschnitt „ANHANG“ dieses Codelabs. Ist dies nicht der Fall, nehmen Sie die entsprechenden Änderungen manuell vor.
Sie können auch verschiedene Prompts ausprobieren, um sich die Antworten von Duet AI anzusehen.
Setzen Sie das Duet AI-Chatprotokoll zurück, indem Sie oben in der Duet AI-Seitenleiste auf das Papierkorbsymbol klicken.
requirements.txt
Erstellen Sie eine requirements.txt
-Datei für die Anwendung.
Öffnen Sie sowohl die Datei connect_connector.py
als auch die Datei data_model.py
und geben Sie den folgenden Prompt ein.
Aufgabe 1: Eine pip-Anforderungsdatei für dieses Datenmodell und diesen Dienst generieren
Aufgabe 2: Mit den neuesten Versionen eine pip-Anforderungsdatei für dieses Datenmodell und diesen Dienst generieren
Prüfen Sie, ob die Namen und Versionen korrekt sind. In der Antwort oben sind beispielsweise der Name und die Version von google-cloud-sql-connecter
falsch. Korrigieren Sie die Versionen manuell und erstellen Sie eine requirements.txt
-Datei, die so aussieht:
cloud-sql-python-connector==1.2.4
sqlalchemy==1.4.36
pg8000==1.22.0
Führen Sie im Befehlsterminal folgenden Befehl aus:
pip3 install -r requirements.txt
Setzen Sie das Duet AI-Chatprotokoll zurück, indem Sie oben in der Duet AI-Seitenleiste auf das Papierkorbsymbol klicken.
Pakettabelle in Cloud SQL erstellen
Legen Sie die Umgebungsvariablen für den CloudSQL-Datenbank-Connector fest.
export INSTANCE_NAME=$(gcloud sql instances list --format='value(name)') export INSTANCE_CONNECTION_NAME=$(gcloud sql instances describe ${INSTANCE_NAME} --format="value(connectionName)") export DB_USER=evolution export DB_PASS=evolution export DB_NAME=product_details
Führen Sie nun data_model.py aus.
python data_model.py
Die Ausgabe sieht in etwa so aus (überprüfen Sie den Code, um zu sehen, was tatsächlich erwartet wird):
Tables created successfully.
Stellen Sie eine Verbindung zur Cloud SQL-Instanz her und prüfen Sie, ob die Datenbank erstellt wurde.
gcloud sql connect ${INSTANCE_NAME} --user=evolution --database=product_details
Nachdem Sie das Passwort (auch evolution) eingegeben haben, rufen Sie die Tabellen ab.
product_details=> \dt
Die Ausgabe sieht in etwa so aus:
List of relations Schema | Name | Type | Owner --------+----------+-------+----------- public | packages | table | evolution (1 row)
Sie können sich auch das Datenmodell und die Tabellendetails ansehen.
product_details=> \d+ packages
Die Ausgabe sieht in etwa so aus:
Table "public.packages" Column | Type | Collation | Nullable | Default | Storage | Compression | Stats target | Description -------------------------------+-------------------+-----------+----------+--------------------------------------+----------+-------------+--------------+------------- id | integer | | not null | nextval('packages_id_seq'::regclass) | plain | | | product_id | integer | | not null | | plain | | | height | double precision | | not null | | plain | | | width | double precision | | not null | | plain | | | depth | double precision | | not null | | plain | | | weight | double precision | | not null | | plain | | | special_handling_instructions | character varying | | | | extended | | | Indexes: "packages_pkey" PRIMARY KEY, btree (id) Access method: heap
Geben Sie \q
ein, um Cloud SQL zu beenden.
db_init.py
Als Nächstes fügen wir der Tabelle packages
Beispieldaten hinzu.
Löschen Sie das Duet AI-Chatprotokoll. Öffnen Sie die Datei data_model.py
und versuchen Sie es mit den folgenden Prompts.
Aufgabe 1: Funktion generieren, die 10 Zeilen mit Beispielpaketen erstellt und sie an die Tabelle „Packages“ übergibt
Aufgabe 2: Generieren Sie mithilfe der Sitzung von „connect_connector“ eine Funktion, die 10 Beispielpaketzeilen erstellt und an die Pakettabelle übergibt
Verwenden Sie OPEN
den Code wie zuvor in einem neuen Dateiworkflow. Speichern Sie den Code in einer Datei mit dem Namen
db_init.py
.
Die letzte Datei befindet sich im Abschnitt „ANHANG“ dieses Codelabs. Ist dies nicht der Fall, nehmen Sie die entsprechenden Änderungen manuell vor.
Sie können auch verschiedene Prompts ausprobieren, um sich die Antworten von Duet AI anzusehen.
Setzen Sie das Duet AI-Chatprotokoll zurück, indem Sie oben in der Duet AI-Seitenleiste auf das Papierkorbsymbol klicken.
Beispielpaketdaten erstellen
Führen Sie db_init.py
über die Befehlszeile aus.
python db_init.py
Die Ausgabe sieht in etwa so aus:
Packages created successfully.
Stellen Sie wieder eine Verbindung zur Cloud SQL-Instanz her und prüfen Sie, ob die Beispieldaten der Tabelle „Packages“ hinzugefügt wurden.
Stellen Sie eine Verbindung zur Cloud SQL-Instanz her und prüfen Sie, ob die Datenbank erstellt wurde.
gcloud sql connect ${INSTANCE_NAME} --user=evolution --database=product_details
Nach der Eingabe des Passworts (auch evolution) können Sie alle Daten aus der Tabelle „packages“ abrufen.
product_details=> SELECT * FROM packages;
Die Ausgabe sieht in etwa so aus:
id | product_id | height | width | depth | weight | special_handling_instructions ----+------------+--------+-------+-------+--------+----------------------------------- 1 | 0 | 10 | 10 | 10 | 10 | No special handling instructions. 2 | 1 | 10 | 10 | 10 | 10 | No special handling instructions. 3 | 2 | 10 | 10 | 10 | 10 | No special handling instructions. 4 | 3 | 10 | 10 | 10 | 10 | No special handling instructions. 5 | 4 | 10 | 10 | 10 | 10 | No special handling instructions. 6 | 5 | 10 | 10 | 10 | 10 | No special handling instructions. 7 | 6 | 10 | 10 | 10 | 10 | No special handling instructions. 8 | 7 | 10 | 10 | 10 | 10 | No special handling instructions. 9 | 8 | 10 | 10 | 10 | 10 | No special handling instructions. 10 | 9 | 10 | 10 | 10 | 10 | No special handling instructions. (10 rows)
Geben Sie \q
ein, um Cloud SQL zu beenden.
main.py
Wenn die Dateien data_model.py
, package-service.yaml
und connect_connector.py
geöffnet sind, erstellen Sie eine main.py
für die Anwendung.
Aufgabe 1: Mit der Python flask-Bibliothek eine Implementierung erstellen, die HTTP-REST-Endpunkte für diesen Dienst verwendet
Aufgabe 2: Verwenden Sie die Python flask-Bibliothek. Erstellen Sie eine Implementierung, die HTTP-REST-Endpunkte für diesen Dienst verwendet. und verwenden Sie SessionMaker aus „connect_conector.py“ für Paketdaten.
Aufgabe 3: Verwenden Sie die Python flask-Bibliothek. Erstellen Sie eine Implementierung, die HTTP-REST-Endpunkte für diesen Dienst verwendet. Importieren und verwenden Sie ein Paket aus „data_model.py“ und „SessionMaker“ aus „connect_conector.py“ für Paketdaten.
Aufgabe 4: Verwenden Sie die Python flask-Bibliothek. Erstellen Sie eine Implementierung, die HTTP-REST-Endpunkte für diesen Dienst verwendet. Import und Verwendung von Paketen aus data_model.py und SessionMaker aus connect_conector.py für Paketdaten. Host-IP 0.0.0.0 für app.run verwenden
Aktualisieren Sie die Anforderungen für main.py
.
Prompt: Anforderungsdatei für main.py erstellen
Hängen Sie dies an requirements.txt
-Datei an. Stellen Sie sicher, dass Sie Flask Version 3.0.0 verwenden.
Verwenden Sie OPEN
den Code wie zuvor in einem neuen Dateiworkflow. Speichern Sie den Code in einer Datei mit dem Namen
main.py
.
Die letzte Datei befindet sich im Abschnitt „ANHANG“ dieses Codelabs. Ist dies nicht der Fall, nehmen Sie die entsprechenden Änderungen manuell vor.
Setzen Sie das Duet AI-Chatprotokoll zurück, indem Sie oben in der Duet AI-Seitenleiste auf das Papierkorbsymbol klicken.
5. Anwendung testen und ausführen
Installieren Sie die Anforderungen.
pip3 install -r requirements.txt
Führen Sie main.py
aus.
python main.py
Die Ausgabe sieht in etwa so aus:
* Serving Flask app 'main' * Debug mode: off 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:5000 * Running on http://10.88.0.3:5000 Press CTRL+C to quit
Testen Sie an einem zweiten Terminal den Endpunkt /packages/<product_id>
.
curl localhost:5000/packages/1
Die Ausgabe sieht in etwa so aus:
{"depth":10.0,"height":10.0,"special_handling_instructions":"No special handling instructions.","weight":10.0,"width":10.0}
Sie können auch jede andere Produkt-ID in Ihren Beispieldaten testen.
Geben Sie CTRL_C
ein, um den laufenden Docker-Container im Terminal zu beenden.
Einheitentests werden generiert
Generieren Sie bei geöffneter Datei main.py
Einheitentests.
Aufgabe 1: Einheitentests generieren.
Verwenden Sie OPEN
den Code wie zuvor in einem neuen Dateiworkflow. Speichern Sie den Code in einer Datei mit dem Namen
test.py
.
In der Funktion test_get_package
muss eine product_id
definiert werden. Sie können sie manuell hinzufügen.
Die letzte Datei befindet sich im Abschnitt „ANHANG“ dieses Codelabs. Ist dies nicht der Fall, nehmen Sie die entsprechenden Änderungen manuell vor.
Setzen Sie das Duet AI-Chatprotokoll zurück, indem Sie oben in der Duet AI-Seitenleiste auf das Papierkorbsymbol klicken.
Einheitentests ausführen
Führen Sie den Einheitentest durch.
python test.py
Die Ausgabe sieht in etwa so aus:
. ---------------------------------------------------------------------- Ran 1 test in 1.061s OK
Schließen Sie alle Dateien im Cloud Shell-Editor und löschen Sie das Chatprotokoll. Klicken Sie dazu in der oberen Statusleiste auf das Papierkorbsymbol .
Dockerfile
Erstellen Sie eine Dockerfile
für diese Anwendung.
Öffne main.py
und versuche es mit den folgenden Aufforderungen.
Aufgabe 1: Generieren Sie ein Dockerfile für diese Anwendung.
Aufgabe 2: Generieren Sie ein Dockerfile für diese Anwendung. Kopieren Sie alle Dateien in den Container.
Außerdem musst du ENVARS
für INSTANCE_CONNECTION_NAME
, DB_USER
, DB_PASS
und DB_NAME
festlegen. Sie können dies manuell tun. Das Dockerfile sollte so aussehen:
FROM python:3.10-slim
WORKDIR /app
COPY . ./
RUN pip install -r requirements.txt
# Add these manually for your project
ENV INSTANCE_CONNECTION_NAME=YOUR_INSTANCE_CONNECTION_NAME
ENV DB_USER=evolution
ENV DB_PASS=evolution
ENV DB_NAME=product_details
CMD ["python", "main.py"]
Verwenden Sie OPEN
den Code wie zuvor in einem neuen Dateiworkflow. Speichern Sie den Code in einer Datei namens Dockerfile.
Die letzte Datei befindet sich im Abschnitt „ANHANG“ dieses Codelabs. Ist dies nicht der Fall, nehmen Sie die entsprechenden Änderungen manuell vor.
Anwendung lokal ausführen
Versuchen Sie bei geöffnetem Dockerfile
den folgenden Prompt.
Aufgabe 1: Wie führe ich einen Container mit diesem Dockerfile lokal aus
Folgen Sie der Anleitung.
# Build docker build -t shipping . # And run docker run -p 5000:5000 -it shipping
Die Ausgabe sieht in etwa so aus:
* Serving Flask app 'main' * Debug mode: off 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:5000 * Running on http://172.17.0.2:5000 Press CTRL+C to quit
Greifen Sie in einem zweiten Terminalfenster auf den Container zu.
curl localhost:5000/packages/1
Die Ausgabe sieht in etwa so aus:
{"depth":10.0,"height":10.0,"special_handling_instructions":"No special handling instructions.","weight":10.0,"width":10.0}
Die Containeranwendung funktioniert.
Geben Sie CTRL_C
ein, um den laufenden Docker-Container im Terminal zu beenden.
Container-Image in Artifact Registry erstellen
Erstellen Sie das Container-Image und übertragen Sie es per Push an Artifact Registry.
cd ~/shipping gcloud auth configure-docker us-central1-docker.pkg.dev docker build -t us-central1-docker.pkg.dev/${PROJECT_ID}/shipping/shipping . docker push us-central1-docker.pkg.dev/${PROJECT_ID}/shipping/shipping
Der Anwendungscontainer befindet sich jetzt unter us-central1-docker.pkg.dev/${PROJECT_ID}/shipping/shipping
und kann in GKE bereitgestellt werden.
6. Anwendung wird im GKE-Cluster bereitgestellt
Beim Erstellen der GCP-Ressourcen für diesen Workshop wurde ein GKE Autopilot-Cluster erstellt. Stellen Sie eine Verbindung zum GKE-Cluster her.
gcloud container clusters get-credentials gke1 \ --region=us-central1
Kommentieren Sie das Kubernetes-Standarddienstkonto mit dem Google-Dienstkonto.
kubectl annotate serviceaccount default iam.gke.io/gcp-service-account=cloudsqlsa@${PROJECT_ID}.iam.gserviceaccount.com
Die Ausgabe sieht in etwa so aus:
serviceaccount/default annotated
Bereiten Sie die Datei k8s.yaml vor und wenden Sie sie an.
cp ~/duetaidev/k8s.yaml_tmpl ~/shipping/. export INSTANCE_NAME=$(gcloud sql instances list --format='value(name)') export INSTANCE_CONNECTION_NAME=$(gcloud sql instances describe ${INSTANCE_NAME} --format="value(connectionName)") export IMAGE_REPO=us-central1-docker.pkg.dev/${PROJECT_ID}/shipping/shipping envsubst < ~/shipping/k8s.yaml_tmpl > k8s.yaml kubectl apply -f k8s.yaml
Die Ausgabe sieht in etwa so aus:
deployment.apps/shipping created service/shipping created
Warten Sie, bis die Pods ausgeführt werden und dem Dienst eine IP-Adresse für den externen Load Balancer zugewiesen ist.
kubectl get pods kubectl get service shipping
Die Ausgabe sieht in etwa so aus:
# kubectl get pods NAME READY STATUS RESTARTS AGE shipping-f5d6f8d5-56cvk 1/1 Running 0 4m47s shipping-f5d6f8d5-cj4vv 1/1 Running 0 4m48s shipping-f5d6f8d5-rrdj2 1/1 Running 0 4m47s # kubectl get service shipping NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE shipping LoadBalancer 34.118.225.125 34.16.39.182 80:30076/TCP 5m41s
Warten Sie bei GKE Autopilot-Clustern einen Moment, bis die Ressourcen bereit sind.
Greifen Sie über die EXTERNAL-IP
-Adresse auf den Dienst zu.
export EXTERNAL_IP=$(kubectl get svc shipping --output jsonpath='{.status.loadBalancer.ingress[0].ip}') curl http://${EXTERNAL_IP}/packages/1
Die Ausgabe sieht in etwa so aus:
{"depth":10.0,"height":10.0,"special_handling_instructions":"No special handling instructions.","weight":10.0,"width":10.0}
7. Zusätzlicher Schritt: Fehlerbehebung bei der Bewerbung
Entfernen Sie die IAM-Rolle „Cloud SQL-Client“ aus dem Dienstkonto cloudsqlsa
. Dies führt zu einem Fehler beim Herstellen einer Verbindung zur Cloud SQL-Datenbank.
gcloud projects remove-iam-policy-binding ${PROJECT_ID} \ --member="serviceAccount:cloudsqlsa@${PROJECT_ID}.iam.gserviceaccount.com" \ --role="roles/cloudsql.client"
Starten Sie den Versand-Pod neu.
kubectl rollout restart deployment shipping
Versuchen Sie nach dem Neustart des Pods noch einmal, auf den Dienst shipping
zuzugreifen.
export EXTERNAL_IP=$(kubectl get svc shipping --output jsonpath='{.status.loadBalancer.ingress[0].ip}') curl http://${EXTERNAL_IP}/packages/1
Die Ausgabe sieht in etwa so aus:
... <title>500 Internal Server Error</title> <h1>Internal Server Error</h1> <p>The server encountered an internal error and was unable to complete your request. Either the server is overloaded or there is an error in the application.</p>
Prüfen Sie die Logs unter Kubernetes Engine > Arbeitslasten
Klicken Sie auf das Deployment shipping
und dann auf den Tab Logs.
Klicken Sie rechts in der Statusleiste auf das Symbol Im Log-Explorer ansehen . Dadurch wird ein neues Fenster mit dem Log-Explorer geöffnet.
Klicken Sie auf einen der Traceback
-Fehlereinträge und dann auf Diesen Logeintrag erklären.
Lesen Sie die Erklärung des Fehlers.
Als Nächstes bitten wir Sie, den Fehler mithilfe von Duet AI zu beheben.
Versuchen Sie es mit dem folgenden Prompt.
Aufgabe 1: Hilfe bei der Fehlerbehebung
Geben Sie die Fehlermeldung in die Eingabeaufforderung ein.
Aufgabe 2: Verboten: Das authentifizierte IAM-Hauptkonto ist anscheinend nicht berechtigt, API-Anfragen zu senden. Cloud SQL Admin API überprüfen in Ihrem GCP-Projekt und im Cloud SQL-Client aktiviert ist, Rolle wurde dem IAM-Hauptkonto gewährt
Und dann.
Aufgabe 3: Wie weise ich mit gcloud einem Google-Dienstkonto die Rolle „Cloud SQL-Client“ zu?
Weisen Sie dem cloudsqlsa
die Rolle „Cloud SQL-Client“ zu.
gcloud projects add-iam-policy-binding ${PROJECT_ID} \ --member="serviceAccount:cloudsqlsa@${PROJECT_ID}.iam.gserviceaccount.com" \ --role="roles/cloudsql.client"
Warten Sie einen Moment und versuchen Sie dann noch einmal, auf die App zuzugreifen.
export EXTERNAL_IP=$(kubectl get svc shipping --output jsonpath='{.status.loadBalancer.ingress[0].ip}') curl http://${EXTERNAL_IP}/packages/1
Die Ausgabe sieht in etwa so aus:
{"depth":10.0,"height":10.0,"special_handling_instructions":"No special handling instructions.","weight":10.0,"width":10.0}
Sie haben Duet AI in Cloud Logging, Log Explorer und Log Explainer verwendet, um das Problem zu beheben.
8. Fazit
Glückwunsch! Du hast dieses Codelab erfolgreich abgeschlossen.
In diesem Codelab haben Sie Folgendes gelernt:
- Aktivieren Sie Duet AI in Ihrem GCP-Projekt und konfigurieren Sie es für die Verwendung in einer IDE und in der Cloud Console.
- Verwenden Sie Duet-KI zum Generieren, Vervollständigen und Erklärungen von Code.
- Mit Duet-KI ein Anwendungsproblem erklären und beheben
- Duet AI-Funktionen wie IDE-Chat und Chat in mehreren Schritten, Chat- und Inline-Codegenerierung, intelligente Aktionen wie Codeerklärung und Rezitationsbestätigung.
9. Anhang
package-service.yaml
swagger: "2.0"
info:
title: Shipping and Package Information API
description: This API provides information about shipping and packages.
version: 1.0.0
host: shipping.googleapis.com
schemes:
- https
produces:
- application/json
paths:
/packages/{product_id}:
get:
summary: Get information about a package
description: This method returns information about a package, including its height, width, depth, weight, and any special handling instructions.
parameters:
- name: product_id
in: path
required: true
type: integer
format: int64
responses:
"200":
description: A successful response
schema:
type: object
properties:
height:
type: integer
format: int64
width:
type: integer
format: int64
depth:
type: integer
format: int64
weight:
type: integer
format: int64
special_handling_instructions:
type: string
"404":
description: The product_id was not found
data_model.py
from sqlalchemy import Column, Integer, String, Float
from sqlalchemy.ext.declarative import declarative_base
from connect_connector import engine
Base = declarative_base()
class Package(Base):
__tablename__ = 'packages'
id = Column(Integer, primary_key=True)
product_id = Column(Integer, nullable=False)
height = Column(Float, nullable=False)
width = Column(Float, nullable=False)
depth = Column(Float, nullable=False)
weight = Column(Float, nullable=False)
special_handling_instructions = Column(String, nullable=True)
def create_tables():
Base.metadata.create_all(engine)
if __name__ == '__main__':
create_tables()
print('Tables created successfully.')
connect_connector.py
import os
from google.cloud.sql.connector import Connector, IPTypes
import sqlalchemy
# You may need to manually import pg8000 and Base as follows
import pg8000
from sqlalchemy.ext.declarative import declarative_base
def connect_with_connector() -> sqlalchemy.engine.base.Engine:
"""Initializes a connection pool for a Cloud SQL instance of Postgres."""
# Note: Saving credentials in environment variables is convenient, but not
# secure - consider a more secure solution such as
# Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
# keep secrets safe.
instance_connection_name = os.environ[
"INSTANCE_CONNECTION_NAME"
] # e.g. 'project:region:instance'
db_user = os.environ["DB_USER"] # e.g. 'my-database-user'
db_pass = os.environ["DB_PASS"] # e.g. 'my-database-password'
db_name = os.environ["DB_NAME"] # e.g. 'my-database'
ip_type = IPTypes.PRIVATE if os.environ.get("PRIVATE_IP") else IPTypes.PUBLIC
connector = Connector()
def getconn() -> sqlalchemy.engine.base.Engine:
conn: sqlalchemy.engine.base.Engine = connector.connect(
instance_connection_name,
"pg8000",
user=db_user,
password=db_pass,
db=db_name,
ip_type=ip_type,
)
return conn
pool = sqlalchemy.create_engine(
"postgresql+pg8000://",
creator=getconn,
# ...
)
return pool
# Create a connection pool
engine = connect_with_connector()
# Create a sessionmaker class to create new sessions
SessionMaker = sqlalchemy.orm.sessionmaker(bind=engine)
# Create a Base class for ORM
# You may need to manually fix the following
Base = declarative_base()
db_init.py
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from connect_connector import engine
from data_model import Package
def create_packages():
# Create a session
session = sessionmaker(bind=engine)()
# Create 10 sample packages
for i in range(10):
package = Package(
product_id=i,
height=10.0,
width=10.0,
depth=10.0,
weight=10.0,
special_handling_instructions="No special handling instructions."
)
# Add the package to the session
session.add(package)
# Commit the changes
session.commit()
if __name__ == '__main__':
create_packages()
print('Packages created successfully.')
main.py
from flask import Flask, request, jsonify
from data_model import Package
from connect_connector import SessionMaker
app = Flask(__name__)
session_maker = SessionMaker()
@app.route("/packages/<int:product_id>", methods=["GET"])
def get_package(product_id):
"""Get information about a package."""
session = session_maker
package = session.query(Package).filter(Package.product_id == product_id).first()
if package is None:
return jsonify({"message": "Package not found."}), 404
return jsonify(
{
"height": package.height,
"width": package.width,
"depth": package.depth,
"weight": package.weight,
"special_handling_instructions": package.special_handling_instructions,
}
), 200
if __name__ == "__main__":
app.run(host="0.0.0.0")
test.py
import unittest
from data_model import Package
from connect_connector import SessionMaker
from main import app
class TestPackage(unittest.TestCase):
def setUp(self):
self.session_maker = SessionMaker()
def tearDown(self):
self.session_maker.close()
def test_get_package(self):
"""Test the `get_package()` function."""
package = Package(
product_id=11, # Ensure that the product_id different from the sample data
height=10,
width=10,
depth=10,
weight=10,
special_handling_instructions="Fragile",
)
session = self.session_maker
session.add(package)
session.commit()
response = app.test_client().get("/packages/11")
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json,
{
"height": 10,
"width": 10,
"depth": 10,
"weight": 10,
"special_handling_instructions": "Fragile",
},
)
if __name__ == "__main__":
unittest.main()
requirements.txt
cloud-sql-python-connector==1.2.4
sqlalchemy==1.4.36
pg8000==1.22.0
Flask==3.0.0
gunicorn==20.1.0
psycopg2-binary==2.9.3
Dockerfile
FROM python:3.10-slim
WORKDIR /app
COPY . ./
RUN pip install -r requirements.txt
# Add these manually for your project
ENV INSTANCE_CONNECTION_NAME=YOUR_INSTANCE_CONNECTION_NAME
ENV DB_USER=evolution
ENV DB_PASS=evolution
ENV DB_NAME=product_details
CMD ["python", "main.py"]