App zur Fotorestaurierung mit Genkit Go und Nano Banana Pro erstellen

1. Einführung

In diesem Codelab erstellen wir GlowUp, ein Tool zur Fotorestaurierung. GlowUp nutzt KI, um alte, beschädigte oder Schwarz-Weiß-Fotos zu restaurieren und hochwertige 4K-Farbbilder zu erstellen. Mit diesem Tool kannst du deinen Familienfotos neues Leben einhauchen oder sogar beschädigte Illustrationen, Zeichnungen, Gemälde oder andere Bilder wiederherstellen.

Sie verwenden Genkit Go, um die Anwendungslogik zu implementieren, und Gemini 3 Pro Image (auch als Nano Banana Pro bezeichnet) als Modell, um die Fotos zu verarbeiten.

Vorbereitung

  • Grundkenntnisse der Programmiersprache Go
  • Grundkenntnisse der Google Cloud Console

Lerninhalte

  • Genkit-Anwendungen in Go entwickeln
  • Grundlegende Genkit-Konzepte wie Abläufe, Plug-ins und Prompts
  • Prompts mit Handlebars-Vorlagen schreiben
  • Bilddaten aus Modellantworten abrufen

Voraussetzungen

Dieser Workshop kann vollständig in der Google Cloud Shell durchgeführt werden, in der alle notwendigen Abhängigkeiten (gcloud CLI, Code-Editor, Go, Gemini CLI) vorinstalliert sind.

Alternativ können Sie auch auf Ihrem eigenen Computer arbeiten. Dazu benötigen Sie Folgendes:

  • Die Go-Toolchain (Version 1.24 oder höher)
  • Node.js v20 oder höher (für die genkit-Befehlszeile)
  • Ein Terminal mit installiertem gcloud-CLI
  • Eine IDE zum Bearbeiten Ihres Codes, z. B. VS Code oder eine ähnliche IDE
  • Empfohlen: ein Programmier-Agent wie die Gemini CLI oder Antigravity

Schlüsseltechnologien

Hier finden Sie weitere Informationen zu den Technologien, die wir verwenden werden:

  • Gemini Nano Banana Pro (Gemini 3 Pro Image): das Modell, das für den Restaurierungsprozess verwendet wird
  • Genkit Go: Unser Toolkit für die Orchestrierung von Modellaufrufen

2. Umgebung einrichten

Sie können dieses Lab auf Ihrem Computer oder vollständig in der Cloud ausführen. Auch wenn Sie den Code lokal ausführen, benötigen Sie ein Google Cloud-Projekt, damit die serverseitigen Komponenten in der Cloud bereitgestellt werden können. Folgen Sie der Anleitung im nächsten Abschnitt, um sie zu erstellen.

Umgebung zum selbstbestimmten Lernen einrichten

  1. Melden Sie sich in der Google Cloud Console an und erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes Projekt. Wenn Sie noch kein Gmail- oder Google Workspace-Konto haben, müssen Sie eines erstellen.

295004821bab6a87.png37d264871000675d.png96d86d3d5655cdbe.png

  • 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 sie 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). Die Cloud Console generiert automatisch einen eindeutigen String. In der Regel ist es egal, wie dieser lautet. In den meisten Codelabs müssen Sie auf Ihre Projekt-ID verweisen (normalerweise als PROJECT_ID gekennzeichnet). Wenn Ihnen die generierte ID nicht gefällt, können Sie eine andere zufällige ID generieren. Alternativ können Sie auch einen eigenen Namen ausprobieren und prüfen, ob er verfügbar ist. Sie kann nach diesem Schritt nicht mehr geändert werden und bleibt für die Dauer des Projekts bestehen.
  • Zur Information: Es gibt einen dritten Wert, eine Projektnummer, die von einigen APIs verwendet wird. Weitere Informationen zu allen drei Werten finden Sie in der Dokumentation.
  1. Als Nächstes müssen Sie in der Cloud Console die Abrechnung aktivieren, um Cloud-Ressourcen und ‑APIs verwenden zu können. Die Kosten für dieses Codelab sind gering, wenn überhaupt welche anfallen. Wenn Sie Ressourcen herunterfahren möchten, um zu vermeiden, dass Ihnen über diese Anleitung hinaus Kosten in Rechnung gestellt werden, können Sie die erstellten Ressourcen oder das Projekt löschen. Neue Google Cloud-Nutzer kommen für das Programm für die kostenlose Testversion mit einem Guthaben von 300 $ infrage.

Cloud Shell starten

Google Cloud kann zwar remote von Ihrem Laptop aus bedient werden, in diesem Codelab verwenden Sie jedoch die Google Cloud Shell, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.

Klicken Sie in der Google Cloud Console rechts oben in der Symbolleiste auf das Cloud Shell-Symbol:

Cloud Shell aktivieren

Die Bereitstellung und Verbindung mit der Umgebung sollte nur wenige Augenblicke dauern. Wenn der Vorgang abgeschlossen ist, wird in etwa Folgendes angezeigt:

Screenshot des Google Cloud Shell-Terminals, auf dem zu sehen ist, dass die Umgebung verbunden ist

Diese virtuelle Maschine verfügt über sämtliche Entwicklertools, die Sie benötigen. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft in Google Cloud, was die Netzwerkleistung und Authentifizierung erheblich verbessert. Alle Aufgaben in diesem Codelab können in einem Browser erledigt werden. Sie müssen nichts installieren.

3. Projekt einrichten

Projekt erstellen

Zuerst müssen wir ein neues Verzeichnis für Ihr Projekt erstellen und das Go-Modul initialisieren. Führen Sie im Terminal die folgenden Befehle aus:

mkdir -p glowup && cd glowup
go mod init glowup

Genkit-Befehlszeile installieren

Jetzt müssen wir die Genkit-Befehlszeile installieren. Dadurch erhältst du Zugriff auf lokale Entwicklertools, einschließlich der Entwickler-UI. Geben Sie im Terminalfenster Folgendes ein:

curl -sL cli.genkit.dev | bash

Umgebungsvariablen konfigurieren

Prüfen Sie, ob Ihre Google Cloud-Anmeldedaten korrekt eingerichtet sind. Der Standort muss global sein, wenn Sie Gemini 3 Pro-Vorabversionen verwenden (Nano Banana Pro ist eine davon).

export GOOGLE_CLOUD_PROJECT=$(gcloud config get project)
export GOOGLE_CLOUD_LOCATION=global

Führen Sie den folgenden Befehl im Shell-Modus aus, um die Vertex AI API für das aktuelle Projekt zu aktivieren:

gcloud services enable aiplatform.googleapis.com

Wenn Sie von Ihrem lokalen Computer aus arbeiten (nicht in Cloud Shell), müssen Sie sich mit dem gcloud-Befehl authentifizieren:

gcloud auth application-default login

4. Erste Genkit-Anwendung erstellen

Genkit ist ein Open-Source-Framework, mit dem Entwickler produktionsreife KI-gestützte Anwendungen erstellen, bereitstellen und überwachen können. In diesem Abschnitt erstellen wir eine einfache „Hello World“-Anwendung, damit Sie sich mit dem Framework vertraut machen können, bevor wir uns mit der Logik für die Fotorestaurierung befassen.

Genkit-Terminologie

Bevor Sie mit Genkit arbeiten, sollten Sie sich mit einigen wichtigen Begriffen vertraut machen:

  • Plug-ins: werden verwendet, um die Funktionen von Genkit zu erweitern. Unter anderem registrieren Sie über Plug-ins KI-Modelle, die Ihre Anwendung unterstützen.
  • Flows: Die wichtigste Architekturkomponente von Genkit. In einem typischen Ablauf wird eine Eingabe verarbeitet und eine Ausgabe zurückgegeben. Es ist nicht unbedingt erforderlich, ein Modell zu verwenden, aber in den meisten Fällen werden Sie Modelle in Ihren Abläufen verwenden.
  • Prompts: Interaktionsvorlagen, die im dotprompt-Format gespeichert sind (als *.prompt-Dateien). Diese enthalten nicht nur die Modellanweisungen, sondern auch Konfigurationen wie Modellname, Modellparameter, Eingaben und Ausgaben.

Verbindung zu KI-Modellen herstellen

Genkit verwendet Plug-ins, um Ihren Code mit Modellanbietern zu verbinden. Es gibt Plug-ins für alle gängigen Modellanbieter, darunter Google, Anthropic und OpenAI.Sie können Plug-ins auch verwenden, um eine Verbindung zu lokalen Modellen herzustellen (z.B. mit Ollama) oder die Funktionen von Genkit zu erweitern (z.B. Verbindung zu MCP-Servern).

Für den Zugriff auf Google-Modelle sollten Sie das googlegenai-Plug-in verwenden. Er unterstützt zwei Backends:

  • Google AI: Am besten für das Prototyping geeignet. Verwendet einen API-Schlüssel.
  • Vertex AI (Google Cloud): Empfohlen für die Produktion. Verwendet Projekt-ID und Standort.

In diesem Codelab verwenden wir die Vertex AI-Authentifizierung und verweisen auf das Projekt, das Sie zu Beginn des Labs erstellt haben.

Begrüßungsablauf erstellen

Bevor wir uns mit dem Ablauf für die Fotorestaurierung in Glow Up befassen, erstellen wir einen einfachen Ablauf, um uns mit den Konzepten vertraut zu machen und zu prüfen, ob unsere Einrichtung ordnungsgemäß funktioniert.

Ein Flow ist eine spezielle Genkit-Funktion, die Ihre KI-Logik umschließt und Folgendes bietet:

  • Typsichere Ein- und Ausgaben: Schemas mit Go-Strukturen für die statische und Laufzeitvalidierung definieren
  • Streaming-Unterstützung: Teilantworten oder benutzerdefinierte Daten streamen
  • Integration der Entwickler-UI: Testen und debuggen Sie Abläufe mit visuellen Traces.
  • Einfache Bereitstellung: Bereitstellung als HTTP-Endpunkte auf einer beliebigen Plattform

Öffnen Sie Ihre IDE und erstellen Sie eine main.go-Datei in Ihrem Projektverzeichnis. Wenn Sie Cloud Shell verwenden, können Sie den folgenden Befehl verwenden:

cloudshell edit main.go

Fügen Sie dann den folgenden Code hinzu:

main.go

package main

import (
        "context"
        "log"
        "os"
        "os/signal"
        "syscall"

        "github.com/firebase/genkit/go/genkit"
        "github.com/firebase/genkit/go/ai"
        "github.com/firebase/genkit/go/plugins/googlegenai"
)

func main() {
        ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
        defer cancel()

        // Initialize Genkit with the Vertex AI plugin
        g := genkit.Init(ctx,
                genkit.WithPlugins(&googlegenai.VertexAI{}),
        )

        // Define the greeter flow
        genkit.DefineFlow(g, "greeter", func(ctx context.Context, name string) (string, error) {
                text, err := genkit.GenerateText(ctx, g,
                        ai.WithModelName("vertexai/gemini-2.5-pro"),
                        ai.WithPrompt("Say a warm and creative hello to %s", name),
                )
                if err != nil {
                        return "", err
                }

                return text, nil
        })

        // Register the flow here in the next steps
        log.Println("GlowUp initialized. Ready for flows.")
        <-ctx.Done()
}

Speichern Sie die Datei und führen Sie dann go mod tidy aus, um Ihre Abhängigkeiten zu aktualisieren:

go mod tidy

Der obige Code initialisiert Genkit mit dem VertexAI-Plug-in, definiert einen Ablauf namens „greeter“ und wartet dann unbegrenzt auf <-ctx.Done(). Wir halten die Ausführung an, damit dieses Programm nicht sofort beendet wird, da wir ihm keine Anweisungen zur tatsächlichen Ausführung des Ablaufs geben.

Wenn Sie dieses Programm so ausführen, wie es jetzt ist, wird es von sich aus nicht viel tun. Wir müssen den Ablauf irgendwie aufrufen. In einer echten Produktionsanwendung würden wir diesen Ablauf in einen Webserver oder eine CLI-Anwendung einbinden. Während der Entwicklung können wir jedoch die genkit-CLI verwenden, um den Ablauf zu entwickeln und zu optimieren.

Die genkit-Befehlszeile wurde entwickelt, um Modelle, Prompts, Abläufe und andere Komponenten des Genkit-Stacks zu testen. Außerdem werden Traces vollständig unterstützt. Das ist sehr praktisch, wenn Sie nachvollziehen möchten, wie die Anwendung im Hintergrund funktioniert. Führen Sie den folgenden Befehl aus, um den Begrüßungsablauf mit der genkit-Befehlszeile zu starten:

genkit start -- go run main.go

Dadurch werden die Telemetry API- und Entwickler-UI-Endpunkte gestartet. Auf dem Bildschirm sollte Folgendes zu sehen sein:

$ genkit start -- go run main.go
Telemetry API running on http://localhost:4033
Project root: /home/daniela/glowup
Genkit Developer UI: http://localhost:4000

Wenn Sie localhost:4000 in Ihrem Browser öffnen, um die Entwicklungsoberfläche zu starten. Sie sollten Folgendes sehen:

93d9bd9e1bd6627d.png

Nehmen Sie sich Zeit, um die Entwicklungsoberfläche zu erkunden. Lösen Sie den Flow „greeter“ einmal aus, um zu sehen, wie er funktioniert.

Prompt-Vorlagen verwenden

Sie können Ihre Prompts in Modellaufrufen hartcodieren, wie wir es im vorherigen Beispiel getan haben. Ein besserer Ansatz wäre jedoch, Prompt-Vorlagen zu erstellen, um alle Prompts Ihrer Anwendung zentral zu speichern. So lassen sie sich bei der Wartung des Codes leichter finden und Sie können unabhängig von den Abläufen mit den Prompts experimentieren.

Zum Definieren von Prompt-Vorlagen verwendet Genkit das Open-Source-Format dotprompt, das als *.prompt-Dateien gespeichert wird. Eine .prompt-Datei besteht aus zwei Teilen:

  1. Frontmatter: Ein YAML-Block, der das Modell, die Modellparameter sowie die Eingabe- und Ausgabeschemas definiert.
  2. Text: Der Text des Prompts selbst, der mit der „Handlebars“-Syntax als Vorlage verwendet werden kann. Wenn Sie beispielsweise eine Eingabe mit dem Namen variable-name definieren, können Sie im Text mit {{variable-name}} darauf verweisen.

Die Verzeichnisstruktur des Projekts sieht so aus:

glowup/
 ├── main.go        
 └── prompts/
      └── greeter.prompt

Sehen wir uns das einmal genauer an. Erstellen Sie zuerst den Ordner, in dem die Prompts gespeichert werden sollen:

mkdir -p prompts

Erstellen Sie dann eine greeter.prompt-Datei:

cloudshell edit prompts/greeter.prompt

Fügen Sie den folgenden Inhalt ein:

greeter.prompt

ec9fc82a98604123.png

Dieser Prompt zeigt einige der Funktionen der Vorlagensprache. Zuerst geben wir das Modell vertexai/gemini-2.5-flash im Frontmatter an. Wenn Sie ein Modell angeben möchten, müssen Sie die in der jeweiligen Plug-in-Dokumentation definierte Nomenklatur verwenden.

Im Abschnitt „config“ können wir die Modellparameter konfigurieren. Wir verwenden die Temperatur 1,9, damit das Modell kreativer sein kann. Die Temperatur reicht von 0 (konsistentere Ausgaben) bis 2 (kreativere Ausgaben). Dieser und andere Modellparameter werden normalerweise im Modellblatt des Modells veröffentlicht. Hier ist beispielsweise das Modellblatt für gemini-2.5-flash.

Im Eingabebereich können wir Argumente für den Prompt angeben. In diesem Fall definieren wir den Namen als String. Nach dem Frontmatter folgt der Prompt-Text. Der erste Block definiert den System-Prompt und der zweite Block den Nutzer-Prompt. Alle diese Elemente zusammen ermöglichen einige sehr leistungsstarke Prompting-Techniken. Die vollständige Dokumentation zu dotprompt finden Sie hier.

Passen Sie jetzt den greeter-Flow an, um den gerade erstellten Prompt zu verwenden:

main.go

package main

import (
        "context"
        "os"
        "os/signal"
        "syscall"

        "github.com/firebase/genkit/go/ai"
        "github.com/firebase/genkit/go/genkit"
        "github.com/firebase/genkit/go/plugins/googlegenai"
)

func main() {
        ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
        defer cancel()

        // Initialize Genkit with the Vertex AI plugin
        g := genkit.Init(ctx,
                genkit.WithPlugins(&googlegenai.VertexAI{}),
                genkit.WithDefaultModel("vertexai/gemini-2.5-flash"),
        )

        // Define the greeter flow
        genkit.DefineFlow(g, "greeter", func(ctx context.Context, name *string) (string, error) {
                prompt := genkit.LookupPrompt(g, "greeter")

                input := map[string]any{
                        "name": name,
                }

                resp, err := prompt.Execute(ctx, ai.WithInput(input))
                if err != nil {
                        return "", err
                }
                return resp.Text(), nil
        })

        <-ctx.Done()
}

Führen Sie den Ablauf über die Befehlszeile mit und ohne Namen aus, um den Unterschied zu sehen. Ausführung ohne Namen:

genkit flow:run greeter

Beispielausgabe:

$ genkit flow:run greeter
Telemetry API running on http://localhost:4035
Running '/flow/greeter' (stream=false)...
Result:
"Hello there, absolutely delightful human!\n\nThe very moment your message arrived, the day instantly sparkled a little brighter. It's not just nice, it's genuinely **wonderful** to meet you!\n\nMay your entire day be filled with unexpected pockets of joy, effortless triumphs, and all the happiness you truly deserve! We're thrilled to have you here!"

Und mit einem Namen:

genkit flow:run greeter '"Daniela"'

Beispielausgabe:

$ genkit flow:run greeter '"Daniela"'
Telemetry API running on http://localhost:4035
Running '/flow/greeter' (stream=false)...
Result:
"Well hello there, Daniela! What a truly beautiful name, and what an absolute pleasure it is to meet you!\n\nRight from this moment, I just know your day is going to be brimming with positive energy and wonderful surprises. May it be filled with brilliant ideas, joyful moments, and the delightful realization that you're an amazing person doing incredible things. So glad you're here!"

Die Vorlage hat wie erwartet funktioniert. Wir sind bereit, dieses Projekt auf die nächste Stufe zu bringen!

5. Bilder mit Nano Banana Pro wiederherstellen

Aufforderung zur Wiederherstellung

Nachdem Sie nun mit den Bausteinen von Genkit vertraut sind, können Sie den Prompt für die Fotorestaurierung erstellen.

Erstellen Sie im Verzeichnis „prompts“ eine Datei mit dem Namen glowup.prompt und fügen Sie den folgenden Inhalt ein:

glowup.prompt

fd0f1551466c8138.png

Der Prompt für die Wiederherstellung folgt demselben Muster wie der Prompt für die Begrüßung, mit nur wenigen nennenswerten Unterschieden:

  • Bildgröße: Das Attribut imageSize von imageConfig ist ein modellspezifischer Parameter von Nano Banana Pro. Damit können wir die Ausgabegröße als 1K, 2K oder 4K angeben.
  • Medieneingabe: Wir verwenden die Vorlage {{ media }}, um das Foto in den Nutzer-Prompt einzufügen. Mit dieser Technik können wir multimodale Prompts (Text und Bild) an das Modell senden.

Sie können diesen Prompt in der Entwickler-UI testen. Sie können ihn gerne anpassen, um zu sehen, wie sich das auf die Ausgabe auswirkt.

Ablauf der Bildwiederherstellung

Nachdem der Prompt für die Wiederherstellung bereit ist, erstellen wir jetzt unsere CLI-Anwendung. Ersetzen Sie den Inhalt von main.go durch den folgenden Code:

main.go

package main

import (
        "context"
        "encoding/base64"
        "errors"
        "flag"
        "fmt"
        "log"
        "mime"
        "os"
        "os/signal"
        "strings"
        "syscall"

        "github.com/firebase/genkit/go/ai"
        "github.com/firebase/genkit/go/genkit"
        "github.com/firebase/genkit/go/plugins/googlegenai"
)

func main() {
        url := flag.String("url", "", "url of the image to restore")
        contentType := flag.String("contentType", "image/jpeg", "content type of the image (default: image/jpeg)")
        flag.Parse()

        ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
        defer cancel()

        // Initialize Genkit with the Vertex AI plugin
        g := genkit.Init(ctx,
                genkit.WithPlugins(&googlegenai.VertexAI{}),
        )

        // Input schema for the glowUp flow
        type Input struct {
                URL         string `json:"url,omitempty"`
                ContentType string `json:"contentType,omitempty"`
        }

        glowup := genkit.DefineFlow(g, "glowUp", func(ctx context.Context, input Input) (string, error) {
                // 1. Retrieve prompt
                prompt := genkit.LookupPrompt(g, "glowup")
                if prompt == nil {
                        return "", errors.New("prompt 'glowup' not found")
                }

                resp, err := prompt.Execute(ctx, ai.WithInput(input))
                if err != nil {
                        return "", fmt.Errorf("generation failed: %w", err)
                }

                return resp.Media(), nil
        })

        // triggers the flow and returns the encoded response from the model
        out, err := glowup.Run(ctx, Input{URL: *url, ContentType: *contentType})
        if err != nil {
                log.Fatalln(err)
        }

        // decodes image data and returns the appropriate file extension
        data, ext, err := decode(out)
        if err != nil {
                log.Fatalln(err)
        }

        // writes restored file to disk
        filename := "restored" + ext
        if err := os.WriteFile(filename, data, 0644); err != nil {
                log.Fatalln(err)
        }
}

// decode returns the decoded data and the file extension appropriate for the mime type
func decode(text string) ([]byte, string, error) {
        if !strings.HasPrefix(text, "data:") {
                return nil, "", errors.New("unsupported enconding format")
        }
        text = strings.TrimPrefix(text, "data:")
        parts := strings.Split(text, ";base64,")

        mimeType := parts[0]
        decoded, err := base64.StdEncoding.DecodeString(parts[1])
        if err != nil {
                return nil, "", err
        }

        ext, err := mime.ExtensionsByType(mimeType)
        if err != nil {
                return nil, "", err
        }

        return decoded, ext[0], nil
}

Der Code ist in seiner Struktur dem greeter-Ablauf sehr ähnlich, wurde aber dieses Mal so angepasst, dass er als eigenständige CLI-Anwendung ausgeführt werden kann. Anstatt für immer zu blockieren, wird der glowUp-Ablauf ausgeführt, die Ausgabe decodiert und die resultierenden Binärdaten auf dem Laufwerk gespeichert.

Wir müssen die Ausgabe decodieren, da das Modell die Bilddaten im folgenden Format zurückgibt:

data:<mime type>;base64,<base64 encoded image>

In der Funktion decode sehen Sie, dass wir die Stringmanipulation verwenden, um den MIME-Typ und die codierten Bildteile aufzuteilen. Anschließend verwenden wir die Funktionen mime.ExtensionByType und base64.DecodeString, um die Informationen zu extrahieren, die wir zum Speichern der Datei benötigen.

Wiederherstellungsprozess testen

Jetzt ist es endlich an der Zeit, diesen Ablauf mit einem echten Bild auszuführen. Wenn Sie keine alten Fotos zur Hand haben, die restauriert werden müssen, können Sie es mit diesem Bild aus der Library of Congress versuchen, das frei von Urheberrechten ist:

f0fc83a81e88052a.png

Hier ist der direkte Link zum Foto, um es an den Ablauf zu übergeben: https://tile.loc.gov/storage-services/service/pnp/fsa/8c01000/8c01700/8c01765v.jpg

export IMAGE_URL="https://tile.loc.gov/storage-services/service/pnp/fsa/8c01000/8c01700/8c01765v.jpg"
go run main.go --url $IMAGE_URL

Und hier ist die restaurierte und kolorierte Ausgabe:

5ed7bfcf6d26313c.png

Fertig!

6. glowUp als Webdienst bereitstellen

Wenn Sie Ihre Abläufe nicht in einer Befehlszeilenanwendung, sondern in einem Webdienst bereitstellen möchten, bietet Genkit eine bequeme Möglichkeit, Abläufe mit dem genkit.Handler-Adapter in Endpunkte umzuwandeln. Im folgenden Code wird der glowUp-Flow mit genkit.Handler als glowUp-Endpunkt registriert.

Sie können sie mit einem regulären HTTP-Server verfügbar machen, wie Sie es normalerweise mit dem http-Paket aus der Standardbibliothek tun würden. Genkit bietet aber auch ein server-Plug-in, das bei einigen der gängigen Server-Boilerplates hilft, z. B. beim ordnungsgemäßen Verarbeiten von Signalen zum Herunterfahren.

Ersetzen Sie den Inhalt von main.go durch den folgenden Code, um Ihren Webserver zu erstellen.

package main

import (
        "context"
        "errors"
        "fmt"
        "log"
        "net/http"
        "os"

        "github.com/firebase/genkit/go/ai"
        "github.com/firebase/genkit/go/genkit"
        "github.com/firebase/genkit/go/plugins/googlegenai"
        "github.com/firebase/genkit/go/plugins/server"
)

func main() {
        ctx := context.Background()

        PORT := os.Getenv("PORT")
        if PORT == "" {
                PORT = "8080"
        }

        listenAddr := ":" + PORT

        // Initialize Genkit with the Vertex AI plugin
        g := genkit.Init(ctx,
                genkit.WithPlugins(&googlegenai.VertexAI{}),
        )

        // Input schema for the glowUp flow
        type Input struct {
                URL         string `json:"url,omitempty"`
                ContentType string `json:"contentType,omitempty"`
        }

        genkit.DefineFlow(g, "glowUp", func(ctx context.Context, input Input) (string, error) {
                prompt := genkit.LookupPrompt(g, "glowup")
                if prompt == nil {
                        return "", errors.New("prompt 'glowup' not found")
                }

                resp, err := prompt.Execute(ctx, ai.WithInput(input))
                if err != nil {
                        return "", fmt.Errorf("generation failed: %w", err)
                }

                return resp.Media(), nil
        })

        log.Printf("GlowUp Flow Server started. Listening on %s", listenAddr)
        mux := http.NewServeMux()
        for _, flow := range genkit.ListFlows(g) {
                mux.HandleFunc("POST /"+flow.Name(), genkit.Handler(flow))
        }

        if err := server.Start(ctx, listenAddr, mux); err != nil {
                // Check if the error is due to context cancellation
                if ctx.Err() != nil {
                        log.Println("GlowUp server shutting down gracefully...")
                        return
                }
                log.Fatal(err)
        }
}

Sie können diesen Dienst entweder lokal oder in der Cloud ausführen. Wenn Sie das Programm lokal ausführen möchten, können Sie die Datei direkt ausführen, da das Programm jetzt vollständig ist. Sie müssen es also nicht über die Genkit-Befehlszeile starten. Beispiel:

go run main.go

Da es sich um einen blockierenden Vorgang handelt, müssen Sie zum Testen ein zweites Terminal starten. Am schnellsten geht das mit dem Befehl curl:

curl -sS -X POST http://localhost:8080/glowUp \
     -H "Content-Type: application/json" \
     -d '{"data":{"url": $IMAGE_URL, "contentType":"image/jpeg"}}' \
     > result.json

Da es sich um eine Serverantwort handelt, müssen wir das Base64-Bild decodieren:

cat result.json | jq -r '.result' | awk -F ',' '{print $2}' | base64 -d > restored.png

Webdienst in Cloud Run bereitstellen

Es ist in Ordnung, dass dieser Server „auf meinem Computer funktioniert“, aber im Idealfall würden wir ihn an einem anderen Ort bereitstellen, der für alle unsere Nutzer zugänglich ist. Eine der einfachsten Möglichkeiten, solche Dienste bereitzustellen, ist die Cloud Run-Funktion „Aus der Quelle bereitstellen“. Mit dieser Funktion müssen Sie den Container nicht einmal selbst erstellen, alles ist automatisiert.

Führen Sie den folgenden Befehl aus, um diesen Dienst mithilfe der Bereitstellung aus der Quelle in Cloud Run bereitzustellen. Ersetzen Sie dabei die Projekt-ID durch Ihre eigene:

gcloud run deploy glowup --source . --region us-central1 --no-allow-unauthenticated --set-env-vars GOOGLE_GENAI_USE_VERTEXAI=True,GOOGLE_CLOUD_LOCATION=$GOOGLE_CLOUD_LOCATION,GOOGLE_CLOUD_PROJECT=$GOOGLE_CLOUD_PROJECT

Die Bereitstellung kann einige Minuten dauern. Anschließend können Sie den Endpunkt testen, indem Sie eine weitere Anfrage über curl senden:

GLOWUP_URL=$(gcloud run services describe glowup --region us-central1 --format='value(status.url)')

curl -X POST "$GLOWUP_URL/glowUp" \
     -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
     -H "Content-Type: application/json" \
     -d "{\"data\":{\"url\":\"$IMAGE_URL\", \"contentType\":\"image/jpeg\"} }" \
     > result.json

Auch hier müssen wir das Base64-Bild decodieren:

cat result.json | jq -r '.result' | awk -F ',' '{print $2}' | base64 -d > restored_cloudrun.png

Jetzt haben wir einen voll funktionsfähigen Webserver für die Fotorestaurierung.

Optional: „Vibe Coding“ einer Clientanwendung

Code manuell zu schreiben, macht Spaß, kann aber auch eine Herausforderung sein, wenn Sie noch nie ein bestimmtes Projekt durchgeführt haben. Zum Glück gibt es heute KI-Agenten, die uns dabei helfen, den Prozess zu beschleunigen.

In diesem Schritt schreiben wir den Code nicht selbst, sondern bitten die Gemini CLI (oder Ihren bevorzugten Programmier-Agenten), die Arbeit für uns zu erledigen. Verwenden Sie den folgenden Prompt:

GlowUp is a photo restoration service that takes a restoration request as input and returns a restored picture as output. Your task is to create a client application that uses this server to process image urls and save a restored file locally.

TODO:
- Write a CLI application that receives three arguments: an url (required), content type (optional, defaults to image/jpeg) and addr (server address, optional, defaults to localhost:8080)
- The CLI should send a POST request to the /glowUp endpoint in the server with the body '{"data":{"url": <url>, "contentType": <contentType>} }'
- The server response should be parsed by stripping the "data:" prefix. The remainder will have the format <mimeType>;base64,<encoded imageData>
- Extract the mime type and convert to a file extension using the mime package
- Extract the image data and decode it using the base64 package
Save a file named "restored" + the detected file extension

Acceptance Criteria:
- The client builds successfully
- Use the client to restore the image https://tile.loc.gov/storage-services/service/pnp/fsa/8c01000/8c01700/8c01765v.jpg
- Check that restored.png exists after processing the image above

Der KI-Agent muss die Dateien möglicherweise etwas umorganisieren, da wir nicht zwei „main“-Funktionen im selben Modul haben können. Beobachten Sie, wie er arbeitet, und steuern Sie ihn in Richtung der richtigen Implementierung, indem Sie ihm bei Bedarf den Servercode oder Snippets zur Verfügung stellen.

Nach dem Lab aufräumen

7. Fazit

Glückwunsch! Sie haben mit Genkit und Nano Banana Pro eine Anwendung zur Fotorestaurierung mit hoher Wiedergabetreue erstellt,

In diesem Codelab haben Sie Folgendes gelernt:

  • Umgebung für die Entwicklung von Genkit Go-Anwendungen konfigurieren
  • Multimodale Prompts mit dotprompt erstellen
  • Genkit-Abläufe mit Prompt-Vorlagen erstellen
  • Bilder mit Nano Banana Pro verarbeiten
  • Genkit-Abläufe als Befehlszeilenanwendungen und Webdienste verpacken
  • Genkit-Anwendungen in Cloud Run bereitstellen

Denken Sie daran, die Umgebung nach Abschluss der Tests zu bereinigen.

Nächste Schritte

Sie können Ihre Lernreise fortsetzen, indem Sie sich andere Codelabs auf dieser Plattform ansehen oder glowUp selbst verbessern.

Wenn Sie Ideen für Verbesserungen benötigen, können Sie Folgendes ausprobieren:

  • glowUp CLI zum Wiederherstellen lokaler Dateien aktivieren
  • Frontend für den GlowUp-Webdienst erstellen
  • MIME-Typ automatisch aus den Daten erkennen
  • Andere Arten der Bildverarbeitung (von Foto zu Zeichnung, von Zeichnung zu Foto, von Skizze zu fertigem Kunstwerk usw.)
  • Client erstellen oder verbessern (vielleicht eine Smartphone-App entwickeln?)

Die Möglichkeiten sind einfach endlos. Wenn Sie sich nicht sicher sind, ob Sie das allein schaffen, können Sie sich jederzeit von einem KI-Agenten wie der Gemini CLI oder Antigravity helfen lassen. Wenn Sie mehr mit Genkit machen möchten, können Coding-Agents in Kombination mit dem Genkit-MCP-Server Ihnen die Arbeit erleichtern.

Den vollständigen Code für dieses Repository finden Sie hier.

Viel Spaß beim Programmieren!