1. מבוא
ב-Codelab הזה נבנה את GlowUp, כלי לשחזור תמונות. GlowUp משתמש ב-AI כדי לשחזר תמונות ישנות, פגומות או בשחור-לבן, וליצור תמונות צבעוניות באיכות 4K. אתם יכולים להשתמש בכלי הזה כדי לשפר את התמונות המשפחתיות שלכם, או אפילו כדי לשחזר איורים, ציורים או סוגים אחרים של תמונות שניזוקו.
תשתמשו ב-Genkit Go כדי להטמיע את הלוגיקה של האפליקציה, וב-Gemini 3 Pro Image (שנקרא גם Nano Banana Pro) כמודל לעיבוד התמונות.
דרישות מוקדמות
- ידע בסיסי בשפת התכנות Go
- ידע בסיסי במסוף Google Cloud
מה תלמדו
- איך מפתחים אפליקציות Genkit ב-Go
- מושגים בסיסיים ב-Genkit כמו תהליכים, פלאגינים והנחיות
- איך כותבים הנחיות באמצעות תבניות Handlebars
- איך לקבל נתוני תמונות מהתשובות של המודל
הדרישות
אפשר להשלים את הסדנה הזו לגמרי ב-Google Cloud Shell, שכולל את כל יחסי התלות הנדרשים (ה-CLI של gcloud, עורך קוד, Go, Gemini CLI) מותקנים מראש.
לחלופין, אם אתם מעדיפים לעבוד במחשב שלכם, תצטרכו את הדברים הבאים:
- Go toolchain (גרסה 1.24 ואילך)
- Node.js בגרסה 20 ואילך (ל-CLI של
genkit) - מסוף שמותקן בו ה-CLI של
gcloud - סביבת פיתוח משולבת (IDE) לעריכת הקוד, כמו VS Code או סביבה דומה
- מומלץ: סוכן תכנות כמו Gemini CLI או Antigravity
טכנולוגיות עיקריות
כאן אפשר למצוא מידע נוסף על הטכנולוגיות שבהן נשתמש:
- Gemini Nano Banana Pro (Gemini 3 Pro Image): המודל שמפעיל את תהליך השחזור שלנו
- Genkit Go: ערכת הכלים שלנו לתזמור קריאות למודלים
2. הגדרת הסביבה
אתם יכולים להריץ את ה-Lab הזה מהמחשב שלכם או לגמרי בענן. גם אם תחליטו להריץ את הקוד באופן מקומי, תצטרכו פרויקט בענן ב-Google Cloud כדי לפרוס את הרכיבים בצד השרת בענן. כדי ליצור את מרכז הבקרה הזה, פועלים לפי השלבים בקטע הבא.
הגדרת סביבה בקצב אישי
- נכנסים למסוף Google Cloud ויוצרים פרויקט חדש או משתמשים בפרויקט קיים. אם עדיין אין לכם חשבון Gmail או Google Workspace, אתם צריכים ליצור חשבון.



- שם הפרויקט הוא השם שמוצג למשתתפים בפרויקט. זוהי מחרוזת תווים שלא משמשת את Google APIs. תמיד אפשר לעדכן אותו.
- מזהה הפרויקט הוא ייחודי לכל הפרויקטים ב-Google Cloud, ואי אפשר לשנות אותו אחרי שהוא הוגדר. מסוף Cloud יוצר באופן אוטומטי מחרוזת ייחודית. בדרך כלל לא משנה מה היא. ברוב ה-Codelabs, תצטרכו להפנות למזהה הפרויקט (בדרך כלל מזוהה בתור
PROJECT_ID). אם אתם לא אוהבים את המזהה שנוצר, אתם יכולים ליצור מזהה אקראי אחר. אתם יכולים גם לנסות להזין שם משלכם ולבדוק אם הוא זמין. אי אפשר לשנות אותו אחרי השלב הזה, והוא נשאר לאורך כל הפרויקט. - לידיעתכם, יש ערך שלישי, מספר פרויקט, שמשמש בחלק מממשקי ה-API. מידע נוסף על שלושת הערכים האלה זמין במסמכי התיעוד.
- בשלב הבא, צריך להפעיל את החיוב במסוף Cloud כדי להשתמש במשאבים או בממשקי ה-API של Cloud. העלות של הפעלת ה-Codelab הזה תהיה נמוכה מאוד, אם בכלל. כדי להשבית את המשאבים ולהימנע מחיובים נוספים, אתם יכולים למחוק את המשאבים שיצרתם או למחוק את הפרויקט. משתמשים חדשים ב-Google Cloud זכאים לתקופת ניסיון בחינם בשווי 300$.
הפעלת Cloud Shell
אפשר להפעיל את Google Cloud מרחוק מהמחשב הנייד, אבל ב-Codelab הזה תשתמשו ב-Google Cloud Shell, סביבה של שורת פקודה שפועלת ב-Cloud.
במסוף Google Cloud, לוחצים על הסמל של Cloud Shell בסרגל הכלים שבפינה הימנית העליונה:

ההקצאה והחיבור לסביבה אמורים להימשך רק כמה רגעים. בסיום התהליך, אמור להופיע משהו כזה:

המכונה הווירטואלית הזו נטענת עם כל הכלים למפתחים שתצטרכו. יש בה ספריית בית בנפח מתמיד של 5GB והיא פועלת ב-Google Cloud, מה שמשפר מאוד את ביצועי הרשת והאימות. את כל העבודה ב-Codelab הזה אפשר לבצע בדפדפן. לא צריך להתקין שום דבר.
3. הגדרת הפרויקט
יצירת הפרויקט
קודם כל, צריך ליצור ספרייה חדשה לפרויקט ולהפעיל את המודול של Go. במסוף, מריצים את הפקודות הבאות:
mkdir -p glowup && cd glowup
go mod init glowup
התקנת Genkit CLI
עכשיו צריך להתקין את Genkit CLI. כך אתם מקבלים גישה לכלים מקומיים למפתחים, כולל ממשק המשתמש למפתחים. בחלון הטרמינל, מקלידים:
curl -sL cli.genkit.dev | bash
הגדרת משתני סביבה
מוודאים שפרטי הכניסה הנכונים ל-Google Cloud מוגדרים. כדי להשתמש במודלים של Gemini 3 Pro בגרסת טרום-השקה (כמו Nano Banana Pro), המיקום צריך להיות global.
export GOOGLE_CLOUD_PROJECT=$(gcloud config get project)
export GOOGLE_CLOUD_LOCATION=global
מריצים את הפקודה הבאה במצב מעטפת כדי להפעיל את 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 כדי להפעיל את האפליקציה שלכם.
- תהליכים: הרכיב הארכיטקטוני העיקרי של Genkit. תהליך טיפוסי מקבל קלט, מעבד אותו ומחזיר פלט. לא תמיד צריך להשתמש במודל, אבל ברוב המקרים תשתמשו במודלים בתוך התהליכים שלכם.
- הנחיות: תבניות אינטראקציה שמאוחסנות בפורמט dotprompt (נשמרות כקובצי
*.prompt). ההנחיות האלה מכילות לא רק את ההוראות למודל, אלא גם הגדרות כמו שם המודל, הפרמטרים של המודל, הקלט והפלט.
חיבור למודלים של AI
Genkit משתמש ביישומי פלאגין כדי לחבר את הקוד שלכם לספקי מודלים. יש פלאגינים לכל ספקי המודלים העיקריים, כולל Google, Anthropic ו-OpenAI. אתם יכולים גם להשתמש בפלאגינים כדי להתחבר למודלים מקומיים (למשל, באמצעות Ollama) או כדי להרחיב את היכולות של Genkit (למשל, להתחבר לשרתי MCP).
כדי לגשת למודלים של Google, צריך להשתמש בפלאגין googlegenai. הוא תומך בשני קצוות עורפיים:
- Google AI: הכי מתאים ליצירת אב טיפוס. משתמש במפתח API.
- Vertex AI (Google Cloud): מומלץ לסביבת ייצור. משתמש במזהה הפרויקט ובמיקום.
ב-Codelab הזה נשתמש באימות של Vertex AI תוך הפניה לפרויקט שיצרתם בתחילת שיעור ה-Lab.
יצירת תהליך של הודעת פתיחה
לפני שנעמיק בתהליך שחזור התמונות של Glow Up, נבנה תהליך בסיסי כדי להכיר את המושגים ולוודא שההגדרה שלנו פועלת כמו שצריך.
Flow הוא פונקציה מיוחדת של Genkit שעוטפת את הלוגיקה של ה-AI כדי לספק:
- קלט ופלט עם מניעת שגיאות הקלדה: הגדרת סכימות באמצעות מבני Go לאימות סטטי ובזמן ריצה
- תמיכה בסטרימינג: סטרימינג של תשובות חלקיות או נתונים בהתאמה אישית
- שילוב ממשק משתמש למפתחים: בדיקה וניפוי באגים של תהליכים באמצעות מעקבים חזותיים
- פריסה קלה: פריסה כנקודות קצה (endpoints) של 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 כדי לעדכן את יחסי התלות:
go mod tidy
הקוד שלמעלה מאתחל את Genkit עם הפלאגין VertexAI, מגדיר תהליך בשם "greeter" ואז ממתין ללא הגבלת זמן ב-<-ctx.Done(). אנחנו מעכבים את ההפעלה כדי שהתוכנית הזו לא תסתיים מיד, כי אנחנו לא נותנים לה הוראות להפעיל את התהליך בפועל.
זה אומר שאם תריצו את התוכנית הזו כמו שהיא עכשיו, היא לא תעשה הרבה בעצמה – אנחנו צריכים להפעיל את התהליך איכשהו. באפליקציה אמיתית בסביבת ייצור, היינו עוטפים את התהליך הזה בשרת אינטרנט או באפליקציית CLI. בזמן הפיתוח, אנחנו יכולים להשתמש ב-CLI של genkit כדי לפתח את התהליך ולבצע בו אופטימיזציה.
ממשק שורת הפקודה של genkit פותח כדי לעזור לנו לבדוק מודלים, הנחיות, תהליכים ורכיבים אחרים של Genkit. יש גם תמיכה מלאה במעקבים, וזה מאוד נוח כשרוצים להבין איך האפליקציה פועלת מאחורי הקלעים. כדי להפעיל את תהליך הברכה באמצעות ה-CLI של genkit, מריצים את הפקודה הבאה:
genkit start -- go run main.go
הפעולה הזו תפעיל את נקודות הקצה של Telemetry API ושל ממשק המשתמש למפתחים. אמור להופיע משהו כזה:
$ 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 בדפדפן כדי להפעיל את ממשק המשתמש למפתחים. אמור להופיע מסך כזה:

כדאי להקדיש זמן כדי להכיר את ממשק המשתמש למפתחים. אפשר להפעיל את התהליך "ברכת שלום" פעם אחת רק כדי לראות איך הוא עובד.
שימוש בתבניות לפרומפטים
אפשר לכתוב בתוך הקוד את הפרומפטים בקריאות למודל, כמו שעשינו בדוגמה הקודמת, אבל עדיף ליצור תבניות לפרומפט כדי לאחסן את כל הפרומפטים של האפליקציה במקום אחד. כך קל יותר למצוא אותן כשמתחזקים את הקוד, וגם אפשר להתנסות בהנחיות בלי קשר לתהליכים.
כדי להגדיר תבניות לפרומפטים, Genkit משתמש בפורמט dotprompt בקוד פתוח, שנשמר כקובצי *.prompt. קובץ .prompt מורכב משני חלקים:
- Frontmatter: בלוק YAML שמגדיר את המודל, את הפרמטרים של המודל ואת סכימות הקלט והפלט
- גוף: גוף ההנחיה עצמה, שאפשר ליצור לה תבנית באמצעות תחביר handlebars. לדוגמה, אם מגדירים קלט בשם
variable-name, אפשר להפנות אליו בגוף ההודעה בתור{{variable-name}}.
מבנה הספרייה של הפרויקט ייראה כך:
glowup/
├── main.go
└── prompts/
└── greeter.prompt
בואו נראה איך זה עובד בפועל. קודם כל, יוצרים את התיקייה שבה רוצים לשמור את ההנחיות:
mkdir -p prompts
אחר כך יוצרים קובץ greeter.prompt:
cloudshell edit prompts/greeter.prompt
ולהוסיף את התוכן הבא:
greeter.prompt

ההנחיה הזו מציגה כמה מהתכונות של שפת התבנית. קודם כל, אנחנו מציינים את המודל vertexai/gemini-2.5-flash ב-frontmatter. כדי לציין מודל, צריך להשתמש במינוח שמוגדר במסמכי התיעוד של הפלאגין הרלוונטי.
בקטע config אפשר להגדיר את הפרמטרים של המודל. אנחנו משתמשים בטמפרטורה 1.9 כדי לאפשר למודל להיות יצירתי יותר. טווח הטמפרטורה הוא בין 0 (פלט עקבי יותר) ל-2 (פלט יצירתי יותר). הפרמטר הזה ופרמטרים אחרים של המודל מתפרסמים בדרך כלל בגיליון המודל. לדוגמה, הנה גיליון המודל של gemini-2.5-flash.
בקטע הקלט אפשר לציין ארגומנטים להנחיה. במקרה הזה אנחנו מגדירים את השם כמחרוזת. אחרי ה-frontmatter מופיע גוף ההנחיה. הבלוק הראשון מגדיר את ההנחיה למערכת, והבלוק השני הוא ההנחיה למשתמש. כל האלמנטים האלה ביחד מאפשרים להשתמש בטכניקות יעילות מאוד לכתיבת הנחיות. כאן אפשר לעיין במסמכי התיעוד המלאים של 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

ההנחיה לשחזור דומה להנחיה של "הודעת הפתיחה", עם כמה הבדלים בולטים:
- גודל התמונה: המאפיין
imageSizeשלimageConfigהוא פרמטר ספציפי למודל Nano Banana Pro. היא מאפשרת לנו לציין את גודל הפלט כ-1K, 2K או 4K. - קלט מדיה: אנחנו משתמשים בתבנית
{{ media }}כדי להוסיף את התמונה להנחיה של המשתמש. השיטה הזו מאפשרת לנו לשלוח למודל הנחיות מולטי-מודאליות (טקסט + תמונה).
אתם יכולים לבדוק את ההנחיה הזו בממשק המשתמש למפתחים. אתם יכולים לשנות את ההנחיה כדי לראות איך השינוי משפיע על הפלט.
תהליך שחזור התמונה
עכשיו, כשההנחיה לשחזור מוכנה, אפשר ליצור את אפליקציית ה-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 כדי לחלץ את המידע שדרוש לנו כדי לשמור את הקובץ.
בדיקת תהליך השחזור
עכשיו הגיע הזמן להריץ את התהליך הזה עם תמונה אמיתית. אם אין לכם תמונות ישנות שצריך לשחזר, אתם יכולים לנסות את התמונה הזו מנחלת הכלל, שנלקחה מהאתר של ספריית הקונגרס:

זה הקישור הישיר לתמונה שצריך להעביר לתהליך: 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
והנה התמונה המשוחזרת והצבועה:

הצלחת!
6. פריסת glowUp כשירות אינטרנט
אם במקום אפליקציה של שורת פקודה אתם רוצים לחשוף את התהליכים בשירות אינטרנט, Genkit מספק דרך נוחה להמיר תהליכים לנקודות קצה באמצעות המתאם genkit.Handler. הקוד הבא רושם את התהליך glowUp כנקודת קצה (endpoint) של 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)
}
}
אתם יכולים להריץ את השירות הזה באופן מקומי או בענן. כדי להריץ באופן מקומי, אפשר פשוט להריץ את הקובץ ישירות כי התוכנית הושלמה, כך שלא צריך להפעיל אותה דרך ה-CLI של Genkit. לדוגמה:
go run main.go
מכיוון שזו פעולת חסימה, צריך להפעיל טרמינל שני כדי לבדוק אותה. הדרך הכי מהירה היא להשתמש בפקודה 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" של אפליקציית לקוח
כתיבת קוד באופן ידני היא מהנה, אבל יכולה להיות גם מאתגרת אם אף פעם לא עשיתם פרויקט מסוג מסוים. למזלנו, היום יש לנו סוכני תכנות שיכולים לעזור לנו לזרז את התהליך.
בשלב הזה, במקום לכתוב את הקוד בעצמנו, נבקש מ-Gemini CLI (או מסוכן ה-AI המועדף עליכם לכתיבת קוד) לעשות את העבודה בשבילנו. משתמשים בהנחיה הבאה:
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" באותו מודול. צופים בתהליך ומכוונים את Gemini להטמעה הנכונה, ומספקים לו את קוד השרת או קטעי הקוד לפי הצורך.
ניקוי אחרי ה-Lab
7. סיכום
מעולה! סיימתם לפתח אפליקציה לשחזור תמונות ברמת דיוק גבוהה באמצעות Genkit ו-Nano Banana Pro,
ב-Codelab הזה למדתם איך:
- הגדרת הסביבה לפיתוח אפליקציות Genkit Go
- יצירת הנחיות מולטי-מודאליות באמצעות
dotprompt - יצירת תהליכים ב-Genkit באמצעות תבניות לפרומפטים
- איך מעבדים תמונות באמצעות Nano Banana Pro
- אריזת תהליכי Genkit כאפליקציות של שורת הפקודה וכשירותי אינטרנט
- פריסת אפליקציות Genkit ב-Cloud Run
בסיום הבדיקה, חשוב לנקות את הסביבה.
השלבים הבאים
אתם יכולים להמשיך ללמוד על ידי עיון ב-Codelabs אחרים בפלטפורמה הזו, או לשפר את glowUp בעצמכם.
אם אתם צריכים רעיונות לשיפורים, אתם יכולים לנסות:
- הפעלת glowUp CLI כדי לשחזר קבצים מקומיים
- יצירת ממשק קצה לשירות האינטרנט של GlowUp
- זיהוי אוטומטי של סוג ה-MIME מהנתונים
- לבצע סוגים אחרים של עיבוד תמונות (מתמונה לציור, מציור לתמונה, משרטוט ליצירת אומנות סופית וכו').
- ליצור או לשפר את הלקוח (אולי לפתח אפליקציה לסמארטפון?)
האפשרויות הן אינסופיות. אם אתם חוששים לעשות את זה לבד, אתם תמיד יכולים להיעזר בסוכן תכנות כמו Gemini CLI או Antigravity. אם אתם רוצים לעשות יותר עם Genkit, סוכני תכנות בשילוב עם שרת Genkit MCP יכולים להקל עליכם מאוד.
לבסוף, אם אתם רוצים לגשת לקוד המלא של המאגר הזה, תוכלו למצוא אותו כאן.
בהצלחה!