Genkit Go ve Nano Banana Pro kullanarak fotoğraf restorasyon uygulaması oluşturma

1. Giriş

Bu codelab'de, fotoğraf restorasyon aracı olan GlowUp'ı oluşturacağız. GlowUp, yapay zekayı kullanarak eski, hasarlı veya siyah-beyaz fotoğrafları onararak yüksek kaliteli 4K renkli görüntüler oluşturur. Bu aracı kullanarak aile fotoğraflarınıza yeni bir hayat verebilir, hatta hasarlı çizimleri, resimleri, tabloları veya diğer görsel biçimlerini onarmak için uyarlayabilirsiniz.

Uygulama mantığını uygulamak için Genkit Go'yu, fotoğrafları işlemek için ise Gemini 3 Pro Image'ı (Nano Banana Pro olarak da bilinir) kullanacaksınız.

Ön koşullar

  • Go programlama dili hakkında temel düzeyde bilgi
  • Google Cloud Console hakkında temel bilgi

Neler öğreneceksiniz?

  • Go'da Genkit uygulamaları geliştirme
  • Akışlar, eklentiler ve istemler gibi temel Genkit kavramları
  • Handlebars şablonlarıyla istem yazma
  • Model yanıtlarından görüntü verileri alma

İhtiyacınız olanlar

Bu atölye çalışması, gerekli tüm bağımlılıkların (gcloud CLI, kod düzenleyici, Go, Gemini CLI) önceden yüklü olduğu Google Cloud Shell'de tamamen yapılabilir.

Alternatif olarak, kendi makinenizde çalışmayı tercih ederseniz aşağıdakilere ihtiyacınız olacaktır:

  • Go araç zinciri (1.24 veya sonraki sürümler)
  • Node.js v20 veya sonraki sürümler (genkit CLI için)
  • gcloud KSA'nın yüklü olduğu bir terminal
  • Kodunuzu düzenlemek için VS Code veya benzeri bir IDE
  • Önerilen: Gemini CLI veya Antigravity gibi bir kodlama temsilcisi

Temel Teknolojiler

Kullanacağımız teknolojiler hakkında daha fazla bilgiyi burada bulabilirsiniz:

  • Gemini Nano Banana Pro (Gemini 3 Pro Image): Restorasyon sürecimizi destekleyen model
  • Genkit Go: Model çağrılarını yönetmek için araç setimiz

2. Ortam Kurulumu

Bu laboratuvarı kendi makinenizden veya tamamen buluttan çalıştırabilirsiniz. Kodu yerel olarak çalıştırmaya karar verseniz bile sunucu tarafı bileşenlerinin buluta dağıtılması için bir Google Cloud projesine ihtiyacınız olur. Oluşturmak için sonraki bölümdeki adımları uygulayın.

Yönlendirmesiz ortam kurulumu

  1. Google Cloud Console'da oturum açın ve yeni bir proje oluşturun veya mevcut bir projeyi yeniden kullanın. Gmail veya Google Workspace hesabınız yoksa hesap oluşturmanız gerekir.

295004821bab6a87.png37d264871000675d.png96d86d3d5655cdbe.png

  • Proje adı, bu projenin katılımcıları için görünen addır. Google API'leri tarafından kullanılmayan bir karakter dizesidir. Bu bilgiyi dilediğiniz zaman güncelleyebilirsiniz.
  • Proje kimliği, tüm Google Cloud projeleri genelinde benzersizdir ve sabittir (ayarlandıktan sonra değiştirilemez). Cloud Console, benzersiz bir dizeyi otomatik olarak oluşturur. Genellikle bu dizeyi önemsemeniz gerekmez. Çoğu codelab'de proje kimliğinize (genellikle PROJECT_ID olarak tanımlanır) başvurmanız gerekir. Oluşturulan kimliği beğenmezseniz başka bir rastgele kimlik oluşturabilirsiniz. Alternatif olarak, kendi adınızı deneyebilir ve kullanılabilir olup olmadığını görebilirsiniz. Bu adımdan sonra değiştirilemez ve proje süresince geçerli olur.
  • Bazı API'lerin kullandığı üçüncü bir değer olan proje numarası da vardır. Bu üç değer hakkında daha fazla bilgiyi belgelerde bulabilirsiniz.
  1. Ardından, Cloud kaynaklarını/API'lerini kullanmak için Cloud Console'da faturalandırmayı etkinleştirmeniz gerekir. Bu codelab'i tamamlamak için çok az bir ücret ödemeniz gerekir veya hiç ödeme yapmanız gerekmez. Bu eğitimden sonra faturalandırma yapılmaması için oluşturduğunuz kaynakları veya projeyi silebilirsiniz. Yeni Google Cloud kullanıcıları 300 ABD doları değerinde ücretsiz deneme programından yararlanabilir.

Cloud Shell'i başlatma

Google Cloud'u dizüstü bilgisayarınızdan uzaktan çalıştırabilirsiniz ancak bu codelab'de, Cloud'da çalışan bir komut satırı ortamı olan Google Cloud Shell'i kullanacaksınız.

Google Cloud Console'da, sağ üstteki araç çubuğunda Cloud Shell simgesini tıklayın:

Cloud Shell'i etkinleştirme

Birkaç saniye içinde ortamın temel hazırlığı yapılır ve bağlantı kurulur. İşlem tamamlandığında şuna benzer bir sonuç görürsünüz:

Ortamın bağlandığını gösteren Google Cloud Shell terminalinin ekran görüntüsü

Bu sanal makine, ihtiyaç duyacağınız tüm geliştirme araçlarıyla yüklüdür. 5 GB boyutunda kalıcı bir ana dizin bulunur ve Google Cloud'da çalışır. Bu sayede ağ performansı ve kimlik doğrulama önemli ölçüde güçlenir. Bu codelab'deki tüm çalışmalarınızı tarayıcıda yapabilirsiniz. Herhangi bir şey yüklemeniz gerekmez.

3. Proje Ayarları

Projeyi oluşturma

Öncelikle projeniz için yeni bir dizin oluşturup Go modülünü başlatmamız gerekiyor. Terminalinizde aşağıdaki komutları çalıştırın:

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

Genkit CLI'yı yükleme

Şimdi Genkit KSA'yı yüklememiz gerekiyor. Bu sayede, Geliştirici Kullanıcı Arayüzü de dahil olmak üzere yerel geliştirici araçlarına erişebilirsiniz. Terminal pencerenize şunu yazın:

curl -sL cli.genkit.dev | bash

Ortam değişkenlerini yapılandırma

Google Cloud kimlik bilgilerinizin doğru şekilde ayarlandığından emin olun. Gemini 3 Pro Preview modelleri (Nano Banana Pro bunlardan biridir) kullanılırken konum global olmalıdır.

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

Mevcut proje için Vertex AI API'yi etkinleştirmek üzere kabuk modunda aşağıdaki komutu çalıştırın:

gcloud services enable aiplatform.googleapis.com

Yerel makinenizden çalıştırıyorsanız (Cloud Shell'de değil) gcloud komutuyla kimlik doğrulaması yapmanız gerekir:

gcloud auth application-default login

4. İlk Genkit uygulamanızı oluşturma

Genkit, geliştiricilerin üretime hazır yapay zeka destekli uygulamalar oluşturmasına, dağıtmasına ve izlemesine yardımcı olmak için tasarlanmış açık kaynaklı bir çerçevedir. Bu bölümde, fotoğraf restorasyon mantığına girmeden önce çerçeveye alışmanıza yardımcı olacak basit bir "Hello World" uygulaması oluşturacağız.

Genkit terminolojisi

Genkit ile çalışmaya başlamadan önce birkaç önemli terimi anlamanız gerekir:

  • Eklentiler: Genkit'in özelliklerini genişletmek için kullanılır. Uygulamanızı desteklemek için yapay zeka modellerini kaydetmek, eklentiler aracılığıyla yapabileceğiniz işlemlerden biridir.
  • Akışlar: Genkit'in ana mimari bileşenidir. Standart bir akış, giriş alır, işler ve çıkış döndürür. Bir modelin kullanılması zorunlu değildir ancak çoğu zaman akışlarınızda modeller kullanırsınız.
  • İstemler: dotprompt biçiminde depolanan etkileşim şablonları (*.prompt dosyaları olarak kaydedilir). Bunlar yalnızca model talimatlarını değil, aynı zamanda model adı, model parametreleri, girişler ve çıkışlar gibi yapılandırmaları da içerir.

Yapay zeka modelleriyle bağlantı kurma

Genkit, kodunuzu model sağlayıcılara bağlamak için eklentileri kullanır. Google, Anthropic ve OpenAI dahil olmak üzere tüm büyük model sağlayıcılar için eklentiler mevcuttur. Eklentileri kullanarak yerel modellere bağlanabilir (ör. Ollama kullanarak) veya Genkit'in özelliklerini genişletebilirsiniz (ör. MCP sunucularına bağlanarak).

Google modellerine erişmek için googlegenai eklentisini kullanmanız gerekir. İki arka ucu destekler:

  • Google AI: Prototip oluşturmak için en iyi seçenektir. API anahtarı kullanır.
  • Vertex AI (Google Cloud): Üretim için önerilir. Proje kimliğini ve konumu kullanır.

Bu codelab'de, laboratuvarın başında oluşturduğunuz projeye referans veren Vertex AI kimlik doğrulamasını kullanacağız.

Karşılama akışı oluşturma

Glow Up fotoğraf restorasyonu akışını daha ayrıntılı incelemeden önce, kavramları öğrenmek ve kurulumumuzun düzgün çalıştığından emin olmak için temel bir akış oluşturalım.

Akış, yapay zeka mantığınızı sarmalayarak aşağıdakileri sağlayan özel bir Genkit işlevidir:

  • Tip güvenli girişler ve çıkışlar: Statik ve çalışma zamanı doğrulaması için Go yapılarını kullanarak şemalar tanımlayın.
  • Akış desteği: Kısmi yanıtları veya müşteri verilerini akışla aktarma
  • Geliştirici kullanıcı arayüzü entegrasyonu: Görsel izlerle akışları test edin ve hatalarını ayıklayın.
  • Kolay dağıtım: Herhangi bir platformda HTTP uç noktası olarak dağıtın.

IDE'nizi açın ve proje dizininizde bir main.go dosyası oluşturun. Cloud Shell kullanıyorsanız aşağıdaki komutu kullanabilirsiniz:

cloudshell edit main.go

Ardından aşağıdaki kodu ekleyin:

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

Dosyayı kaydedin ve ardından bağımlılıklarınızı güncellemek için go mod tidy komutunu çalıştırın:

go mod tidy

Yukarıdaki kod, Genkit'i VertexAI eklentisiyle başlatır, "greeter" adlı bir akış tanımlar ve ardından <-ctx.Done() üzerinde süresiz olarak bekler. Akışı yürütmek için herhangi bir talimat vermediğimizden, bu programın hemen sonlandırılmaması için yürütmeyi bekletiyoruz.

Bu programı şu anki haliyle çalıştırırsanız kendi başına pek bir şey yapmaz. Akışı bir şekilde çağırmamız gerekir. Gerçek bir üretim uygulamasında bu akışı bir web sunucusuna veya CLI uygulamasına sarmalarız. Geliştirme aşamasında ise akışı geliştirip optimize etmek için genkit CLI'yı kullanabiliriz.

genkit CLI, Genkit yığınının modellerini, istemlerini, akışlarını ve diğer bileşenlerini test etmemize yardımcı olmak için geliştirilmiştir. Ayrıca, uygulamanın arka planda nasıl çalıştığını anlamak istediğinizde çok kullanışlı olan izler için tam destek sunar. genkit KSA'yı kullanarak karşılama akışımızı başlatmak için aşağıdaki komutu çalıştırın:

genkit start -- go run main.go

Bu işlem, Telemetry API ve geliştirici kullanıcı arayüzü uç noktalarını etkinleştirir. Aşağıdakine benzer bir tablo görürsünüz:

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

Geliştirici kullanıcı arayüzünü başlatmak için tarayıcınızda localhost:4000 adresini açarsanız. Şuna benzer bir ekran görürsünüz:

93d9bd9e1bd6627d.png

Geliştirici kullanıcı arayüzünü incelemek için zaman ayırın. "Karşılama" akışını bir kez tetikleyerek nasıl çalıştığını görebilirsiniz.

İstem şablonlarını kullanma

Önceki örnekte yaptığımız gibi istemlerinizi model çağrılarına sabit kodla ekleyebilirsiniz. Ancak daha iyi bir yaklaşım, uygulamamızın tüm istemlerini merkezi bir şekilde depolamak için istem şablonları oluşturmaktır. Bu sayede, kodun bakımı sırasında istemleri daha kolay bulabilir ve akışlardan bağımsız olarak istemlerle denemeler yapabilirsiniz.

Genkit, istem şablonlarını tanımlamak için *.prompt dosyaları olarak kaydedilen açık kaynak dotprompt biçimini kullanır. .prompt dosyası iki bölümden oluşur:

  1. Frontmatter: Modeli, model parametrelerini ve hem giriş hem de çıkış şemalarını tanımlayan bir YAML bloğu
  2. Gövde: "Handlebars" söz dizimi kullanılarak şablon haline getirilebilen istemin gövdesi. Örneğin, variable-name adlı bir giriş tanımlarsanız gövdede {{variable-name}} olarak referans verebilirsiniz.

Projenin dizin yapısı şu şekilde görünür:

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

Bunu uygulamalı olarak görelim. Öncelikle istemlerinizi depolayacağınız klasörü oluşturun:

mkdir -p prompts

Ardından bir greeter.prompt dosyası oluşturun:

cloudshell edit prompts/greeter.prompt

Ardından aşağıdaki içeriği ekleyin:

greeter.prompt

ec9fc82a98604123.png

Bu istem, şablon dilinin birkaç özelliğini gösterir. Öncelikle, ön bilgide vertexai/gemini-2.5-flash modelini belirtiriz. Bir model belirtmek için ilgili eklenti belgelerinde tanımlanan adlandırma kuralını kullanmanız gerekir.

Yapılandırma bölümünde model parametrelerini yapılandırabilirsiniz. Modelin daha yaratıcı olmasını sağlamak için sıcaklığı 1,9 olarak ayarlıyoruz. Sıcaklık 0 (daha tutarlı çıkışlar) ile 2 (daha yaratıcı çıkışlar) arasında değişir. Bu ve diğer model parametreleri genellikle modelin model sayfasında yayınlanır. Örneğin, gemini-2.5-flash modelinin model sayfasını burada bulabilirsiniz.

Giriş bölümü, istem için bağımsız değişkenler belirtmemize olanak tanır. Bu örnekte, adı dize olarak tanımlıyoruz. Ön kısımdan sonra istem gövdesi gelir. Buradaki ilk blok sistem istemini, ikinci blok ise kullanıcı istemini tanımlar. Tüm bu unsurlar bir araya geldiğinde çok güçlü istem teknikleri kullanılabilir. dotprompt ile ilgili tüm dokümanları buradan inceleyebilirsiniz.

Şimdi greeter akışını, az önce oluşturduğumuz istemi kullanacak şekilde uyarlayalım:

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

Aradaki farkı görmek için akışı komut satırından adla ve adsız olarak çalıştırmayı deneyin. Adsız çalıştırma:

genkit flow:run greeter

Örnek çıkış:

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

Adı da şu:

genkit flow:run greeter '"Daniela"'

Örnek çıkış:

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

Şablonun beklendiği gibi çalıştığını görebilirsiniz. Bu projeyi bir üst seviyeye taşımaya hazırız.

5. Nano Banana Pro ile görüntüleri geri yükleme

Geri yükleme istemi

Genkit'in temel bileşenlerini öğrendiğinize göre artık fotoğraf restorasyon istemimizi oluşturabiliriz.

İstemler dizininde glowup.prompt adlı bir dosya oluşturun ve aşağıdaki içeriği bu dosyaya yapıştırın:

glowup.prompt

fd0f1551466c8138.png

Geri yükleme istemi, "karşılama" istemimizle aynı kalıbı izler ancak birkaç önemli fark vardır:

  • Görüntü boyutu: imageConfig öğesinin imageSize özelliği, Nano Banana Pro'nun modele özgü bir parametresidir. Çıkış boyutunu 1K, 2K veya 4K olarak belirtebiliriz.
  • Medya girişi: Fotoğrafı kullanıcı istemine eklemek için {{ media }} şablonunu kullanıyoruz. Bu teknik, modele çok formatlı istemler (metin + resim) göndermemize olanak tanır.

Bu istemi geliştirici kullanıcı arayüzünde test edebilirsiniz. Çıktıyı nasıl etkilediğini görmek için istemi dilediğiniz gibi değiştirebilirsiniz.

Görüntü restorasyon akışı

Restorasyon istemi hazır olduğuna göre şimdi CLI uygulamamızı oluşturalım. main.go dosyasının içeriğini aşağıdaki kodla değiştirin:

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
}

Kod, yapı olarak greeter akışına çok benzer ancak bu kez bağımsız bir CLI uygulaması olarak çalışacak şekilde uyarlanmıştır. Sonsuza kadar engellemek yerine glowUp akışını çalıştırır, çıkışın kodunu çözer ve elde edilen ikili verileri diske kaydeder.

Model, görüntü verilerini aşağıdaki biçimde döndürdüğü için çıkışın kodunu çözmemiz gerekir:

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

decode işlevinde, MIME türünü ve kodlanmış resim parçalarını ayırmak için dize manipülasyonu kullandığımızı görebilirsiniz. Ardından, dosyayı kaydetmek için gereken bilgileri ayıklamak üzere mime.ExtensionByType ve base64.DecodeString işlevlerini kullanırız.

Geri yükleme akışını test etme

Artık bu akışı gerçek bir resimle çalıştırmanın zamanı geldi. Onarılması gereken eski fotoğraflarınız yoksa Kongre Kütüphanesi web sitesinden alınan bu kamu alanı resmiyle deneyebilirsiniz:

f0fc83a81e88052a.png

Akışa aktarmak için fotoğrafın doğrudan bağlantısı: 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

Onarılmış ve renklendirilmiş çıktı ise şu şekilde:

5ed7bfcf6d26313c.png

Başarılı aktarım

6. glowUp'ı web hizmeti olarak dağıtma

Akışlarınızı komut satırı uygulaması yerine bir web hizmetinde kullanıma sunmak istiyorsanız Genkit, genkit.Handler bağdaştırıcısını kullanarak akışları uç noktalara dönüştürmenin kolay bir yolunu sunar. Aşağıdaki kod, genkit.Handler kullanarak glowUp akışını glowUp uç noktası olarak kaydeder.

Bunları, standart kitaplıktaki http paketini kullanarak normalde yaptığınız gibi normal bir HTTP sunucusuyla kullanıma sunabilirsiniz. Ancak Genkit, kapatma sinyallerini düzgün bir şekilde işleme gibi yaygın sunucu standartlarından bazılarına yardımcı olan bir server eklentisi de sağlar.

Web sunucunuzu oluşturmak için main.go dosyasının içeriğini aşağıdaki kodla değiştirin.

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

Bu hizmeti yerel olarak veya bulutta çalıştırabilirsiniz. Program artık tamamlandığı için yerel olarak çalıştırmak isterseniz dosyayı doğrudan çalıştırabilirsiniz. Bu nedenle, dosyayı Genkit CLI aracılığıyla başlatmamız gerekmez. Örneğin:

go run main.go

Bu işlem engelleme işlemi olduğundan test etmek için ikinci bir terminal başlatmanız gerekir. En hızlı yöntem, curl komutunu kullanmaktır:

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

Bu bir sunucu yanıtı olduğundan base64 resmin kodunu çözmemiz gerekir:

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

Web hizmetini Cloud Run'a dağıtma

Bu sunucunun "makinenizde çalışması" iyi bir şeydir ancak ideal dünyada bunu tüm kullanıcılarımızın erişebileceği başka bir yere dağıtırız. Bu tür hizmetleri dağıtmanın en kolay yollarından biri, Cloud Run'ın kaynaktan dağıtma özelliğini kullanmaktır. Bu özellik sayesinde kapsayıcıyı kendiniz oluşturmanız bile gerekmez, her şey otomatik olarak yapılır.

Bu hizmeti kaynaktan dağıtım kullanarak Cloud Run'a dağıtmak için aşağıdaki komutu çalıştırın (proje kimliğini kendi kimliğinizle değiştirin):

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

Dağıtımın tamamlanması birkaç dakika sürebilir. İşiniz bittiğinde curl üzerinden başka bir istek göndererek uç noktayı test edebilirsiniz:

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

Yine base64 resminin kodunu çözmemiz gerekir:

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

Artık tamamen çalışan bir fotoğraf restorasyonu web sunucumuz var.

İsteğe bağlı: İstemci uygulaması için "sezgisel kodlama"

Manuel olarak kod yazmak eğlencelidir ancak daha önce belirli bir proje türünü hiç yapmadıysanız zorlayıcı da olabilir. Neyse ki günümüzde bu süreci hızlandırmamıza yardımcı olabilecek kodlama temsilcileri var.

Bu adımda, kodu kendimiz yazmak yerine Gemini KSA'dan (veya tercih ettiğiniz kodlama ajanından) bizim için yazmasını isteyeceğiz. Aşağıdaki istemi kullanın:

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

Aynı modülde iki "main" işlevi olamayacağı için temsilcinin dosyaları biraz yeniden düzenlemesi gerekebilir. Çalışmasını izleyin ve gerekirse sunucu kodunu veya snippet'leri vererek doğru uygulamaya yönlendirin.

Laboratuvardan sonra temizlik

7. Sonuç

Tebrikler! Genkit ve Nano Banana Pro'yu kullanarak yüksek kaliteli bir fotoğraf restorasyon uygulaması oluşturdunuz.

Bu codelab'de şunları öğrendiniz:

  • Ortamınızı Genkit Go uygulamaları geliştirecek şekilde yapılandırma
  • dotprompt ile çok formatlı istemler oluşturma
  • İstem şablonlarını kullanarak Genkit akışları oluşturma
  • Görüntüleri işlemek için Nano Banana Pro'yu kullanma
  • Genkit akışlarını komut satırı uygulamaları ve web hizmetleri olarak paketleme
  • Genkit uygulamalarını Cloud Run'a dağıtma

Testi tamamladıktan sonra ortamı temizlemeyi unutmayın.

Sonraki adımlar

Bu platformdaki diğer codelab'leri keşfederek veya glowUp'ta kendi başınıza iyileştirmeler yaparak öğrenme yolculuğunuza devam edebilirsiniz.

İyileştirmelerle ilgili fikirlere ihtiyacınız varsa şunları deneyebilirsiniz:

  • Yerel dosyaları geri yüklemek için glowUp KSA'yı etkinleştirme
  • GlowUp web hizmeti için ön uç oluşturma
  • Verilerden MIME türünü otomatik olarak algılama
  • Diğer görüntü işleme türlerini gerçekleştirme (fotoğraftan çizime, çizimden fotoğrafa, taslaktan nihai resme vb.)
  • İstemciyi oluşturma veya iyileştirme (akıllı telefon uygulaması oluşturma)

Seçenekleriniz sınırsızdır. Kendi başınıza ilerlemek biraz göz korkutucu geliyorsa Gemini CLI veya Antigravity gibi bir kodlama temsilcisinden yardım alabilirsiniz. Genkit ile daha fazlasını yapmak istiyorsanız Genkit MCP sunucusu ile eşlenen kodlama temsilcileri işinizi çok daha kolaylaştırabilir.

Son olarak, bu deponun tam koduna erişmek isterseniz buradan ulaşabilirsiniz.

Keyifli kodlamalar!