สร้างแอปการกู้คืนรูปภาพโดยใช้ Genkit Go และ Nano Banana Pro

1. บทนำ

ใน Codelab นี้ เราจะสร้าง GlowUp ซึ่งเป็นเครื่องมือปรับแต่งรูปภาพ GlowUp ใช้ AI เพื่อกู้คืนรูปภาพเก่า รูปภาพที่เสียหาย หรือรูปภาพขาวดำ โดยสร้างรูปภาพสี 4K คุณภาพสูง คุณสามารถใช้เครื่องมือนี้เพื่อทำให้รูปภาพครอบครัวกลับมามีชีวิตอีกครั้ง หรือแม้แต่ปรับใช้เพื่อกู้คืนภาพประกอบ ภาพวาด ภาพวาดสี หรือรูปภาพรูปแบบอื่นๆ ที่เสียหาย

คุณจะใช้ Genkit Go เพื่อใช้ตรรกะของแอปพลิเคชัน และใช้ Gemini 3 Pro Image (หรือที่เรียกว่า Nano Banana Pro) เป็นโมเดลในการประมวลผลรูปภาพ

ข้อกำหนดเบื้องต้น

  • ความรู้พื้นฐานเกี่ยวกับภาษาโปรแกรม Go
  • ความรู้พื้นฐานเกี่ยวกับคอนโซล Google Cloud

สิ่งที่คุณจะได้เรียนรู้

  • วิธีพัฒนาแอปพลิเคชัน Genkit ใน Go
  • แนวคิดพื้นฐานของ Genkit เช่น โฟลว์ ปลั๊กอิน และพรอมต์
  • วิธีเขียนพรอมต์ด้วยเทมเพลต Handlebar
  • วิธีรับข้อมูลรูปภาพจากคำตอบของโมเดล

สิ่งที่คุณต้องมี

เวิร์กช็อปนี้สามารถทำได้ทั้งหมดภายใน Google Cloud Shell ซึ่งมาพร้อมกับทรัพยากร Dependency ที่จำเป็นทั้งหมด (gcloud CLI, ตัวแก้ไขโค้ด, Go, Gemini CLI) ที่ติดตั้งไว้ล่วงหน้า

หรือหากต้องการทำงานในเครื่องของคุณเอง คุณจะต้องมีสิ่งต่อไปนี้

  • Go Toolchain (เวอร์ชัน 1.24 ขึ้นไป)
  • Node.js v20 ขึ้นไป (สำหรับ genkit CLI)
  • เทอร์มินัลที่ติดตั้ง gcloud CLI ไว้
  • IDE เพื่อแก้ไขโค้ด เช่น VS Code หรือที่คล้ายกัน
  • แนะนำ: เอเจนต์การเขียนโค้ด เช่น Gemini CLI หรือ Antigravity

เทคโนโลยีหลัก

ดูข้อมูลเพิ่มเติมเกี่ยวกับเทคโนโลยีที่เราจะใช้ได้ที่นี่

  • Gemini Nano Banana Pro (Gemini 3 Pro Image): โมเดลที่ขับเคลื่อนกระบวนการกู้คืนของเรา
  • Genkit Go: ชุดเครื่องมือของเราสำหรับการจัดการการเรียกใช้โมเดล

2. การตั้งค่าสภาพแวดล้อม

คุณสามารถเรียกใช้ห้องทดลองนี้จากเครื่องของคุณหรือในระบบคลาวด์ทั้งหมดก็ได้ แม้ว่าคุณจะเลือกเรียกใช้โค้ดในเครื่อง แต่คุณจะต้องมีโปรเจ็กต์ Google Cloud เพื่อให้คอมโพเนนต์ฝั่งเซิร์ฟเวอร์ใช้งานได้ในระบบคลาวด์ ทำตามขั้นตอนในส่วนถัดไปเพื่อสร้างหน้าดังกล่าว

การตั้งค่าสภาพแวดล้อมแบบเรียนรู้ด้วยตนเอง

  1. ลงชื่อเข้าใช้คอนโซล Google Cloud แล้วสร้างโปรเจ็กต์ใหม่หรือใช้โปรเจ็กต์ที่มีอยู่ซ้ำ หากยังไม่มีบัญชี Gmail หรือ Google Workspace คุณต้องสร้างบัญชี

295004821bab6a87.png37d264871000675d.png96d86d3d5655cdbe.png

  • ชื่อโปรเจ็กต์คือชื่อที่แสดงสำหรับผู้เข้าร่วมของโปรเจ็กต์นี้ ซึ่งเป็นสตริงอักขระที่ Google APIs ไม่ได้ใช้ คุณอัปเดตข้อมูลได้ทุกเมื่อ
  • รหัสโปรเจ็กต์จะไม่ซ้ำกันในโปรเจ็กต์ Google Cloud ทั้งหมดและเปลี่ยนแปลงไม่ได้ (ไม่สามารถเปลี่ยนแปลงได้หลังจากตั้งค่าแล้ว) Cloud Console จะสร้างสตริงที่ไม่ซ้ำกันโดยอัตโนมัติ ซึ่งโดยปกติแล้วคุณจะไม่สนใจว่าสตริงนั้นคืออะไร ใน Codelab ส่วนใหญ่ คุณจะต้องอ้างอิงรหัสโปรเจ็กต์ (โดยปกติจะระบุเป็น PROJECT_ID) หากไม่ชอบรหัสที่สร้างขึ้น คุณอาจสร้างรหัสแบบสุ่มอีกรหัสหนึ่ง หรือจะลองใช้ชื่อของคุณเองและดูว่าพร้อมใช้งานหรือไม่ก็ได้ คุณจะเปลี่ยนแปลงไม่ได้หลังจากขั้นตอนนี้ และจะยังคงอยู่ตลอดระยะเวลาของโปรเจ็กต์
  • โปรดทราบว่ายังมีค่าที่ 3 คือหมายเลขโปรเจ็กต์ ซึ่ง API บางรายการใช้ ดูข้อมูลเพิ่มเติมเกี่ยวกับค่าทั้ง 3 ค่านี้ได้ในเอกสารประกอบ
  1. ถัดไป คุณจะต้องเปิดใช้การเรียกเก็บเงินในคอนโซล Cloud เพื่อใช้ทรัพยากร/API ของ Cloud การทำตาม Codelab นี้จะมีค่าใช้จ่ายไม่มากนัก (หากมี) หากต้องการปิดทรัพยากรเพื่อหลีกเลี่ยงการเรียกเก็บเงินนอกเหนือจากบทแนะนำนี้ คุณสามารถลบทรัพยากรที่สร้างขึ้นหรือลบโปรเจ็กต์ได้ ผู้ใช้ Google Cloud รายใหม่มีสิทธิ์เข้าร่วมโปรแกรมทดลองใช้ฟรีมูลค่า $300 USD

เริ่ม Cloud Shell

แม้ว่า Google Cloud จะทำงานจากระยะไกลจากแล็ปท็อปได้ แต่ใน Codelab นี้ คุณจะใช้ Google Cloud Shell ซึ่งเป็นสภาพแวดล้อมบรรทัดคำสั่งที่ทำงานในระบบคลาวด์

จากคอนโซล Google Cloud ให้คลิกไอคอน Cloud Shell บนแถบเครื่องมือด้านขวาบน

เปิดใช้งาน Cloud Shell

การจัดสรรและเชื่อมต่อกับสภาพแวดล้อมจะใช้เวลาเพียงไม่นาน เมื่อดำเนินการเสร็จแล้ว คุณควรจะเห็นข้อความในลักษณะนี้

ภาพหน้าจอของเทอร์มินัล Google Cloud Shell ที่แสดงว่าสภาพแวดล้อมเชื่อมต่อแล้ว

เครื่องเสมือนนี้โหลดมาพร้อมกับเครื่องมือสำหรับนักพัฒนาซอฟต์แวร์ทั้งหมดที่คุณต้องการ โดยมีไดเรกทอรีหลักขนาด 5 GB แบบถาวร และทำงานบน Google Cloud ซึ่งช่วยเพิ่มประสิทธิภาพเครือข่ายและการตรวจสอบสิทธิ์ได้อย่างมาก งานทั้งหมดของคุณใน Codelab นี้สามารถทำได้ภายในเบราว์เซอร์ คุณไม่จำเป็นต้องติดตั้งอะไรเลย

3. การตั้งค่าโปรเจ็กต์

สร้างโปรเจ็กต์

ก่อนอื่น เราต้องสร้างไดเรกทอรีใหม่สำหรับโปรเจ็กต์และเริ่มต้นโมดูล Go เรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัล

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

ติดตั้ง Genkit CLI

ตอนนี้เราต้องติดตั้ง Genkit CLI ซึ่งจะช่วยให้คุณเข้าถึงเครื่องมือสำหรับนักพัฒนาซอฟต์แวร์ในเครื่อง รวมถึง UI สำหรับนักพัฒนาซอฟต์แวร์ พิมพ์คำสั่งต่อไปนี้ในหน้าต่างเทอร์มินัล

curl -sL cli.genkit.dev | bash

กำหนดค่าตัวแปรสภาพแวดล้อม

ตรวจสอบว่าคุณได้ตั้งค่าข้อมูลเข้าสู่ระบบ Google Cloud ที่ถูกต้องแล้ว ตำแหน่งต้องเป็น global เมื่อใช้โมเดล Gemini 3 Pro เวอร์ชันตัวอย่าง (Nano Banana Pro เป็นหนึ่งในนั้น)

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

เรียกใช้คำสั่งต่อไปนี้ในโหมด Shell เพื่อเปิดใช้ Vertex AI API สำหรับโปรเจ็กต์ปัจจุบัน

gcloud services enable aiplatform.googleapis.com

และหากเรียกใช้จากเครื่องของคุณเอง (ไม่ใช่ใน CloudShell) คุณจะต้องตรวจสอบสิทธิ์ด้วยคำสั่ง gcloud ดังนี้

gcloud auth application-default login

4. สร้างแอปพลิเคชัน Genkit แอปแรก

Genkit เป็นเฟรมเวิร์กโอเพนซอร์สที่ออกแบบมาเพื่อช่วยนักพัฒนาแอปสร้าง ติดตั้งใช้งาน และตรวจสอบแอปพลิเคชันที่ทำงานด้วยระบบ AI ซึ่งพร้อมใช้งานจริง ในส่วนนี้ เราจะสร้างแอปพลิเคชัน "Hello World" แบบง่ายๆ เพื่อช่วยให้คุณคุ้นเคยกับเฟรมเวิร์กก่อนที่เราจะเจาะลึกตรรกะการกู้คืนรูปภาพ

คำศัพท์ของ Genkit

ก่อนเริ่มทำงานกับ Genkit คุณควรทำความเข้าใจคำศัพท์สำคัญบางคำต่อไปนี้

  • ปลั๊กอิน: ใช้เพื่อขยายความสามารถของ Genkit นอกจากนี้ คุณยังลงทะเบียนโมเดล AI เพื่อขับเคลื่อนแอปพลิเคชันผ่านปลั๊กอินได้ด้วย
  • Flow: องค์ประกอบทางสถาปัตยกรรมหลักของ Genkit โดยทั่วไปแล้ว โฟลว์จะรับอินพุต ประมวลผล และแสดงผลลัพธ์ ไม่จำเป็นต้องใช้โมเดล แต่ส่วนใหญ่แล้วคุณจะใช้โมเดลภายในโฟลว์
  • พรอมต์: เทมเพลตการโต้ตอบที่จัดเก็บไว้ในรูปแบบ dotprompt (บันทึกเป็นไฟล์ *.prompt) ซึ่งไม่เพียงแต่มีวิธีการของโมเดลเท่านั้น แต่ยังมีการกำหนดค่าต่างๆ เช่น ชื่อโมเดล พารามิเตอร์โมเดล อินพุต และเอาต์พุตด้วย

การเชื่อมต่อกับโมเดล AI

Genkit ใช้ปลั๊กอินเพื่อเชื่อมต่อโค้ดกับผู้ให้บริการโมเดล มีปลั๊กอินสำหรับผู้ให้บริการโมเดลรายใหญ่ทั้งหมด รวมถึง Google, Anthropic และ OpenAI นอกจากนี้ คุณยังใช้ปลั๊กอินเพื่อเชื่อมต่อกับโมเดลในเครื่อง (เช่น การใช้ Ollama) หรือเพื่อขยายความสามารถของ Genkit (เช่น เชื่อมต่อกับเซิร์ฟเวอร์ MCP) ได้ด้วย

หากต้องการเข้าถึงโมเดลของ Google คุณควรใช้ปลั๊กอิน googlegenai โดยรองรับแบ็กเอนด์ 2 รายการ ได้แก่

  • Google AI: เหมาะสำหรับการสร้างต้นแบบมากที่สุด ใช้คีย์ API
  • Vertex AI (Google Cloud): แนะนำสำหรับการใช้งานจริง ใช้รหัสโปรเจ็กต์และตำแหน่ง

ใน Codelab นี้ เราจะใช้การตรวจสอบสิทธิ์ Vertex AI โดยอ้างอิงโปรเจ็กต์ที่คุณสร้างไว้ตอนต้นของห้องทดลอง

การสร้างโฟลว์ผู้ต้อนรับ

ก่อนที่จะเจาะลึกขั้นตอนการกู้คืนรูปภาพของ Glow Up เรามาสร้างขั้นตอนพื้นฐานเพื่อทำความคุ้นเคยกับแนวคิดและตรวจสอบว่าการตั้งค่าทำงานอย่างถูกต้องกันก่อน

โฟลว์คือฟังก์ชัน Genkit พิเศษที่รวมตรรกะ AI ของคุณเพื่อให้บริการต่อไปนี้

  • อินพุตและเอาต์พุตที่ปลอดภัยในการกำหนดประเภท: กำหนดสคีมาโดยใช้โครงสร้าง Go สำหรับการตรวจสอบแบบคงที่และรันไทม์
  • การรองรับสตรีมมิง: สตรีมคำตอบเพียงบางส่วนหรือข้อมูลที่กำหนดเอง
  • การผสานรวม UI ของนักพัฒนาแอป: ทดสอบและแก้ไขข้อบกพร่องของโฟลว์ด้วยการติดตามภาพ
  • ติดตั้งใช้งานง่าย: ติดตั้งใช้งานเป็นปลายทาง HTTP ในแพลตฟอร์มใดก็ได้

เปิด IDE และสร้างไฟล์ main.go ในไดเรกทอรีโปรเจ็กต์ หากใช้ Cloud Shell คุณสามารถใช้คำสั่งต่อไปนี้ได้

cloudshell edit main.go

จากนั้นเพิ่มโค้ดต่อไปนี้

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

บันทึกไฟล์แล้วเรียกใช้ go mod tidy เพื่ออัปเดตทรัพยากร Dependency ดังนี้

go mod tidy

โค้ดด้านบนจะเริ่มต้น Genkit ด้วยปลั๊กอิน VertexAI, กำหนดโฟลว์ชื่อ "greeter" แล้วรอ <-ctx.Done() ตลอดไป เราจะระงับการดำเนินการเพื่อไม่ให้โปรแกรมนี้สิ้นสุดทันที เนื่องจากเราไม่ได้ให้คำสั่งใดๆ แก่โปรแกรมเพื่อดำเนินการตามขั้นตอนจริงๆ

ซึ่งหมายความว่าหากคุณเรียกใช้โปรแกรมนี้ในตอนนี้ โปรแกรมจะทำงานได้ไม่มากนัก เราจึงต้องเรียกใช้โฟลว์ด้วยวิธีใดวิธีหนึ่ง แม้ว่าในแอปพลิเคชันเวอร์ชันที่ใช้งานจริง เราจะรวมโฟลว์นี้ไว้ในเว็บเซิร์ฟเวอร์หรือแอป CLI แต่ในระหว่างการพัฒนา เราสามารถใช้ genkit CLI เพื่อช่วยพัฒนาและเพิ่มประสิทธิภาพโฟลว์ได้

CLI ของ genkit ได้รับการพัฒนาขึ้นเพื่อช่วยเราทดสอบโมเดล พรอมต์ โฟลว์ และคอมโพเนนต์อื่นๆ ของสแต็ก Genkit นอกจากนี้ยังรองรับการติดตามอย่างเต็มรูปแบบ ซึ่งสะดวกมากเมื่อคุณต้องการทำความเข้าใจวิธีการทำงานของแอปพลิเคชันเบื้องหลัง หากต้องการเปิดใช้งานขั้นตอนการทักทายโดยใช้ genkit CLI ให้เรียกใช้คำสั่งต่อไปนี้

genkit start -- go run main.go

ซึ่งจะเปิดใช้งานปลายทาง Telemetry API และ Developer UI คุณควรเห็นข้อความลักษณะนี้

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

หากคุณเปิด localhost:4000 ในเบราว์เซอร์เพื่อเปิด Dev-UI คุณควรเห็นหน้าจอดังนี้

93d9bd9e1bd6627d.png

ใช้เวลาสำรวจ UI สำหรับนักพัฒนาซอฟต์แวร์ คุณอาจเรียกใช้โฟลว์ "greeter" 1 ครั้งเพื่อดูวิธีการทำงาน

การใช้เทมเพลตพรอมต์

แม้ว่าคุณจะฮาร์ดโค้ดพรอมต์ในการเรียกใช้โมเดลได้เหมือนที่เราทำในตัวอย่างก่อนหน้านี้ แต่วิธีที่ดีกว่าคือการสร้างเทมเพลตพรอมต์เพื่อจัดเก็บพรอมต์ทั้งหมดของแอปพลิเคชันไว้ในที่เดียว ซึ่งไม่เพียงช่วยให้ค้นหาพรอมต์ได้ง่ายขึ้นเมื่อทำการบำรุงรักษาโค้ด แต่ยังช่วยให้คุณทดสอบพรอมต์ได้อย่างอิสระจากโฟลว์ด้วย

ในการกำหนดเทมเพลตพรอมต์ Genkit จะใช้รูปแบบ dotprompt แบบโอเพนซอร์ส ซึ่งบันทึกเป็นไฟล์ *.prompt ไฟล์ .prompt ประกอบด้วย 2 ส่วน ได้แก่

  1. Frontmatter: บล็อก YAML ที่กำหนดโมเดล พารามิเตอร์โมเดล และสคีมาทั้งอินพุตและเอาต์พุต
  2. เนื้อหา: เนื้อหาของพรอมต์ ซึ่งสามารถสร้างเทมเพลตได้โดยใช้ไวยากรณ์ "handlebars" เช่น หากคุณกำหนดอินพุตชื่อ variable-name คุณจะอ้างอิงอินพุตดังกล่าวในเนื้อหาเป็น {{variable-name}} ได้

โครงสร้างไดเรกทอรีของโปรเจ็กต์จะมีลักษณะดังนี้

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

มาดูตัวอย่างการใช้งานจริงกัน ขั้นแรก ให้สร้างโฟลเดอร์เพื่อจัดเก็บพรอมต์ โดยทำดังนี้

mkdir -p prompts

จากนั้นสร้างไฟล์ greeter.prompt โดยทำดังนี้

cloudshell edit prompts/greeter.prompt

และแทรกเนื้อหาต่อไปนี้

greeter.prompt

ec9fc82a98604123.png

พรอมต์นี้แสดงฟีเจอร์บางอย่างของภาษาเทมเพลต ก่อนอื่น เราจะระบุโมเดล vertexai/gemini-2.5-flash ใน Frontmatter หากต้องการระบุโมเดล คุณต้องใช้การตั้งชื่อที่กำหนดไว้ในเอกสารประกอบของปลั๊กอินที่เกี่ยวข้อง

ส่วนการกำหนดค่าช่วยให้เรากำหนดค่าพารามิเตอร์ของโมเดลได้ เราใช้ค่าอุณหภูมิ 1.9 เพื่อให้โมเดลมีความคิดสร้างสรรค์มากขึ้น อุณหภูมิมีตั้งแต่ 0 (เอาต์พุตที่สอดคล้องกันมากขึ้น) ถึง 2 (เอาต์พุตที่สร้างสรรค์มากขึ้น) โดยปกติแล้ว พารามิเตอร์นี้และพารามิเตอร์อื่นๆ ของโมเดลจะเผยแพร่ในชีตโมเดลของโมเดล ตัวอย่างเช่น เอกสารข้อมูลโมเดลสำหรับ gemini-2.5-flash

ส่วนอินพุตช่วยให้เราระบุอาร์กิวเมนต์สำหรับพรอมต์ได้ ในกรณีนี้ เราจะกำหนดชื่อเป็นสตริง หลังจาก Frontmatter เราจะมีเนื้อหาพรอมต์ บล็อกแรกที่นี่กำหนดพรอมต์ของระบบ และบล็อกที่ 2 คือพรอมต์ของผู้ใช้ องค์ประกอบทั้งหมดเหล่านี้รวมกันทำให้เกิดเทคนิคการเขียนพรอมต์ที่มีประสิทธิภาพมาก คุณสามารถดูเอกสารประกอบฉบับเต็มสำหรับ dotprompt ได้ที่นี่

ตอนนี้ เรามาปรับขั้นตอน greeter เพื่อใช้พรอมต์ที่เราเพิ่งสร้างขึ้นกัน

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

ลองเรียกใช้โฟลว์จากบรรทัดคำสั่ง โดยมีและไม่มีชื่อเพื่อดูความแตกต่าง การวิ่งโดยไม่มีชื่อ:

genkit flow:run greeter

ตัวอย่างเอาต์พุต

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

และมีชื่อดังนี้

genkit flow:run greeter '"Daniela"'

ตัวอย่างเอาต์พุต

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

คุณจะเห็นว่าเทมเพลตทำงานตามที่คาดไว้ เราพร้อมที่จะยกระดับโปรเจ็กต์นี้ไปอีกขั้นแล้ว

5. การกู้คืนรูปภาพด้วย Nano Banana Pro

ข้อความแจ้งการกู้คืน

เมื่อคุณคุ้นเคยกับองค์ประกอบพื้นฐานของ Genkit แล้ว ก็ถึงเวลาสร้างพรอมต์การกู้คืนรูปภาพ

สร้างไฟล์ชื่อ glowup.prompt ในไดเรกทอรีพรอมต์ แล้ววางเนื้อหาต่อไปนี้ลงในไฟล์

glowup.prompt

fd0f1551466c8138.png

พรอมต์การกู้คืนจะเป็นไปตามรูปแบบเดียวกับพรอมต์ "ผู้ต้อนรับ" โดยมีความแตกต่างที่สำคัญเพียง 2 ประการดังนี้

  • ขนาดรูปภาพ: พร็อพเพอร์ตี้ imageSize ของ imageConfig เป็นพารามิเตอร์เฉพาะโมเดลของ Nano Banana Pro ซึ่งช่วยให้เราสามารถระบุขนาดเอาต์พุตเป็น 1K, 2K หรือ 4K ได้
  • อินพุตสื่อ: เราใช้เทมเพลต {{ media }} เพื่อแทรกรูปภาพในพรอมต์ของผู้ใช้ เทคนิคนี้ช่วยให้เราส่งพรอมต์แบบหลายโมดัลไปยังโมเดล (ข้อความ + รูปภาพ) ได้

คุณทดสอบข้อความแจ้งนี้ได้ใน Dev UI คุณสามารถปรับแต่งพรอมต์เพื่อดูว่าส่งผลต่อเอาต์พุตอย่างไร

ขั้นตอนการกู้คืนรูปภาพ

เมื่อพรอมต์การกู้คืนพร้อมแล้ว ตอนนี้เรามาสร้างแอปพลิเคชัน CLI กัน แทนที่เนื้อหาของ main.go ด้วยโค้ดด้านล่าง

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
}

โค้ดมีโครงสร้างคล้ายกับขั้นตอน greeter มาก แต่ครั้งนี้ได้รับการปรับให้ทำงานเป็นแอปพลิเคชัน CLI แบบสแตนด์อโลน แทนที่จะบล็อกตลอดไป ระบบจะเรียกใช้โฟลว์ glowUp ถอดรหัสเอาต์พุต และบันทึกข้อมูลไบนารีที่ได้ลงในดิสก์

เราจำเป็นต้องถอดรหัสเอาต์พุตเนื่องจากโมเดลจะแสดงผลข้อมูลรูปภาพในรูปแบบต่อไปนี้

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

คุณจะเห็นในฟังก์ชัน decode ว่าเราใช้การจัดการสตริงเพื่อแยกประเภท MIME และส่วนรูปภาพที่เข้ารหัส จากนั้นเราจะใช้ฟังก์ชัน mime.ExtensionByType และ base64.DecodeString เพื่อดึงข้อมูลที่จำเป็นในการบันทึกไฟล์

การทดสอบขั้นตอนการกู้คืน

ตอนนี้ถึงเวลาเรียกใช้โฟลว์นี้กับรูปภาพจริงแล้ว หากไม่มีรูปภาพเก่าที่ต้องปรับแต่ง คุณสามารถลองใช้รูปภาพที่เป็นสาธารณสมบัติซึ่งดึงมาจากเว็บไซต์ Library of Congress ได้

f0fc83a81e88052a.png

ลิงก์โดยตรงไปยังภาพถ่ายเพื่อส่งไปยังโฟลว์มีดังนี้ 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

และนี่คือผลลัพธ์ที่ได้รับการกู้คืนและปรับสี

5ed7bfcf6d26313c.png

สำเร็จ!

6. กำลังติดตั้งใช้งาน glowUp เป็นบริการบนเว็บ

หากต้องการแสดงโฟลว์ในเว็บเซอร์วิสแทนแอปพลิเคชันบรรทัดคำสั่ง Genkit มีวิธีที่สะดวกในการแปลงโฟลว์เป็นปลายทางโดยใช้อะแดปเตอร์ genkit.Handler โค้ดด้านล่างจะลงทะเบียนขั้นตอน glowUp เป็นปลายทาง glowUp โดยใช้ genkit.Handler

คุณสามารถแสดงผลด้วยเซิร์ฟเวอร์ HTTP ปกติได้ตามปกติโดยใช้แพ็กเกจ http จากไลบรารีมาตรฐาน แต่ Genkit ยังมีปลั๊กอิน server ที่ช่วยจัดการเทมเพลตเซิร์ฟเวอร์ทั่วไปบางอย่าง เช่น การจัดการสัญญาณปิดระบบอย่างราบรื่น

แทนที่เนื้อหาของ main.go ด้วยโค้ดด้านล่างเพื่อสร้างเว็บเซิร์ฟเวอร์

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

คุณสามารถเรียกใช้บริการนี้ในเครื่องหรือในระบบคลาวด์ก็ได้ หากต้องการเรียกใช้ในเครื่อง คุณสามารถเรียกใช้ไฟล์ได้โดยตรงเนื่องจากโปรแกรมเสร็จสมบูรณ์แล้ว เราจึงไม่จำเป็นต้องเปิดใช้งานผ่าน Genkit CLI เช่น

go run main.go

เนื่องจากการดำเนินการนี้เป็นการบล็อก คุณจึงต้องเปิดเทอร์มินัลที่ 2 เพื่อทดสอบ วิธีที่เร็วที่สุดคือการใช้คำสั่ง curl ดังนี้

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

เนื่องจากนี่เป็นการตอบกลับของเซิร์ฟเวอร์ เราจึงต้องถอดรหัสรูปภาพ Base64 ดังนี้

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

ทำให้เว็บเซอร์วิสใช้งานได้ใน Cloud Run

เซิร์ฟเวอร์นี้ "ทำงานบนเครื่องของฉัน" ได้ก็ดี แต่ในโลกอุดมคติ เราจะทำให้เซิร์ฟเวอร์นี้เข้าถึงได้จากที่อื่นสำหรับผู้ใช้ทุกคน วิธีที่สะดวกที่สุดวิธีหนึ่งในการติดตั้งใช้งานบริการเช่นนี้คือการใช้ฟีเจอร์ติดตั้งใช้งานจากแหล่งที่มาของ Cloud Run ฟีเจอร์นี้ช่วยให้คุณไม่ต้องสร้างคอนเทนเนอร์เอง เนื่องจากทุกอย่างเป็นแบบอัตโนมัติ

หากต้องการทำให้บริการนี้ใช้งานได้ใน Cloud Run โดยใช้การทำให้ใช้งานได้จากแหล่งที่มา ให้เรียกใช้คำสั่งต่อไปนี้ (แทนที่รหัสโปรเจ็กต์ด้วยรหัสของคุณเอง)

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

การติดตั้งใช้งานอาจใช้เวลาสักครู่จึงจะเสร็จสมบูรณ์ เมื่อเสร็จแล้ว คุณจะทดสอบปลายทางได้โดยส่งคำขออีกรายการผ่าน 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

อีกครั้ง เราจำเป็นต้องถอดรหัสรูปภาพ Base64 ดังนี้

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

ตอนนี้เรามีเว็บเซิร์ฟเวอร์สำหรับการกู้คืนรูปภาพที่ทำงานได้อย่างสมบูรณ์แล้ว

ไม่บังคับ: "Vibe Coding" แอปพลิเคชันไคลเอ็นต์

การเขียนโค้ดด้วยตนเองเป็นเรื่องสนุก แต่อาจเป็นเรื่องท้าทายหากคุณไม่เคยทำโปรเจ็กต์บางประเภทมาก่อน โชคดีที่ปัจจุบันเรามี Agent การเขียนโค้ดที่ช่วยให้เราเร่งกระบวนการได้

ในขั้นตอนนี้ แทนที่จะเขียนโค้ดเอง เราจะขอความช่วยเหลือจาก Gemini CLI (หรือเอเจนต์การเขียนโค้ดที่คุณชื่นชอบ) ให้ทำงานให้เรา ใช้พรอมต์ต่อไปนี้

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

ตัวแทนอาจต้องจัดระเบียบไฟล์ใหม่เล็กน้อยเนื่องจากเราไม่สามารถมีฟังก์ชัน "main" 2 ฟังก์ชันในโมดูลเดียวกันได้ ดูการทำงานและบังคับทิศทางให้ติดตั้งใช้งานอย่างถูกต้อง โดยให้โค้ดหรือข้อมูลโค้ดของเซิร์ฟเวอร์หากจำเป็น

การล้างข้อมูลหลังการทดลอง

7. บทสรุป

ยินดีด้วย คุณได้สร้างแอปพลิเคชันการกู้คืนรูปภาพที่มีความแม่นยำสูงโดยใช้ Genkit และ Nano Banana Pro เรียบร้อยแล้ว

ใน Codelab นี้ คุณได้เรียนรู้วิธีทำสิ่งต่อไปนี้

  • กำหนดค่าสภาพแวดล้อมเพื่อพัฒนาแอปพลิเคชัน Genkit Go
  • สร้างพรอมต์แบบหลายโมดัลด้วย dotprompt
  • สร้างโฟลว์ Genkit โดยใช้เทมเพลตพรอมต์
  • ใช้ Nano Banana Pro เพื่อประมวลผลรูปภาพ
  • แพ็กเกจโฟลว์ Genkit เป็นแอปพลิเคชันบรรทัดคำสั่งและบริการบนเว็บ
  • ทำให้แอปพลิเคชัน Genkit ใช้งานได้ใน Cloud Run

เมื่อทดสอบเสร็จแล้ว อย่าลืมล้างสภาพแวดล้อม

ขั้นตอนถัดไป

คุณสามารถเรียนรู้ต่อได้โดยสำรวจ Codelab อื่นๆ ในแพลตฟอร์มนี้ หรือปรับปรุง glowUp ด้วยตนเอง

หากต้องการไอเดียในการปรับปรุง คุณอาจลองทำดังนี้

  • เปิดใช้ glowUp CLI เพื่อกู้คืนไฟล์ในเครื่อง
  • สร้างฟรอนท์เอนด์สำหรับบริการบนเว็บ GlowUp
  • ตรวจหาประเภท MIME จากข้อมูลโดยอัตโนมัติ
  • ประมวลผลรูปภาพประเภทอื่นๆ (จากภาพถ่ายเป็นภาพวาด จากภาพวาดเป็นภาพถ่าย จากภาพร่างเป็นภาพศิลปะขั้นสุดท้าย ฯลฯ)
  • สร้างหรือปรับปรุงไคลเอ็นต์ (อาจสร้างแอปสมาร์ทโฟน)

ทุกอย่างเป็นไปได้ หากรู้สึกว่าการดำเนินการด้วยตนเองเป็นเรื่องยาก คุณสามารถขอความช่วยเหลือจาก Agent การเขียนโค้ด เช่น Gemini CLI หรือ Antigravity ได้เสมอ และหากต้องการทำสิ่งต่างๆ ได้มากขึ้นด้วย Genkit ตัวแทนการเขียนโค้ดที่จับคู่กับ Genkit MCP Server จะช่วยให้ชีวิตของคุณง่ายขึ้นมาก

สุดท้าย หากต้องการเข้าถึงโค้ดทั้งหมดสำหรับที่เก็บนี้ คุณสามารถดูได้ที่นี่

ขอให้สนุกกับการเขียนโค้ด