1. Introdução
Neste codelab, vamos criar o GlowUp, uma ferramenta de restauração de fotos. O GlowUp usa IA para restaurar fotos antigas, danificadas ou em preto e branco, criando imagens coloridas de alta qualidade em 4K. Use essa ferramenta para dar uma nova vida às fotos da família ou até mesmo adaptar para restaurar ilustrações, desenhos, pinturas ou outras formas de imagens danificadas.
Você vai usar o Genkit Go para implementar a lógica do aplicativo e o Gemini 3 Pro Image (também conhecido como Nano Banana Pro) como o modelo para processar as fotos.
Pré-requisitos
- Conhecimento básico da linguagem de programação Go.
- Conhecimento básico do console do Google Cloud
O que você vai aprender
- Como desenvolver aplicativos Genkit em Go
- Conceitos básicos do Genkit, como fluxos, plug-ins e comandos
- Como escrever comandos com modelos de Handlebars
- Como receber dados de imagem das respostas do modelo
O que é necessário
Este workshop pode ser feito inteiramente no Google Cloud Shell, que já vem com todas as dependências necessárias (CLI gcloud, editor de código, Go, CLI do Gemini) pré-instaladas.
Como alternativa, se você preferir trabalhar na sua própria máquina, vai precisar do seguinte:
- A cadeia de ferramentas Go (versão 1.24 ou mais recente)
- Node.js v20 ou mais recente (para a CLI
genkit) - Um terminal com a CLI
gcloudinstalada - Um ambiente de desenvolvimento integrado para editar seu código, como o VS Code ou similar
- Recomendado:um agente de programação como a CLI do Gemini ou o Antigravity
Principais tecnologias
Confira mais informações sobre as tecnologias que vamos usar:
- Nano Banana Pro do Gemini (Gemini 3 Pro para imagens): o modelo que impulsiona nosso processo de restauração
- Genkit Go: nosso kit de ferramentas para orquestrar chamadas de modelo
2. Configuração do ambiente
Escolha uma das seguintes opções: Configuração do ambiente no seu ritmo se quiser executar este codelab na sua própria máquina ou Iniciar o Cloud Shell se quiser executar este codelab totalmente na nuvem.
Configuração de ambiente autoguiada
- Faça login no Console do Google Cloud e crie um novo projeto ou reutilize um existente. Crie uma conta do Gmail ou do Google Workspace, se ainda não tiver uma.
- O Nome do projeto é o nome de exibição para os participantes do projeto. É uma string de caracteres não usada pelas APIs do Google e pode ser atualizada quando você quiser.
- O ID do projeto precisa ser exclusivo em todos os projetos do Google Cloud e não pode ser mudado após a definição. O console do Cloud gera automaticamente uma string exclusiva. Em geral, não importa o que seja. Na maioria dos codelabs, é necessário fazer referência ao ID do projeto, normalmente identificado como
PROJECT_ID. Se você não gostar do ID gerado, crie outro aleatório. Se preferir, teste o seu e confira se ele está disponível. Ele não pode ser mudado após essa etapa e permanece durante o projeto. - Para sua informação, há um terceiro valor, um Número do projeto, que algumas APIs usam. Saiba mais sobre esses três valores na documentação.
- Em seguida, ative o faturamento no console do Cloud para usar os recursos/APIs do Cloud. A execução deste codelab não vai ser muito cara, se tiver algum custo. Para encerrar os recursos e evitar cobranças além deste tutorial, exclua os recursos criados ou exclua o projeto. Novos usuários do Google Cloud estão qualificados para o programa de US$ 300 de avaliação sem custos.
Inicie o Cloud Shell
Embora o Google Cloud e o Spanner possam ser operados remotamente do seu laptop, neste codelab usaremos o Google Cloud Shell, um ambiente de linha de comando executado no Cloud.
No Console do Google Cloud, clique no ícone do Cloud Shell na barra de ferramentas superior à direita:
O provisionamento e a conexão com o ambiente levarão apenas alguns instantes para serem concluídos: Quando o processamento for concluído, você verá algo como:
Essa máquina virtual contém todas as ferramentas de desenvolvimento necessárias. Ela oferece um diretório principal persistente de 5 GB, além de ser executada no Google Cloud. Isso aprimora o desempenho e a autenticação da rede. Neste codelab, todo o trabalho pode ser feito com um navegador. Você não precisa instalar nada.
3. Configuração do projeto
Criar o projeto
Primeiro, precisamos criar um diretório para o projeto e inicializar o módulo Go. No terminal, execute os seguintes comandos:
mkdir -p glowup && cd glowup
go mod init glowup
Instalar a CLI do Genkit
Agora precisamos instalar a CLI do Genkit. Isso dá acesso a ferramentas de desenvolvedor local, incluindo a interface do desenvolvedor. Na janela do terminal, digite:
curl -sL cli.genkit.dev | bash
Configure as variáveis de ambiente
Verifique se as credenciais corretas do Google Cloud estão configuradas. Substitua your-project-id pelo ID do projeto. O local precisa ser global ao usar modelos de pré-lançamento do Gemini 3 Pro (o Nano Banana Pro é um deles).
export GOOGLE_CLOUD_PROJECT=$(gcloud config get project)
export GOOGLE_CLOUD_LOCATION=global
Execute o seguinte comando no modo shell para ativar a API Vertex AI:
gcloud services enable aiplatform.googleapis.com
Se você estiver executando na sua máquina local (não no Cloud Shell), será necessário fazer a autenticação com o comando gcloud:
gcloud auth application-default login
4. Criar seu primeiro aplicativo Genkit
O Genkit é um framework de código aberto projetado para ajudar os desenvolvedores a criar, implantar e monitorar aplicativos com tecnologia de IA prontos para produção. Nesta seção, vamos criar um aplicativo simples "Hello World" para ajudar você a se familiarizar com o framework antes de analisar a lógica de restauração de fotos.
Terminologia do Genkit
Antes de começar a trabalhar com o Genkit, é importante entender alguns termos principais:
- Plug-ins:usados para estender os recursos do Genkit. Entre outras coisas, é com os plug-ins que você registra modelos de IA para impulsionar seu aplicativo.
- Fluxos:o principal componente arquitetônico do Genkit. Um fluxo típico recebe uma entrada, a processa e retorna uma saída. Não é necessário usar um modelo, mas na maioria das vezes você vai usar modelos nos seus fluxos.
- Comandos:modelos de interação armazenados no formato dotprompt (salvos como arquivos
*.prompt). Eles contêm não apenas as instruções do modelo, mas também configurações como nome, parâmetros, entradas e saídas.
Como se conectar a modelos de IA
O Genkit usa plug-ins para conectar seu código a provedores de modelos. Há plug-ins para todos os principais provedores de modelos, incluindo Google, Anthropic e OpenAI. Também é possível usar plug-ins para se conectar a modelos locais (por exemplo, usando o Ollama) ou para estender os recursos do Genkit (por exemplo, conectar-se a servidores MCP).
Para acessar os modelos do Google, use o plug-in googlegenai. Ele é compatível com dois back-ends:
- Google AI: melhor para prototipagem. Usa uma chave de API.
- Vertex AI (Google Cloud): recomendada para produção. Usa o ID e o local do projeto.
Neste codelab, vamos usar a autenticação da Vertex AI referenciando o projeto que você criou no início do laboratório.
Como criar um fluxo de saudação
Antes de se aprofundar no fluxo de restauração de fotos do Glow Up, vamos criar um fluxo básico para se familiarizar com os conceitos e garantir que nossa configuração esteja funcionando corretamente.
Um fluxo é uma função especial do Genkit que encapsula sua lógica de IA para fornecer:
- Entradas e saídas com segurança de tipo:defina esquemas usando structs do Go para validação estática e de execução.
- Suporte a streaming:transmita respostas parciais ou dados personalizados
- Integração da interface do desenvolvedor:teste e depure fluxos com rastreamentos visuais
- Implantação fácil:implante como endpoints HTTP em qualquer plataforma.
Abra o ambiente de desenvolvimento integrado e crie um arquivo main.go no diretório do projeto. Se você estiver usando o Cloud Shell, use o seguinte comando:
cloudshell edit main.go
Em seguida, adicione o seguinte código:
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()
}
Salve o arquivo e execute go mod tidy para atualizar suas dependências:
go mod tidy
O código acima inicializa o Genkit com o plug-in VertexAI, define um fluxo chamado "greeter" e aguarda indefinidamente em <-ctx.Done(). Estamos mantendo a execução para que o programa não seja encerrado imediatamente, já que não estamos instruções para executar o fluxo.
Isso significa que, se você executar esse programa como ele está agora, ele não vai fazer muito por conta própria. Precisamos invocar o fluxo de alguma forma. Em um aplicativo de produção real, esse fluxo seria encapsulado em um servidor da Web ou app de CLI. No entanto, durante o desenvolvimento, podemos usar a CLI genkit para ajudar a desenvolver e otimizar o fluxo.
A CLI genkit foi desenvolvida para ajudar a testar modelos, comandos, fluxos e outros componentes da pilha do Genkit. Ele também tem suporte completo para rastreamentos, o que é muito conveniente quando você quer entender como o aplicativo está funcionando por dentro. Para iniciar o fluxo de saudação usando a CLI genkit, execute o seguinte comando:
genkit start -- go run main.go
Isso vai ativar os endpoints da API Telemetry e da interface do desenvolvedor. Você verá algo como:
$ genkit start -- go run main.go Telemetry API running on http://localhost:4033 Project root: /home/daniela/glowup Genkit Developer UI: http://localhost:4000
Se você abrir localhost:4000 no navegador para iniciar a interface de desenvolvimento. Você verá uma tela semelhante a esta:
Reserve um tempo para explorar a interface de desenvolvimento. Talvez acione o fluxo "greeter" uma vez só para ver como ele funciona.
Como usar modelos de comando
Embora seja possível codificar as solicitações nas chamadas de modelo, como fizemos no exemplo anterior, uma abordagem melhor seria criar modelos de solicitação para armazenar todas as solicitações do aplicativo de maneira centralizada. Isso não só facilita a localização deles ao fazer a manutenção do código, mas também permite testar os comandos de maneira independente dos fluxos.
Para definir modelos de comandos, o Genkit usa o formato de código aberto dotprompt, salvo como arquivos *.prompt. Um arquivo .prompt consiste em duas partes:
- Frontmatter:um bloco YAML que define o modelo, os parâmetros dele e os esquemas de entrada e saída.
- Corpo: o corpo do próprio comando, que pode ser modelado usando a sintaxe "handlebars". Por exemplo, se você definir uma entrada chamada
variable-name, poderá fazer referência a ela no corpo como{{variable-name}}.
A estrutura de diretórios do projeto será assim:
glowup/
├── main.go
└── prompts/
└── greeter.prompt
Vamos ver isso na prática. Primeiro, crie a pasta para armazenar seus comandos:
mkdir -p prompts
Em seguida, crie um arquivo greeter.prompt:
cloudshell edit prompts/greeter.prompt
e insira o seguinte conteúdo:
greeter.prompt
Esse comando mostra alguns dos recursos da linguagem de modelo. Primeiro, especificamos o modelo vertexai/gemini-2.5-flash no frontmatter. Para especificar um modelo, use a nomenclatura definida na documentação do plug-in correspondente.
A seção de configuração permite configurar os parâmetros do modelo. Estamos usando a temperatura 1,9 para permitir que o modelo seja mais criativo. A temperatura varia de 0 (saídas mais consistentes) a 2 (saídas mais criativas). Esse e outros parâmetros do modelo geralmente são publicados na planilha do modelo. Por exemplo, confira a ficha do modelo gemini-2.5-flash.
A seção de entrada permite especificar argumentos para o comando. Neste caso, estamos definindo o nome como uma string. Depois do frontmatter, temos o corpo do comando. O primeiro bloco define o comando do sistema, e o segundo é o comando do usuário. Todos esses elementos juntos permitem algumas técnicas de solicitação muito eficientes. Confira a documentação completa do dotprompt aqui.
Agora, vamos adaptar o fluxo greeter para usar o comando que acabamos de criar:
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()
}
Tente executar o fluxo na linha de comando, com e sem um nome, para ver a diferença. Execução sem um nome:
genkit flow:run greeter
Exemplo de saída:
$ 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!"
E com um nome:
genkit flow:run greeter '{"name":"Daniela"}'
Exemplo de saída:
$ genkit flow:run greeter '{"name":"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!"
Você pode ver que o modelo funcionou como esperado. Estamos prontos para levar esse projeto a outro nível!
5. Restaurar imagens com o Nano Banana Pro
O comando de restauração
Agora que você já conhece os blocos de construção do Genkit, é hora de criar nosso comando de restauração de fotos.
Crie um arquivo chamado glowup.prompt no diretório "prompts" e cole nele o seguinte conteúdo:
glowup.prompt
A solicitação de restauração segue o mesmo padrão da solicitação de "recepção", com apenas algumas diferenças notáveis:
- Tamanho da imagem:a propriedade
imageSizedeimageConfigé um parâmetro específico do modelo do Nano Banana Pro. Ele permite especificar o tamanho da saída como 1K, 2K ou 4K. - Entrada de mídia:estamos usando o modelo
{{ media }}para inserir a foto no comando do usuário. Essa técnica permite enviar comandos multimodais ao modelo (texto + imagem).
Você pode testar esse comando na interface para desenvolvedores. Faça ajustes para ver como isso afeta a saída.
O fluxo de restauração de imagens
Com o comando de restauração pronto, vamos criar nosso aplicativo de CLI. Substitua o conteúdo de main.go pelo código abaixo:
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
}
O código tem uma estrutura muito semelhante ao fluxo greeter, mas desta vez ele é adaptado para ser executado como um aplicativo CLI independente. Em vez de bloquear para sempre, ele vai executar o fluxo glowUp, decodificar a saída e salvar os dados binários resultantes no disco.
Precisamos decodificar a saída porque o modelo retorna os dados da imagem no seguinte formato:
data:<mime type>;base64,<base64 encoded image>
Na função decode, usamos a manipulação de strings para dividir o tipo MIME e as partes da imagem codificada. Em seguida, usamos as funções mime.ExtensionByType e base64.DecodeString para extrair as informações necessárias para salvar o arquivo.
Como testar o fluxo de restauração
Agora é hora de executar esse fluxo com uma imagem real. Se você não tiver fotos antigas que precisam de restauração, tente com esta imagem de domínio público recuperada do site da Biblioteca do Congresso:
Este é o link direto da fotografia para passar para o fluxo: 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
Esta é a saída restaurada e colorida:
Pronto.
6. Como implantar o glowUp como um serviço da Web
Se, em vez de um aplicativo de linha de comando, você quiser expor seus fluxos em um serviço da Web, o Genkit oferece uma maneira conveniente de converter fluxos em endpoints usando o adaptador genkit.Handler. O código abaixo registra o fluxo glowUp como um endpoint glowUp usando genkit.Handler.
É possível expor esses endpoints com um servidor HTTP normal, como você faria normalmente usando o pacote http da biblioteca padrão. No entanto, o Genkit também oferece um plug-in server que ajuda com alguns dos modelos de servidor comuns, como o processamento adequado de sinais de desligamento.
Substitua o conteúdo de main.go pelo código abaixo para criar seu servidor da 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)
}
}
É possível executar esse serviço localmente ou na nuvem. Para executar localmente, basta executar o arquivo diretamente, já que o programa está completo. Assim, não é necessário iniciá-lo pela CLI do Genkit. Exemplo:
go run main.go
Como essa é uma operação de bloqueio, é necessário iniciar um segundo terminal para testá-la. A maneira mais rápida é usar o comando curl:
curl -sS -X POST http://localhost:8080/glowUp \
-H "Content-Type: application/json" \
-d '{"data":{"url": $IMAGE_URL, "contentType":"image/jpeg"}}' \
> result.json
Como essa é uma resposta do servidor, precisamos decodificar a imagem em base64:
cat result.json | jq -r '.result' | awk -F ',' '{print $2}' | base64 -d > restored.png
Implantar o serviço da Web no Cloud Run
Não há problema em o servidor "funcionar na minha máquina", mas, no mundo ideal, ele seria implantado em outro lugar acessível a todos os usuários. Uma das maneiras mais convenientes de implantar serviços como esse é usar o recurso de implantação do código-fonte do Cloud Run. Com esse recurso, você nem precisa criar o contêiner por conta própria, tudo é automatizado.
Para implantar esse serviço no Cloud Run usando a implantação da origem, execute o seguinte comando (substitua o ID do projeto pelo seu):
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
A implantação pode levar alguns minutos para ser concluída. Quando terminar, teste o endpoint enviando outra solicitação 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
Novamente, precisamos decodificar a imagem em base64:
cat result.json | jq -r '.result' | awk -F ',' '{print $2}' | base64 -d > restored_cloudrun.png
Agora temos um servidor da Web de restauração de fotos totalmente funcional.
Opcional: "vibe coding" de um aplicativo cliente
Escrever código manual é divertido, mas também pode ser desafiador se você nunca fez um determinado tipo de projeto antes. Felizmente, hoje temos agentes de programação que podem ajudar a acelerar o processo.
Nesta etapa, em vez de escrever o código, vamos pedir ao Gemini CLI (ou ao seu agente de programação favorito) para fazer o trabalho. Use o seguinte comando:
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
O agente pode precisar reorganizar um pouco os arquivos, já que não podemos ter duas funções "main" no mesmo módulo. Observe como ele funciona e direcione para a implementação correta, fornecendo o código do servidor ou snippets, se necessário.
Limpeza após o laboratório
7. Conclusão
Parabéns! Você criou um app de restauração de fotos de alta fidelidade usando o Genkit e o Nano Banana Pro.
Neste codelab, você aprendeu a:
- Configure seu ambiente para desenvolver aplicativos Genkit Go
- Criar comandos multimodais com o
dotprompt - Criar flows do Genkit usando modelos de comandos
- Usar o Nano Banana Pro para processar imagens
- Empacotar fluxos do Genkit como aplicativos de linha de comando e serviços da Web
- Implantar aplicativos do Genkit no Cloud Run
Depois de concluir os testes, limpe o ambiente.
Próximas etapas
Você pode continuar sua jornada de aprendizado explorando outros codelabs nesta plataforma ou fazendo melhorias no glowUp por conta própria.
Se você precisar de ideias para melhorias, tente:
- Ativar a CLI glowUp para restaurar arquivos locais
- Criar um front-end para o serviço da Web GlowUp
- Detectar automaticamente o tipo MIME dos dados
- Realizar outros tipos de processamento de imagens (de foto para desenho, de desenho para foto, de esboço para arte final etc.)
- Criar ou melhorar o cliente (talvez criar um app para smartphone?)
As possibilidades são infinitas. Se a ideia de fazer tudo sozinho parecer um pouco assustadora, você sempre pode usar a ajuda de um agente de programação, como a CLI do Gemini ou o Antigravity. E se quiser fazer mais com o Genkit, os agentes de programação pareados com o servidor MCP do Genkit podem facilitar muito sua vida.
Por fim, se quiser acessar o código completo deste repositório, clique aqui.
Divirta-se com os códigos!