Membangun aplikasi pemulihan foto menggunakan Genkit Go dan Nano Banana Pro

1. Pengantar

Dalam codelab ini, kita akan membuat GlowUp, alat pemulihan foto. GlowUp menggunakan AI untuk memulihkan foto lama, rusak, atau hitam putih, sehingga menghasilkan gambar berwarna 4K berkualitas tinggi. Anda dapat menggunakan alat ini untuk menghidupkan kembali foto keluarga Anda, atau bahkan menggunakannya untuk memulihkan ilustrasi, gambar, lukisan, atau bentuk gambar lainnya yang rusak.

Anda akan menggunakan Genkit Go untuk menerapkan logika aplikasi dan Gemini 3 Pro Image (juga dikenal sebagai Nano Banana Pro) sebagai model untuk memproses foto.

Prasyarat

Pengetahuan dasar tentang bahasa pemrograman Go
Pengetahuan dasar tentang konsol Google Cloud

Yang akan Anda pelajari

Cara mengembangkan aplikasi Genkit di Go
Konsep dasar Genkit seperti flow, plugin, dan perintah
Cara menulis perintah dengan template handlebar
Cara mendapatkan data gambar dari respons model

Yang Anda butuhkan

Workshop ini dapat dilakukan sepenuhnya di dalam Google Cloud Shell, yang sudah diinstal sebelumnya dengan semua dependensi yang diperlukan (gcloud CLI, editor kode, Go, Gemini CLI).

Atau, jika Anda lebih suka bekerja di komputer Anda sendiri, Anda akan memerlukan hal berikut:

Toolchain Go (versi 1.24 atau yang lebih tinggi)
Node.js v20 atau yang lebih baru (untuk genkit CLI)
Terminal dengan gcloud CLI yang terinstal
IDE untuk mengedit kode Anda seperti VS Code atau yang serupa
Direkomendasikan: agen coding seperti Gemini CLI atau Antigravity

Teknologi Utama

Di sini Anda dapat menemukan informasi selengkapnya tentang teknologi yang akan kami gunakan:

Gemini Nano Banana Pro (Gemini 3 Pro Image): model yang mendukung proses pemulihan kami
Genkit Go: toolkit kami untuk mengatur panggilan model

2. Penyiapan Lingkungan

Pilih salah satu opsi berikut: Penyiapan lingkungan mandiri jika Anda ingin menjalankan codelab ini di komputer Anda sendiri, atau; Mulai Cloud Shell jika Anda ingin menjalankan codelab ini sepenuhnya di cloud.

Penyiapan lingkungan mandiri

Login ke Google Cloud Console dan buat project baru atau gunakan kembali project yang sudah ada. Jika belum memiliki akun Gmail atau Google Workspace, Anda harus membuatnya.

Project name adalah nama tampilan untuk peserta project ini. String ini adalah string karakter yang tidak digunakan oleh Google API. Anda dapat memperbaruinya kapan saja.
Project ID bersifat unik di semua project Google Cloud dan tidak dapat diubah (tidak dapat diubah setelah ditetapkan). Cloud Console otomatis membuat string unik; biasanya Anda tidak mementingkan kata-katanya. Di sebagian besar codelab, Anda harus merujuk Project ID-nya (umumnya diidentifikasi sebagai PROJECT_ID). Jika tidak suka dengan ID yang dibuat, Anda dapat membuat ID acak lainnya. Atau, Anda dapat mencobanya sendiri, dan lihat apakah ID tersebut tersedia. ID tidak dapat diubah setelah langkah ini dan tersedia selama durasi project.
Sebagai informasi, ada nilai ketiga, Project Number, yang digunakan oleh beberapa API. Pelajari lebih lanjut ketiga nilai ini di dokumentasi.

Selanjutnya, Anda harus mengaktifkan penagihan di Konsol Cloud untuk menggunakan resource/API Cloud. Menjalankan operasi dalam codelab ini tidak akan memakan banyak biaya, bahkan mungkin tidak sama sekali. Guna mematikan resource agar tidak menimbulkan penagihan di luar tutorial ini, Anda dapat menghapus resource yang dibuat atau menghapus project-nya. Pengguna baru Google Cloud memenuhi syarat untuk mengikuti program Uji Coba Gratis senilai $300 USD.

Mulai Cloud Shell

Meskipun Google Cloud dapat dioperasikan dari jarak jauh menggunakan laptop Anda, dalam codelab ini, Anda akan menggunakan Google Cloud Shell, lingkungan command line yang berjalan di Cloud.

Dari Google Cloud Console, klik ikon Cloud Shell di toolbar kanan atas:

Mengaktifkan Cloud Shell

Hanya perlu waktu beberapa saat untuk penyediaan dan terhubung ke lingkungan. Jika sudah selesai, Anda akan melihat tampilan seperti ini:

Screenshot terminal Google Cloud Shell yang menunjukkan bahwa lingkungan telah terhubung

Mesin virtual ini berisi semua alat pengembangan yang Anda perlukan. Layanan ini menawarkan direktori beranda tetap sebesar 5 GB dan beroperasi di Google Cloud, sehingga sangat meningkatkan performa dan autentikasi jaringan. Semua pekerjaan Anda dalam codelab ini dapat dilakukan di browser. Anda tidak perlu menginstal apa pun.

3. Penyiapan Project

Membuat project

Pertama, kita perlu membuat direktori baru untuk project Anda dan melakukan inisialisasi modul Go. Di terminal, jalankan perintah berikut:

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

Instal Genkit CLI

Sekarang kita perlu menginstal Genkit CLI. Dengan begitu, Anda dapat mengakses alat developer lokal, termasuk UI Developer. Di jendela terminal, ketik:

curl -sL cli.genkit.dev | bash

Mengonfigurasi variabel lingkungan

Pastikan Anda telah menyiapkan kredensial Google Cloud yang benar. Ganti your-project-id dengan project ID Anda yang sebenarnya. Lokasi harus global saat menggunakan model Pratinjau Gemini 3 Pro (Nano Banana Pro adalah salah satunya).

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

Jalankan perintah berikut dalam mode shell untuk mengaktifkan Vertex AI API:

gcloud services enable aiplatform.googleapis.com

Jika Anda menjalankan dari komputer lokal (bukan di Cloud Shell), Anda harus melakukan autentikasi dengan perintah gcloud:

gcloud auth application-default login

4. Membuat aplikasi Genkit pertama Anda

Genkit adalah framework open source yang dirancang untuk membantu developer membangun, men-deploy, dan memantau aplikasi berteknologi AI yang siap produksi. Di bagian ini, kita akan membuat aplikasi "Hello World" sederhana untuk membantu Anda memahami framework sebelum mempelajari logika pemulihan foto.

Terminologi Genkit

Sebelum memulai pekerjaan dengan Genkit, Anda harus memahami beberapa istilah utama:

Plugin: digunakan untuk memperluas kemampuan Genkit. Antara lain, melalui plugin inilah Anda mendaftarkan model AI untuk mendukung aplikasi Anda.
Alur: komponen arsitektur utama Genkit. Alur umum akan mengambil input, memprosesnya, dan menampilkan output. Tidak harus menggunakan model, tetapi sebagian besar waktu Anda akan menggunakan model di dalam alur.
Perintah: template interaksi yang disimpan dalam format dotprompt (disimpan sebagai file *.prompt). File ini tidak hanya berisi petunjuk model, tetapi juga konfigurasi seperti nama model, parameter model, input, dan output.

Menghubungkan dengan model AI

Genkit menggunakan plugin untuk menghubungkan kode Anda ke penyedia model. Ada plugin untuk semua penyedia model utama, termasuk Google, Anthropic, dan OpenAI. Anda juga dapat menggunakan plugin untuk terhubung ke model lokal (misalnya, menggunakan Ollama) atau untuk memperluas kemampuan Genkit (misalnya, terhubung ke server MCP).

Untuk mengakses model Google, Anda harus menggunakan plugin googlegenai. API ini mendukung dua backend:

AI Google: Terbaik untuk pembuatan prototipe. Menggunakan Kunci API.
Vertex AI (Google Cloud): Direkomendasikan untuk produksi. Menggunakan ID project dan lokasi.

Dalam codelab ini, kita akan menggunakan autentikasi Vertex AI dengan mereferensikan project yang Anda buat di awal lab.

Membuat alur sapaan

Sebelum mempelajari lebih dalam alur pemulihan foto Glow Up, mari kita buat alur dasar untuk memahami konsepnya dan memastikan penyiapan kita berfungsi dengan baik.

Flow adalah fungsi Genkit khusus yang membungkus logika AI Anda untuk menyediakan:

Input dan output yang aman untuk jenis: Tentukan skema menggunakan struct Go untuk validasi statis dan runtime
Dukungan streaming: Streaming respons parsial atau data kustom
Integrasi UI developer: Menguji dan men-debug alur dengan rekaman visual
Deployment yang mudah: Deploy sebagai endpoint HTTP ke platform apa pun

Buka IDE Anda dan buat file main.go di direktori project Anda. Jika menggunakan cloudshell, Anda dapat menggunakan perintah berikut:

cloudshell edit main.go

Kemudian, tambahkan kode berikut:

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()
}

Simpan file, lalu jalankan go mod tidy untuk memperbarui dependensi Anda:

go mod tidy

Kode di atas menginisialisasi Genkit dengan plugin VertexAI, menentukan alur bernama "greeter", lalu menunggu selamanya di <-ctx.Done(). Kita menahan eksekusi sehingga program ini tidak segera dihentikan, karena kita tidak memberikan petunjuk apa pun untuk benar-benar mengeksekusi alur.

Artinya, jika Anda menjalankan program ini seperti sekarang, program ini tidak akan melakukan banyak hal dengan sendirinya - kita perlu memanggil alurnya. Meskipun dalam aplikasi produksi yang sebenarnya, kita akan membungkus alur ini dalam aplikasi CLI atau server web, selama waktu pengembangan, kita dapat menggunakan CLI genkit untuk membantu kita mengembangkan dan mengoptimalkan alur.

CLI genkit dikembangkan untuk membantu kami menguji model, perintah, alur, dan komponen lain dari stack Genkit. Fitur ini juga memiliki dukungan penuh untuk rekaman aktivitas yang sangat berguna saat Anda ingin memahami cara kerja aplikasi di balik layar. Untuk meluncurkan alur sapaan menggunakan genkit CLI, jalankan perintah berikut:

genkit start -- go run main.go

Tindakan ini akan meluncurkan endpoint Telemetry API dan UI Developer. Anda akan melihat yang seperti ini:

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

Jika Anda membuka localhost:4000 di browser untuk meluncurkan UI Dev. Anda akan melihat layar seperti ini:

Luangkan waktu untuk menjelajahi UI Dev. Mungkin picu alur "penyapa" satu kali hanya untuk melihat cara kerjanya.

Menggunakan template perintah

Meskipun Anda dapat meng-hardcode perintah dalam panggilan model seperti yang kita lakukan pada contoh sebelumnya, pendekatan yang lebih baik adalah membuat template perintah untuk menyimpan semua perintah aplikasi kita secara terpusat. Hal ini tidak hanya memudahkan Anda menemukannya saat melakukan pemeliharaan kode, tetapi juga memungkinkan Anda bereksperimen dengan perintah secara terpisah dari alur.

Untuk menentukan template prompt, Genkit menggunakan format dotprompt open source, yang disimpan sebagai file *.prompt. File .prompt terdiri dari dua bagian:

Frontmatter: Blok YAML yang menentukan model, parameter model, dan skema input serta output
Isi: Isi perintah itu sendiri, yang dapat dibuat template menggunakan sintaksis "handlebars". Misalnya, jika Anda menentukan input bernama variable-name, Anda dapat mereferensikannya di isi sebagai {{variable-name}}.

Struktur direktori project akan terlihat seperti ini:

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

Mari kita lihat penerapannya. Pertama, buat folder untuk menyimpan perintah Anda:

mkdir -p prompts

Kemudian, buat file greeter.prompt:

cloudshell edit prompts/greeter.prompt

Kemudian, masukkan konten berikut:

greeter.prompt

Perintah ini menampilkan beberapa fitur bahasa template. Pertama, kita menentukan model vertexai/gemini-2.5-flash di frontmatter. Untuk menentukan model, Anda harus menggunakan nomenklatur yang ditentukan dalam dokumentasi plugin masing-masing.

Bagian config memungkinkan kita mengonfigurasi parameter model. Kami menggunakan suhu 1,9 agar model dapat lebih kreatif. Temperatur berkisar dari 0 (output yang lebih konsisten) hingga 2 (output yang lebih kreatif). Parameter model ini dan parameter model lainnya biasanya dipublikasikan di lembar model model. Misalnya, berikut adalah lembar model untuk gemini-2.5-flash.

Bagian input memungkinkan kita menentukan argumen untuk perintah. Dalam hal ini, kita menentukan nama sebagai string. Setelah frontmatter, kita memiliki isi perintah. Blok pertama di sini menentukan perintah sistem dan blok kedua adalah perintah pengguna. Semua elemen ini bersama-sama memungkinkan teknik perintah yang sangat efektif. Anda dapat memeriksa dokumentasi lengkap untuk dotprompt di sini.

Sekarang, mari kita sesuaikan alur greeter untuk menggunakan perintah yang baru saja kita buat:

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()
}

Coba jalankan alur dari command line, dengan dan tanpa nama untuk melihat perbedaannya. Menjalankan tanpa nama:

genkit flow:run greeter

Contoh output:

$ 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!"

Dan dengan nama:

genkit flow:run greeter '{"name":"Daniela"}'

Contoh output:

$ 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!"

Anda dapat melihat bahwa template berfungsi seperti yang diharapkan. Kami siap membawa proyek ini ke level berikutnya.

5. Memulihkan Gambar dengan Nano Banana Pro

Perintah Pemulihan

Setelah Anda memahami elemen dasar Genkit, sekarang saatnya membuat perintah pemulihan foto.

Buat file bernama glowup.prompt di direktori perintah, lalu tempelkan konten berikut ke dalamnya:

glowup.prompt

Perintah pemulihan mengikuti pola yang sama dengan perintah "sapaan" kami, dengan hanya beberapa perbedaan penting:

Ukuran gambar: properti imageSize dari imageConfig adalah parameter khusus model Nano Banana Pro. Hal ini memungkinkan kita menentukan ukuran output sebagai 1K, 2K, atau 4K.
Input media: kita menggunakan template {{ media }} untuk menyisipkan foto dalam perintah pengguna. Teknik ini memungkinkan kita mengirimkan perintah multi-modal ke model (teks + gambar).

Anda dapat menguji perintah ini di UI Dev. Jangan ragu untuk mengubahnya guna melihat pengaruhnya terhadap output.

Alur pemulihan gambar

Setelah perintah pemulihan siap, sekarang mari kita buat aplikasi CLI. Ganti konten main.go dengan kode di bawah:

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
}

Struktur kodenya sangat mirip dengan alur greeter, tetapi kali ini diadaptasi untuk dijalankan sebagai aplikasi CLI mandiri. Daripada memblokir selamanya, fungsi ini akan menjalankan alur glowUp, mendekode output, dan menyimpan data biner yang dihasilkan ke disk.

Kita perlu mendekode output karena model menampilkan data gambar dalam format berikut:

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

Anda dapat melihat di fungsi decode bahwa kita menggunakan manipulasi string untuk memisahkan jenis MIME dan bagian gambar yang dienkode. Kemudian, kita menggunakan fungsi mime.ExtensionByType dan base64.DecodeString untuk mengekstrak informasi yang diperlukan untuk menyimpan file.

Menguji alur pemulihan

Sekarang saatnya menjalankan alur ini dengan gambar asli. Jika tidak memiliki foto lama yang perlu direstorasi, Anda dapat mencoba dengan gambar domain publik ini yang diambil dari situs Library of Congress:

Berikut link langsung ke foto untuk meneruskannya ke alur: 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

Berikut adalah output yang dipulihkan dan diwarnai:

Berhasil!

6. Men-deploy glowUp sebagai layanan web

Jika Anda ingin mengekspos alur dalam layanan web, bukan aplikasi command line, Genkit menyediakan cara mudah untuk mengonversi alur menjadi endpoint menggunakan adaptor genkit.Handler. Kode di bawah mendaftarkan alur glowUp sebagai endpoint glowUp menggunakan genkit.Handler.

Anda dapat mengeksposnya dengan server HTTP reguler seperti biasa menggunakan paket http dari library standar, tetapi Genkit juga menyediakan plugin server yang membantu beberapa boilerplate server umum, seperti menangani sinyal penonaktifan dengan baik.

Ganti konten main.go dengan kode di bawah untuk membuat server web Anda.

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)
        }
}

Anda dapat menjalankan layanan ini secara lokal atau di cloud. Untuk menjalankan secara lokal, Anda cukup menjalankan file secara langsung karena programnya sudah selesai, jadi kita tidak perlu meluncurkannya melalui CLI genkit. Contoh:

go run main.go

Karena ini adalah operasi pemblokiran, Anda perlu meluncurkan terminal kedua untuk mengujinya. Cara tercepat adalah dengan menggunakan perintah curl:

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

Karena ini adalah respons server, kita perlu mendekode gambar base64:

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

Men-deploy layanan web ke Cloud Run

Tidak masalah jika server ini "berfungsi di mesin saya", tetapi dalam kondisi ideal, kita akan men-deploy-nya di tempat lain yang dapat diakses oleh semua pengguna kita. Salah satu cara paling mudah untuk men-deploy layanan seperti ini adalah dengan menggunakan fitur deploy dari sumber Cloud Run. Dengan fitur ini, Anda bahkan tidak perlu membuat sendiri container, semuanya otomatis.

Untuk men-deploy layanan ini ke Cloud Run menggunakan deployment dari sumber, jalankan perintah berikut (ganti project ID dengan project ID Anda sendiri):

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

Proses deployment dapat memerlukan waktu beberapa menit. Setelah selesai, Anda dapat menguji endpoint dengan mengirim permintaan lain melalui 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

Sekali lagi, kita perlu mendekode gambar base64:

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

Sekarang kita memiliki server web pemulihan foto yang berfungsi penuh.

Opsional: "Vibe coding" aplikasi klien

Menulis kode secara manual memang menyenangkan, tetapi juga bisa menantang jika Anda belum pernah mengerjakan jenis project tertentu sebelumnya. Untungnya, saat ini kita memiliki agen coding yang dapat membantu mempercepat prosesnya.

Pada langkah ini, alih-alih menulis kode sendiri, kita akan meminta Gemini CLI (atau agen coding favorit Anda) untuk melakukan pekerjaan tersebut. Gunakan perintah berikut:

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

Agen mungkin perlu mengatur ulang file sedikit karena kita tidak dapat memiliki dua fungsi "main" dalam modul yang sama. Lihat cara kerjanya dan arahkan ke penerapan yang tepat dengan memberikan kode atau cuplikan server jika perlu.

Membersihkan setelah lab

7. Kesimpulan

Selamat! Anda telah berhasil membuat aplikasi pemulihan foto dengan fidelitas tinggi menggunakan Genkit dan Nano Banana Pro,

Dalam codelab ini, Anda telah mempelajari cara:

Mengonfigurasi lingkungan Anda untuk mengembangkan aplikasi Genkit Go
Membuat perintah multimodal dengan dotprompt
Membuat alur Genkit menggunakan template perintah
Menggunakan Nano Banana Pro untuk memproses gambar
Mengemas flow Genkit sebagai aplikasi command line dan layanan web
Men-deploy aplikasi Genkit ke Cloud Run

Setelah selesai menguji, jangan lupa untuk membersihkan lingkungan.

Langkah berikutnya

Anda dapat melanjutkan perjalanan belajar dengan menjelajahi codelab lain di platform ini, atau melakukan peningkatan pada glowUp sendiri.

Jika Anda memerlukan beberapa ide untuk peningkatan, Anda dapat mencoba:

Mengaktifkan glowUp CLI untuk memulihkan file lokal
Membuat frontend untuk layanan web GlowUp
Mendeteksi jenis MIME dari data secara otomatis
Lakukan jenis pemrosesan gambar lainnya (dari foto ke gambar, dari gambar ke foto, sketsa ke gambar akhir, dll.
Membuat atau meningkatkan kualitas klien (mungkin membuat aplikasi smartphone?)

Kemungkinannya tak terbatas. Jika ide untuk melakukannya sendiri terasa sedikit menakutkan, Anda selalu dapat menggunakan bantuan agen coding seperti Gemini CLI atau Antigravity. Jika Anda ingin melakukan lebih banyak hal dengan Genkit, agen coding yang dipasangkan dengan Server MCP Genkit dapat mempermudah pekerjaan Anda.

Terakhir, jika ingin mengakses kode lengkap untuk repo ini, Anda dapat menemukannya di sini.

Selamat membuat kode!