1. Introduction
Dans cet atelier de programmation, nous allons créer GlowUp, un outil de restauration de photos. GlowUp utilise l'IA pour restaurer les photos anciennes, endommagées ou en noir et blanc, et créer des images couleur 4K de haute qualité. Vous pouvez utiliser cet outil pour redonner vie à vos photos de famille, ou même l'adapter pour restaurer des illustrations, des dessins, des peintures ou d'autres types d'images endommagés.
Vous utiliserez Genkit Go pour implémenter la logique de l'application et Gemini 3 Pro Image (également appelé Nano Banana Pro) comme modèle pour traiter les photos.
Prérequis
- Connaissances de base du langage de programmation Go
- Connaissances de base de la console Google Cloud
Points abordés
- Développer des applications Genkit en Go
- Concepts de base de Genkit, tels que les flux, les plug-ins et les requêtes
- Rédiger des prompts avec des modèles Handlebars
- Obtenir des données d'image à partir des réponses du modèle
Prérequis
Cet atelier peut être entièrement réalisé dans Google Cloud Shell, qui est préinstallé avec toutes les dépendances nécessaires (gcloud CLI, éditeur de code, Go, Gemini CLI).
Sinon, si vous préférez travailler sur votre propre machine, vous aurez besoin des éléments suivants :
- La chaîne d'outils Go (version 1.24 ou ultérieure)
- Node.js v20 ou version ultérieure (pour la CLI
genkit) - Un terminal sur lequel la CLI
gcloudest installée - Un IDE pour modifier votre code, comme VS Code ou un outil similaire
- Recommandé : un agent de codage comme Gemini CLI ou Antigravity
Technologies clés
Vous trouverez ici plus d'informations sur les technologies que nous allons utiliser :
- Gemini Nano Banana Pro (Gemini 3 Pro Image) : le modèle qui alimente notre processus de restauration
- Genkit Go : notre kit d'outils pour orchestrer les appels de modèle
2. Configuration de l'environnement
Vous pouvez exécuter cet atelier depuis votre ordinateur ou entièrement dans le cloud. Même si vous décidez d'exécuter le code localement, vous aurez besoin d'un projet Google Cloud pour déployer les composants côté serveur sur le cloud. Suivez les étapes de la section suivante pour le créer.
Configuration de l'environnement au rythme de chacun
- Connectez-vous à la console Google Cloud, puis créez un projet ou réutilisez un projet existant. (Si vous ne possédez pas encore de compte Gmail ou Google Workspace, vous devez en créer un.)



- Le nom du projet est le nom à afficher pour les participants au projet. Il s'agit d'une chaîne de caractères qui n'est pas utilisée par les API Google. Vous pourrez toujours la modifier.
- L'ID du projet est unique parmi tous les projets Google Cloud et non modifiable une fois défini. La console Cloud génère automatiquement une chaîne unique (en général, vous n'y accordez d'importance particulière). Dans la plupart des ateliers de programmation, vous devrez indiquer l'ID de votre projet (généralement identifié par
PROJECT_ID). Si l'ID généré ne vous convient pas, vous pouvez en générer un autre de manière aléatoire. Vous pouvez également en spécifier un et voir s'il est disponible. Après cette étape, l'ID n'est plus modifiable et restera donc le même pour toute la durée du projet. - Pour information, il existe une troisième valeur (le numéro de projet) que certaines API utilisent. Pour en savoir plus sur ces trois valeurs, consultez la documentation.
- Vous devez ensuite activer la facturation dans la console Cloud pour utiliser les ressources/API Cloud. L'exécution de cet atelier de programmation est très peu coûteuse, voire sans frais. Pour désactiver les ressources et éviter ainsi que des frais ne vous soient facturés après ce tutoriel, vous pouvez supprimer le projet ou les ressources que vous avez créées. Les nouveaux utilisateurs de Google Cloud peuvent participer au programme d'essai sans frais pour bénéficier d'un crédit de 300 $.
Démarrer Cloud Shell
Bien que Google Cloud puisse être utilisé à distance depuis votre ordinateur portable, nous allons nous servir de Google Cloud Shell pour cet atelier de programmation, un environnement de ligne de commande exécuté dans le cloud.
Dans la console Google Cloud, cliquez sur l'icône Cloud Shell dans la barre d'outils supérieure :

Le provisionnement et la connexion à l'environnement prennent quelques instants seulement. Une fois l'opération terminée, le résultat devrait ressembler à ceci :

Cette machine virtuelle contient tous les outils de développement nécessaires. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud, ce qui améliore nettement les performances du réseau et l'authentification. Vous pouvez effectuer toutes les tâches de cet atelier de programmation dans un navigateur. Vous n'avez rien à installer.
3. Configuration du projet
Créer le projet
Tout d'abord, nous devons créer un répertoire pour votre projet et initialiser le module Go. Dans le terminal, exécutez les commandes suivantes :
mkdir -p glowup && cd glowup
go mod init glowup
Installer la CLI Genkit
Nous devons maintenant installer la CLI Genkit. Vous avez ainsi accès aux outils de développement locaux, y compris à l'UI de développement. Dans la fenêtre de terminal, saisissez :
curl -sL cli.genkit.dev | bash
Configurer les variables d'environnement
Assurez-vous d'avoir configuré les bons identifiants Google Cloud. L'emplacement doit être global lorsque vous utilisez des modèles Gemini 3 Pro Preview (Nano Banana Pro en fait partie).
export GOOGLE_CLOUD_PROJECT=$(gcloud config get project)
export GOOGLE_CLOUD_LOCATION=global
Exécutez la commande suivante en mode shell pour activer l'API Vertex AI pour le projet actuel :
gcloud services enable aiplatform.googleapis.com
Si vous exécutez la commande depuis votre ordinateur local (et non depuis Cloud Shell), vous devez vous authentifier à l'aide de la commande gcloud :
gcloud auth application-default login
4. Créer votre première application Genkit
Genkit est un framework Open Source conçu pour aider les développeurs à créer, déployer et surveiller des applications optimisées par l'IA prêtes pour la production. Dans cette section, nous allons créer une application "Hello World" simple pour vous aider à vous familiariser avec le framework avant de nous plonger dans la logique de restauration de photos.
Terminologie Genkit
Avant de commencer à utiliser Genkit, il est important de comprendre quelques termes clés :
- Plug-ins : utilisés pour étendre les fonctionnalités de Genkit. C'est notamment par le biais de plug-ins que vous enregistrez des modèles d'IA pour alimenter votre application.
- Flux : principal composant architectural de Genkit. Un flux typique prend une entrée, la traite et renvoie une sortie. Il n'est pas nécessaire d'utiliser un modèle, mais la plupart du temps, vous utiliserez des modèles dans vos flux.
- Prompts : modèles d'interaction stockés au format dotprompt (enregistrés en tant que fichiers
*.prompt). Ils contiennent non seulement les instructions du modèle, mais aussi des configurations telles que le nom du modèle, les paramètres du modèle, les entrées et les sorties.
Se connecter à des modèles d'IA
Genkit utilise des plug-ins pour connecter votre code aux fournisseurs de modèles. Il existe des plug-ins pour tous les principaux fournisseurs de modèles, y compris Google, Anthropic et OpenAI. Vous pouvez également utiliser des plug-ins pour vous connecter à des modèles locaux (par exemple, à l'aide d'Ollama) ou pour étendre les fonctionnalités de Genkit (par exemple, pour vous connecter à des serveurs MCP).
Pour accéder aux modèles Google, vous devez utiliser le plug-in googlegenai. Il est compatible avec deux backends :
- Google AI : idéal pour le prototypage. Utilise une clé API.
- Vertex AI (Google Cloud) : recommandé pour la production. Utilise l'ID et l'emplacement du projet.
Dans cet atelier de programmation, nous allons utiliser l'authentification Vertex AI en référençant le projet que vous avez créé au début de l'atelier.
Créer un flux d'accueil
Avant d'approfondir le flux de restauration de photos Glow Up, créons un flux de base pour nous familiariser avec les concepts et nous assurer que notre configuration fonctionne correctement.
Un flux est une fonction Genkit spéciale qui encapsule votre logique d'IA pour fournir :
- Entrées et sorties de type sécurisé : définissez des schémas à l'aide de structures Go pour la validation statique et d'exécution.
- Compatibilité avec le streaming : diffusez des réponses partielles ou des données personnalisées
- Intégration de l'UI de développement : testez et déboguez les flux avec des traces visuelles.
- Déploiement facile : déployez vos modèles en tant que points de terminaison HTTP sur n'importe quelle plate-forme.
Ouvrez votre IDE et créez un fichier main.go dans le répertoire de votre projet. Si vous utilisez Cloud Shell, vous pouvez exécuter la commande suivante :
cloudshell edit main.go
Ajoutez ensuite le code suivant :
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()
}
Enregistrez le fichier, puis exécutez go mod tidy pour mettre à jour vos dépendances :
go mod tidy
Le code ci-dessus initialise Genkit avec le plug-in VertexAI, définit un flux nommé "greeter", puis attend indéfiniment sur <-ctx.Done(). Nous suspendons l'exécution pour que ce programme ne se termine pas immédiatement, car nous ne lui donnons aucune instruction pour exécuter le flux.
Cela signifie que si vous exécutez ce programme tel qu'il est actuellement, il ne fera pas grand-chose de lui-même. Nous devons appeler le flux d'une manière ou d'une autre. Dans une application de production réelle, nous encapsulerions ce flux dans un serveur Web ou une application CLI. Pendant le développement, nous pouvons utiliser la CLI genkit pour nous aider à développer et à optimiser le flux.
La CLI genkit a été développée pour nous aider à tester les modèles, les requêtes, les flux et d'autres composants de la pile Genkit. Il est également entièrement compatible avec les traces, ce qui est très pratique lorsque vous souhaitez comprendre le fonctionnement de l'application en arrière-plan. Pour lancer notre flux d'accueil à l'aide de la CLI genkit, exécutez la commande suivante :
genkit start -- go run main.go
Cela lancera les points de terminaison de l'API Telemetry et de l'UI de développement. L'écran qui s'affiche devrait ressembler à ce qui suit :
$ genkit start -- go run main.go Telemetry API running on http://localhost:4033 Project root: /home/daniela/glowup Genkit Developer UI: http://localhost:4000
Si vous ouvrez localhost:4000 dans votre navigateur pour lancer l'UI de développement. Un écran semblable à celui-ci s'affiche :

Prenez le temps d'explorer l'UI de développement. Vous pouvez déclencher le flux "greeter" une fois pour voir comment il fonctionne.
Utiliser des modèles de prompt
Bien que vous puissiez coder en dur vos prompts dans les appels de modèle, comme nous l'avons fait dans l'exemple précédent, une meilleure approche consiste à créer des modèles de prompts pour stocker tous les prompts de votre application de manière centralisée. Cela permet non seulement de les trouver plus facilement lors de la maintenance du code, mais aussi de tester les prompts indépendamment des flux.
Pour définir des modèles de prompt, Genkit utilise le format Open Source dotprompt, enregistré sous forme de fichiers *.prompt. Un fichier .prompt se compose de deux parties :
- Frontmatter : bloc YAML qui définit le modèle, les paramètres du modèle, ainsi que les schémas d'entrée et de sortie.
- Corps : corps de la requête, qui peut être modélisé à l'aide de la syntaxe "handlebars". Par exemple, si vous définissez une entrée nommée
variable-name, vous pouvez la référencer dans le corps en tant que{{variable-name}}.
La structure de répertoires du projet se présente comme suit :
glowup/
├── main.go
└── prompts/
└── greeter.prompt
Voyons cela en pratique. Commencez par créer le dossier dans lequel stocker vos requêtes :
mkdir -p prompts
Créez ensuite un fichier greeter.prompt :
cloudshell edit prompts/greeter.prompt
Insérez le contenu suivant :
greeter.prompt

Cette requête présente quelques-unes des fonctionnalités du langage de modèle. Tout d'abord, nous spécifions le modèle vertexai/gemini-2.5-flash dans le frontmatter. Pour spécifier un modèle, vous devez utiliser la nomenclature définie dans la documentation du plug-in concerné.
La section "config" nous permet de configurer les paramètres du modèle. Nous utilisons une température de 1,9 pour permettre au modèle d'être plus créatif. La température est comprise entre 0 (résultats plus cohérents) et 2 (résultats plus créatifs). Ce paramètre et d'autres sont généralement publiés dans la fiche du modèle. Par exemple, voici la fiche de modèle pour gemini-2.5-flash.
La section "input" nous permet de spécifier des arguments pour le prompt. Dans ce cas, nous définissons le nom en tant que chaîne. Le corps de la requête suit le frontmatter. Le premier bloc définit le prompt système et le second, le prompt utilisateur. Tous ces éléments combinés permettent d'utiliser des techniques de requêtes très puissantes. Vous pouvez consulter la documentation complète sur dotprompt ici.
À présent, adaptons le flux greeter pour utiliser le prompt que nous venons de créer :
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()
}
Essayez d'exécuter le flux à partir de la ligne de commande, avec et sans nom, pour voir la différence. Exécution sans nom :
genkit flow:run greeter
Exemple de résultat :
$ 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!"
Et avec un nom :
genkit flow:run greeter '"Daniela"'
Exemple de résultat :
$ 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!"
Vous pouvez voir que le modèle a fonctionné comme prévu. Nous sommes prêts à passer à l'étape suivante de ce projet.
5. Restaurer des images avec Nano Banana Pro
L'invite de restauration
Maintenant que vous connaissez les composants de Genkit, il est temps de créer notre prompt de restauration de photos.
Créez un fichier nommé glowup.prompt dans le répertoire "prompts" et collez-y le contenu suivant :
glowup.prompt

Le prompt de restauration suit le même modèle que notre prompt d'accueil, avec seulement quelques différences notables :
- Taille de l'image : la propriété
imageSizedeimageConfigest un paramètre spécifique au modèle Nano Banana Pro. Il nous permet de spécifier la taille de sortie (1K, 2K ou 4K). - Entrée multimédia : nous utilisons le modèle
{{ media }}pour injecter la photo dans la requête utilisateur. Cette technique nous permet d'envoyer des requêtes multimodales au modèle (texte + image).
Vous pouvez tester ce prompt dans l'UI de développement. N'hésitez pas à le modifier pour voir comment cela affecte le résultat.
Flux de restauration d'image
Maintenant que le prompt de restauration est prêt, créons notre application CLI. Remplacez le contenu de main.go par le code ci-dessous :
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
}
La structure du code est très semblable à celle du flux greeter, mais cette fois, elle est adaptée pour s'exécuter en tant qu'application CLI autonome. Au lieu de bloquer indéfiniment, il exécute le flux glowUp, décode la sortie et enregistre les données binaires obtenues sur le disque.
Nous devons décoder la sortie, car le modèle renvoie les données d'image au format suivant :
data:<mime type>;base64,<base64 encoded image>
Dans la fonction decode, vous pouvez voir que nous utilisons la manipulation de chaînes pour séparer le type MIME et les parties de l'image encodée. Nous utilisons ensuite les fonctions mime.ExtensionByType et base64.DecodeString pour extraire les informations dont nous avons besoin pour enregistrer le fichier.
Tester le flux de restauration
Il est enfin temps d'exécuter ce flux avec une vraie image. Si vous n'avez pas de vieilles photos à restaurer sous la main, vous pouvez essayer avec cette image du domaine public récupérée sur le site Web de la Bibliothèque du Congrès :

Voici le lien direct vers la photo à transmettre au flux : 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
Voici le résultat restauré et colorisé :

Opération réussie !
6. Déployer glowUp en tant que service Web
Si, au lieu d'une application de ligne de commande, vous souhaitez exposer vos flux dans un service Web, Genkit offre un moyen pratique de convertir les flux en points de terminaison à l'aide de l'adaptateur genkit.Handler. Le code ci-dessous enregistre le flux glowUp en tant que point de terminaison glowUp à l'aide de genkit.Handler.
Vous pouvez les exposer avec un serveur HTTP standard, comme vous le feriez normalement à l'aide du package http de la bibliothèque standard. Toutefois, Genkit fournit également un plug-in server qui facilite l'utilisation de certains codes standards de serveur, comme la gestion correcte des signaux d'arrêt.
Remplacez le contenu de main.go par le code ci-dessous pour créer votre serveur Web.
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)
}
}
Vous pouvez exécuter ce service localement ou dans le cloud. Pour l'exécuter localement, vous pouvez simplement exécuter le fichier directement, car le programme est maintenant terminé. Nous n'avons donc pas besoin de le lancer via la CLI Genkit. Exemple :
go run main.go
Comme il s'agit d'une opération bloquante, vous devez lancer un deuxième terminal pour la tester. Le moyen le plus rapide consiste à utiliser la commande curl :
curl -sS -X POST http://localhost:8080/glowUp \
-H "Content-Type: application/json" \
-d '{"data":{"url": $IMAGE_URL, "contentType":"image/jpeg"}}' \
> result.json
Comme il s'agit d'une réponse du serveur, nous devons décoder l'image en base64 :
cat result.json | jq -r '.result' | awk -F ',' '{print $2}' | base64 -d > restored.png
Déployer le service Web sur Cloud Run
C'est bien que ce serveur "fonctionne sur votre machine", mais dans un monde idéal, nous le déploierions ailleurs, de manière à ce qu'il soit accessible à tous nos utilisateurs. L'un des moyens les plus pratiques de déployer des services de ce type consiste à utiliser la fonctionnalité de déploiement à partir de la source de Cloud Run. Grâce à cette fonctionnalité, vous n'avez même pas besoin de créer le conteneur vous-même, tout est automatisé.
Pour déployer ce service sur Cloud Run à l'aide du déploiement à partir de la source, exécutez la commande suivante (remplacez l'ID du projet par le vôtre) :
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
Le déploiement peut prendre quelques minutes. Une fois que vous avez terminé, vous pouvez tester le point de terminaison en envoyant une autre requête via curl :
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
Là encore, nous devons décoder l'image base64 :
cat result.json | jq -r '.result' | awk -F ',' '{print $2}' | base64 -d > restored_cloudrun.png
Vous disposez maintenant d'un serveur Web de restauration de photos entièrement fonctionnel.
Facultatif : "Vibe coding" d'une application cliente
Écrire du code manuellement est amusant, mais peut aussi être difficile si vous n'avez jamais réalisé un certain type de projet auparavant. Heureusement, nous disposons aujourd'hui d'agents de codage qui peuvent nous aider à accélérer le processus.
Dans cette étape, au lieu d'écrire le code nous-mêmes, nous allons demander à Gemini CLI (ou à votre agent de codage préféré) de le faire pour nous. Utilisez le prompt suivant :
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
L'agent devra peut-être réorganiser un peu les fichiers, car nous ne pouvons pas avoir deux fonctions "main" dans le même module. Regardez-le travailler et guidez-le vers la bonne implémentation en lui fournissant le code du serveur ou des extraits si nécessaire.
Nettoyer après l'atelier
7. Conclusion
Félicitations ! Vous avez réussi à créer une application de restauration de photos haute fidélité à l'aide de Genkit et de Nano Banana Pro.
Dans cet atelier de programmation, vous avez appris à :
- Configurer votre environnement pour développer des applications Genkit Go
- Créer des prompts multimodaux avec
dotprompt - Créer des flux Genkit à l'aide de modèles de prompt
- Utiliser Nano Banana Pro pour traiter des images
- Empaqueter des flux Genkit en tant qu'applications de ligne de commande et services Web
- Déployer des applications Genkit sur Cloud Run
Une fois les tests terminés, n'oubliez pas de nettoyer l'environnement.
Étapes suivantes
Vous pouvez poursuivre votre apprentissage en explorant d'autres ateliers de programmation sur cette plate-forme ou en améliorant glowUp par vous-même.
Si vous avez besoin d'idées d'amélioration, vous pouvez essayer les suivantes :
- Activer la CLI glowUp pour restaurer les fichiers locaux
- Créer une interface pour le service Web GlowUp
- Détecter automatiquement le type MIME à partir des données
- Effectuer d'autres types de traitement d'image (de photo à dessin, de dessin à photo, de croquis à illustration finale, etc.)
- Créer ou améliorer le client (peut-être créer une application pour smartphone ?)
Les possibilités sont infinies ! Si l'idée de vous lancer seul vous intimide, vous pouvez toujours faire appel à un agent de codage comme Gemini CLI ou Antigravity. Et si vous souhaitez exploiter tout le potentiel de Genkit, les agents de codage associés au serveur MCP Genkit peuvent vous faciliter la vie.
Enfin, si vous souhaitez accéder au code complet de ce dépôt, vous le trouverez sur cette page.
À vous de jouer !