Xây dựng ứng dụng khôi phục ảnh bằng Genkit Go và Nano Banana Pro

1. Giới thiệu

Trong lớp học lập trình này, chúng ta sẽ xây dựng GlowUp, một công cụ khôi phục ảnh. GlowUp sử dụng AI để khôi phục ảnh cũ, ảnh bị hỏng hoặc ảnh đen trắng, tạo ra ảnh màu 4K chất lượng cao. Bạn có thể dùng công cụ này để làm mới ảnh gia đình, hoặc thậm chí là khôi phục hình minh hoạ, bản vẽ, tranh vẽ hoặc các dạng hình ảnh khác bị hỏng.

Bạn sẽ sử dụng Genkit Go để triển khai logic ứng dụng và Gemini 3 Pro Image (còn gọi là Nano Banana Pro) làm mô hình để xử lý ảnh.

Điều kiện tiên quyết

  • Kiến thức cơ bản về ngôn ngữ lập trình Go
  • Kiến thức cơ bản về Google Cloud Console

Kiến thức bạn sẽ học được

  • Cách phát triển ứng dụng Genkit trong Go
  • Các khái niệm cơ bản về Genkit như luồng, trình bổ trợ và câu lệnh
  • Cách viết câu lệnh bằng mẫu Handlebars
  • Cách lấy dữ liệu hình ảnh từ phản hồi của mô hình

Bạn cần có

Bạn có thể thực hiện toàn bộ hội thảo này trong Google Cloud Shell, nơi có tất cả các phần phụ thuộc cần thiết (gcloud CLI, trình soạn thảo mã, Go, Gemini CLI) cài đặt trước.

Ngoài ra, nếu muốn làm việc trên máy của mình, bạn sẽ cần những điều sau:

  • Chuỗi công cụ Go (phiên bản 1.24 trở lên)
  • Node.js phiên bản 20 trở lên (cho CLI genkit)
  • Một thiết bị đầu cuối đã cài đặt gcloud CLI
  • Một IDE để chỉnh sửa mã, chẳng hạn như VS Code hoặc tương tự
  • Nên dùng: một tác nhân lập trình như Gemini CLI hoặc Antigravity

Công nghệ chính

Tại đây, bạn có thể tìm hiểu thêm thông tin về các công nghệ mà chúng tôi sẽ sử dụng:

  • Gemini Nano Banana Pro (Gemini 3 Pro Image): mô hình hỗ trợ quy trình khôi phục của chúng tôi
  • Genkit Go: bộ công cụ của chúng tôi để điều phối các lệnh gọi mô hình

2. Thiết lập môi trường

Bạn có thể chạy lớp học lập trình này trên máy của mình hoặc hoàn toàn trên đám mây. Ngay cả khi quyết định chạy mã trên máy, bạn vẫn cần có một dự án trên đám mây của Google Cloud để triển khai các thành phần phía máy chủ lên đám mây. Hãy làm theo các bước trong phần tiếp theo để tạo trang tổng quan.

Thiết lập môi trường tự học

  1. Đăng nhập vào Google Cloud Console rồi tạo một dự án mới hoặc sử dụng lại một dự án hiện có. Nếu chưa có tài khoản Gmail hoặc Google Workspace, bạn phải tạo một tài khoản.

295004821bab6a87.png37d264871000675d.png96d86d3d5655cdbe.png

  • Tên dự án là tên hiển thị cho những người tham gia dự án này. Đây là một chuỗi ký tự không được các API của Google sử dụng. Bạn có thể cập nhật thông tin này bất cứ lúc nào.
  • Mã dự án là duy nhất trong tất cả các dự án trên Google Cloud và không thể thay đổi (không thể thay đổi sau khi đã đặt). Cloud Console tự động tạo một chuỗi duy nhất; thường thì bạn không cần quan tâm chuỗi đó là gì. Trong hầu hết các lớp học lập trình, bạn sẽ cần tham chiếu Mã dự án (thường được xác định là PROJECT_ID). Nếu không thích mã được tạo, bạn có thể tạo một mã ngẫu nhiên khác. Ngoài ra, bạn có thể thử tên người dùng của riêng mình và xem tên đó có sẵn hay không. Bạn không thể thay đổi thông tin này sau bước này và thông tin này sẽ được giữ nguyên trong suốt thời gian diễn ra dự án.
  • Để bạn biết, có một giá trị thứ ba là Số dự án mà một số API sử dụng. Tìm hiểu thêm về cả ba giá trị này trong tài liệu.
  1. Tiếp theo, bạn cần bật tính năng thanh toán trong Cloud Console để sử dụng các tài nguyên/API của Cloud. Việc chạy qua lớp học lập trình này sẽ không tốn nhiều chi phí, nếu có. Để tắt các tài nguyên nhằm tránh phát sinh phí ngoài hướng dẫn này, bạn có thể xoá các tài nguyên đã tạo hoặc xoá dự án. Người dùng mới của Google Cloud đủ điều kiện tham gia chương trình Dùng thử miễn phí trị giá 300 USD.

Bắt đầu Cloud Shell

Mặc dù có thể vận hành Google Cloud từ xa bằng máy tính xách tay, nhưng trong lớp học lập trình này, bạn sẽ sử dụng Google Cloud Shell, một môi trường dòng lệnh chạy trên Cloud.

Trong Google Cloud Console, hãy nhấp vào biểu tượng Cloud Shell trên thanh công cụ trên cùng bên phải:

Kích hoạt Cloud Shell

Quá trình cấp phép và kết nối với môi trường chỉ mất vài phút. Khi quá trình này hoàn tất, bạn sẽ thấy kết quả như sau:

Ảnh chụp màn hình thiết bị đầu cuối Google Cloud Shell cho thấy môi trường đã kết nối

Máy ảo này được trang bị tất cả công cụ cho nhà phát triển mà bạn cần. Cloud Shell cung cấp thư mục gốc 5 GB cố định và chạy trên Google Cloud, giúp cải thiện đáng kể hiệu suất mạng và khả năng xác thực. Bạn có thể thực hiện tất cả công việc trong lớp học lập trình này bằng trình duyệt. Bạn không cần cài đặt gì cả.

3. Thiết lập dự án

Tạo dự án

Trước tiên, chúng ta cần tạo một thư mục mới cho dự án và khởi chạy mô-đun Go. Trong dòng lệnh, hãy chạy các lệnh sau:

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

Cài đặt Genkit CLI

Bây giờ, chúng ta cần cài đặt Genkit CLI. Nhờ đó, bạn có thể sử dụng các công cụ cho nhà phát triển tại địa phương, bao gồm cả Giao diện người dùng cho nhà phát triển. Trong cửa sổ dòng lệnh, hãy nhập:

curl -sL cli.genkit.dev | bash

Định cấu hình biến môi trường

Đảm bảo bạn đã thiết lập đúng thông tin đăng nhập Google Cloud. Vị trí phải là global khi sử dụng các mô hình Gemini 3 Pro Preview (Nano Banana Pro là một trong số đó).

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

Chạy lệnh sau trong chế độ shell để bật Vertex AI API cho dự án hiện tại:

gcloud services enable aiplatform.googleapis.com

Nếu đang chạy trên máy cục bộ (không phải trên CloudShell), bạn cần xác thực bằng lệnh gcloud:

gcloud auth application-default login

4. Tạo ứng dụng Genkit đầu tiên

Genkit là một khung nguồn mở được thiết kế để giúp nhà phát triển xây dựng, triển khai và giám sát các ứng dụng dựa trên AI sẵn sàng cho môi trường thực tế. Trong phần này, chúng ta sẽ tạo một ứng dụng "Hello World" đơn giản để giúp bạn làm quen với khung này trước khi tìm hiểu sâu về logic khôi phục ảnh.

Thuật ngữ Genkit

Trước khi bắt đầu làm việc với Genkit, bạn cần hiểu một số thuật ngữ chính:

  • Trình bổ trợ: dùng để mở rộng khả năng của Genkit. Ngoài ra, bạn có thể đăng ký các mô hình AI thông qua trình bổ trợ để hỗ trợ ứng dụng của mình.
  • Flow: thành phần cấu trúc chính của Genkit. Một quy trình thông thường sẽ nhận dữ liệu đầu vào, xử lý dữ liệu đó và trả về kết quả đầu ra. Bạn không nhất thiết phải sử dụng mô hình, nhưng hầu hết thời gian bạn sẽ sử dụng mô hình trong luồng của mình.
  • Câu lệnh: các mẫu tương tác được lưu trữ ở định dạng dotprompt (được lưu dưới dạng tệp *.prompt). Những tệp này không chỉ chứa hướng dẫn về mô hình mà còn chứa các cấu hình như tên mô hình, tham số mô hình, dữ liệu đầu vào và đầu ra.

Đang kết nối với các mô hình AI

Genkit sử dụng trình bổ trợ để kết nối mã của bạn với các nhà cung cấp mô hình. Có các trình bổ trợ cho tất cả nhà cung cấp mô hình lớn, bao gồm cả Google, Anthropic và OpenAI. Bạn cũng có thể sử dụng trình bổ trợ để kết nối với các mô hình cục bộ (ví dụ: sử dụng Ollama) hoặc để mở rộng khả năng của Genkit (ví dụ: kết nối với máy chủ MCP).

Để truy cập vào các mô hình của Google, bạn nên sử dụng trình bổ trợ googlegenai. Thư viện này hỗ trợ hai phần phụ trợ:

  • AI của Google: Phù hợp nhất để tạo nguyên mẫu. Sử dụng khoá API.
  • Vertex AI (Google Cloud): Nên dùng cho môi trường thực tế. Sử dụng mã dự án và vị trí.

Trong lớp học lập trình này, chúng ta sẽ sử dụng phương thức xác thực Vertex AI tham chiếu đến dự án mà bạn đã tạo ở đầu lớp học lập trình.

Tạo quy trình chào mừng

Trước khi tìm hiểu sâu hơn về quy trình khôi phục ảnh của Glow Up, hãy xây dựng một quy trình cơ bản để làm quen với các khái niệm và đảm bảo rằng chế độ thiết lập của chúng ta đang hoạt động đúng cách.

Luồng là một hàm Genkit đặc biệt, gói logic AI của bạn để cung cấp:

  • Đầu vào và đầu ra an toàn về kiểu: Xác định giản đồ bằng cách sử dụng cấu trúc Go để xác thực tĩnh và xác thực trong thời gian chạy
  • Hỗ trợ truyền trực tuyến: Truyền trực tuyến phản hồi một phần hoặc dữ liệu tuỳ chỉnh
  • Tích hợp giao diện người dùng dành cho nhà phát triển: Kiểm thử và gỡ lỗi các luồng bằng dấu vết trực quan
  • Dễ dàng triển khai: Triển khai dưới dạng điểm cuối HTTP cho mọi nền tảng

Mở IDE và tạo tệp main.go trong thư mục dự án. Nếu đang dùng cloudshell, bạn có thể sử dụng lệnh sau:

cloudshell edit main.go

Sau đó, hãy thêm mã sau:

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

Lưu tệp rồi chạy go mod tidy để cập nhật các phần phụ thuộc:

go mod tidy

Đoạn mã trên khởi chạy Genkit bằng trình bổ trợ VertexAI, xác định một luồng có tên là "greeter" rồi chờ mãi trên <-ctx.Done(). Chúng ta sẽ giữ lại quá trình thực thi để chương trình này không kết thúc ngay lập tức, vì chúng ta không đưa ra bất kỳ hướng dẫn nào để thực sự thực thi luồng.

Điều này có nghĩa là nếu bạn chạy chương trình này như hiện tại, thì chương trình sẽ không tự làm được gì nhiều – chúng ta cần gọi luồng bằng cách nào đó. Mặc dù trong một ứng dụng thực tế, chúng ta sẽ gói quy trình này trong một máy chủ web hoặc ứng dụng CLI, nhưng trong thời gian phát triển, chúng ta có thể sử dụng CLI genkit để giúp phát triển và tối ưu hoá quy trình.

genkit CLI được phát triển để giúp chúng tôi thử nghiệm các mô hình, câu lệnh, luồng và các thành phần khác của ngăn xếp Genkit. Công cụ này cũng hỗ trợ đầy đủ cho các dấu vết, rất thuận tiện khi bạn muốn tìm hiểu cách ứng dụng hoạt động trong nền. Để chạy quy trình chào mừng bằng CLI genkit, hãy chạy lệnh sau:

genkit start -- go run main.go

Thao tác này sẽ khởi động Telemetry API và các điểm cuối của giao diện người dùng dành cho nhà phát triển. Bạn sẽ thấy như sau:

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

Nếu bạn mở localhost:4000 trên trình duyệt để chạy Dev-UI. Bạn sẽ thấy một màn hình như sau:

93d9bd9e1bd6627d.png

Hãy dành thời gian khám phá Giao diện người dùng cho nhà phát triển. Có thể kích hoạt quy trình "lời chào" một lần để xem cách hoạt động.

Sử dụng mẫu câu lệnh

Mặc dù bạn có thể cố định giá trị trong mã cho câu lệnh trong các lệnh gọi mô hình như chúng ta đã làm trong ví dụ trước, nhưng cách tốt hơn là tạo mẫu câu lệnh để lưu trữ tất cả câu lệnh của ứng dụng theo cách tập trung. Việc này không chỉ giúp bạn dễ dàng tìm thấy câu lệnh khi bảo trì mã mà còn cho phép bạn thử nghiệm câu lệnh độc lập với các luồng.

Để xác định mẫu câu lệnh, Genkit sử dụng định dạng dotprompt nguồn mở, được lưu dưới dạng tệp *.prompt. Tệp .prompt bao gồm hai phần:

  1. Frontmatter: Một khối YAML xác định mô hình, tham số mô hình và cả giản đồ đầu vào và đầu ra
  2. Nội dung: Nội dung của câu lệnh, có thể được tạo mẫu bằng cú pháp "handlebars". Ví dụ: nếu bạn xác định một dữ liệu đầu vào có tên là variable-name, bạn có thể tham chiếu dữ liệu đó trong phần nội dung dưới dạng {{variable-name}}.

Cấu trúc thư mục của dự án sẽ có dạng như sau:

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

Hãy xem ví dụ thực tế. Trước tiên, hãy tạo thư mục để lưu trữ câu lệnh:

mkdir -p prompts

Sau đó, hãy tạo một tệp greeter.prompt:

cloudshell edit prompts/greeter.prompt

Và chèn nội dung sau:

greeter.prompt

ec9fc82a98604123.png

Câu lệnh này minh hoạ một số tính năng của ngôn ngữ mẫu. Trước tiên, chúng ta chỉ định mô hình vertexai/gemini-2.5-flash trong phần đầu. Để chỉ định một mô hình, bạn cần sử dụng danh pháp được xác định trong tài liệu về trình bổ trợ tương ứng.

Phần config cho phép chúng ta định cấu hình các tham số của mô hình. Chúng tôi đang sử dụng nhiệt độ 1,9 để cho phép mô hình sáng tạo hơn. Nhiệt độ nằm trong khoảng từ 0 (kết quả nhất quán hơn) đến 2 (kết quả sáng tạo hơn). Tham số này và các tham số khác của mô hình thường được công bố trong bảng thông tin của mô hình. Ví dụ: sau đây là bảng thông tin mô hình cho gemini-2.5-flash.

Phần đầu vào cho phép chúng ta chỉ định các đối số cho câu lệnh. Trong trường hợp này, chúng ta sẽ xác định tên dưới dạng chuỗi. Sau phần đầu, chúng ta có phần thân câu lệnh. Khối đầu tiên ở đây xác định câu lệnh hệ thống và khối thứ hai là câu lệnh của người dùng. Tất cả các yếu tố này kết hợp với nhau sẽ tạo nên một số kỹ thuật viết câu lệnh rất hiệu quả. Bạn có thể xem toàn bộ tài liệu về dotprompt tại đây.

Bây giờ, hãy điều chỉnh quy trình greeter để sử dụng câu lệnh chúng ta vừa tạo:

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

Hãy thử chạy quy trình từ dòng lệnh, có và không có tên để xem sự khác biệt. Chạy mà không có tên:

genkit flow:run greeter

Ví dụ về đầu ra:

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

Và có tên:

genkit flow:run greeter '"Daniela"'

Ví dụ về đầu ra:

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

Bạn có thể thấy mẫu này hoạt động như mong đợi. Chúng tôi đã sẵn sàng đưa dự án này lên một tầm cao mới!

5. Đang khôi phục hình ảnh bằng Nano Banana Pro

Lời nhắc khôi phục

Giờ đây, khi đã quen thuộc với các thành phần của Genkit, bạn có thể tạo câu lệnh khôi phục ảnh.

Tạo một tệp có tên là glowup.prompt trong thư mục câu lệnh rồi dán nội dung sau vào tệp đó:

glowup.prompt

fd0f1551466c8138.png

Câu lệnh khôi phục có cùng mẫu với câu lệnh "chào mừng", chỉ có một vài điểm khác biệt đáng chú ý:

  • Kích thước hình ảnh: thuộc tính imageSize của imageConfig là một tham số dành riêng cho mô hình Nano Banana Pro. Công cụ này cho phép chúng ta chỉ định kích thước đầu ra là 1K, 2K hoặc 4K.
  • Dữ liệu đầu vào đa phương tiện: chúng ta đang sử dụng mẫu {{ media }} để chèn ảnh vào câu lệnh của người dùng. Kỹ thuật này cho phép chúng ta gửi câu lệnh đa phương thức đến mô hình (văn bản + hình ảnh).

Bạn có thể kiểm thử câu lệnh này trên Giao diện người dùng cho nhà phát triển. Bạn có thể điều chỉnh câu lệnh này để xem kết quả thay đổi như thế nào.

Quy trình khôi phục hình ảnh

Khi lời nhắc khôi phục đã sẵn sàng, giờ hãy xây dựng ứng dụng CLI. Thay thế nội dung của main.go bằng mã dưới đây:

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
}

Mã này có cấu trúc rất giống với quy trình greeter, nhưng lần này được điều chỉnh để chạy dưới dạng một ứng dụng CLI độc lập. Thay vì chặn vĩnh viễn, nó sẽ chạy luồng glowUp, giải mã kết quả và lưu dữ liệu nhị phân thu được vào ổ đĩa.

Chúng ta cần giải mã kết quả đầu ra vì mô hình trả về dữ liệu hình ảnh ở định dạng sau:

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

Trong hàm decode, bạn có thể thấy chúng ta đang sử dụng thao tác chuỗi để phân tách loại MIME và các phần hình ảnh được mã hoá. Sau đó, chúng ta sử dụng hàm mime.ExtensionByType và base64.DecodeString để trích xuất thông tin cần thiết nhằm lưu tệp.

Kiểm thử quy trình khôi phục

Giờ là lúc chạy quy trình này bằng một bức ảnh thực tế! Nếu không có sẵn ảnh cũ cần phục hồi, bạn có thể thử với bức ảnh thuộc phạm vi công cộng này được lấy từ trang web của Thư viện Quốc hội:

f0fc83a81e88052a.png

Dưới đây là đường liên kết trực tiếp đến bức ảnh để chuyển bức ảnh đó vào quy trình: 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

Và đây là kết quả sau khi khôi phục và tô màu:

5ed7bfcf6d26313c.png

Thành công!

6. Triển khai glowUp dưới dạng dịch vụ web

Nếu thay vì một ứng dụng dòng lệnh, bạn muốn hiển thị các luồng của mình trong một dịch vụ web, thì Genkit sẽ cung cấp một cách thuận tiện để chuyển đổi các luồng thành điểm cuối bằng bộ chuyển đổi genkit.Handler. Mã bên dưới đăng ký luồng glowUp làm điểm cuối glowUp bằng genkit.Handler.

Bạn có thể hiển thị các luồng này bằng một máy chủ HTTP thông thường như cách bạn thường làm bằng gói http trong thư viện chuẩn, nhưng Genkit cũng cung cấp một trình bổ trợ server giúp xử lý một số mã nguyên mẫu phổ biến của máy chủ, chẳng hạn như xử lý tín hiệu tắt một cách linh hoạt.

Thay thế nội dung của main.go bằng mã bên dưới để tạo máy chủ web.

package main

import (
        "context"
        "errors"
        "fmt"
        "log"
        "net/http"
        "os"

        "github.com/firebase/genkit/go/ai"
        "github.com/firebase/genkit/go/genkit"
        "github.com/firebase/genkit/go/plugins/googlegenai"
        "github.com/firebase/genkit/go/plugins/server"
)

func main() {
        ctx := context.Background()

        PORT := os.Getenv("PORT")
        if PORT == "" {
                PORT = "8080"
        }

        listenAddr := ":" + PORT

        // Initialize Genkit with the Vertex AI plugin
        g := genkit.Init(ctx,
                genkit.WithPlugins(&googlegenai.VertexAI{}),
        )

        // Input schema for the glowUp flow
        type Input struct {
                URL         string `json:"url,omitempty"`
                ContentType string `json:"contentType,omitempty"`
        }

        genkit.DefineFlow(g, "glowUp", func(ctx context.Context, input Input) (string, error) {
                prompt := genkit.LookupPrompt(g, "glowup")
                if prompt == nil {
                        return "", errors.New("prompt 'glowup' not found")
                }

                resp, err := prompt.Execute(ctx, ai.WithInput(input))
                if err != nil {
                        return "", fmt.Errorf("generation failed: %w", err)
                }

                return resp.Media(), nil
        })

        log.Printf("GlowUp Flow Server started. Listening on %s", listenAddr)
        mux := http.NewServeMux()
        for _, flow := range genkit.ListFlows(g) {
                mux.HandleFunc("POST /"+flow.Name(), genkit.Handler(flow))
        }

        if err := server.Start(ctx, listenAddr, mux); err != nil {
                // Check if the error is due to context cancellation
                if ctx.Err() != nil {
                        log.Println("GlowUp server shutting down gracefully...")
                        return
                }
                log.Fatal(err)
        }
}

Bạn có thể chạy dịch vụ này trên máy hoặc trên đám mây. Để chạy cục bộ, bạn chỉ cần chạy trực tiếp tệp vì chương trình hiện đã hoàn tất, nên chúng ta không cần chạy chương trình đó thông qua CLI genkit. Ví dụ:

go run main.go

Vì đây là thao tác chặn, nên bạn cần khởi chạy một thiết bị đầu cuối thứ hai để kiểm thử. Cách nhanh nhất là sử dụng lệnh curl:

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

Vì đây là phản hồi của máy chủ nên chúng ta cần giải mã hình ảnh base64:

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

Triển khai dịch vụ web lên Cloud Run

Máy chủ này "hoạt động trên máy của tôi" là được, nhưng trong trường hợp lý tưởng, chúng ta sẽ triển khai máy chủ này ở một nơi khác mà tất cả người dùng đều có thể truy cập. Một trong những cách thuận tiện nhất để triển khai các dịch vụ như thế này là sử dụng tính năng triển khai từ nguồn của Cloud Run. Với tính năng này, bạn thậm chí không cần phải tự tạo vùng chứa, mọi thứ đều được tự động hoá.

Để triển khai dịch vụ này cho Cloud Run bằng cách triển khai từ nguồn, hãy thực thi lệnh sau (thay mã dự án bằng mã của riêng bạn):

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

Quá trình triển khai có thể mất vài phút để hoàn tất. Sau khi hoàn tất, bạn có thể kiểm thử điểm cuối bằng cách gửi một yêu cầu khác thông qua 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

Một lần nữa, chúng ta cần giải mã hình ảnh base64:

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

Giờ đây, chúng ta đã có một máy chủ web khôi phục ảnh hoạt động hoàn chỉnh!

Không bắt buộc: "Lập trình theo cảm hứng" cho một ứng dụng khách

Viết mã thủ công rất thú vị nhưng cũng có thể gặp nhiều khó khăn nếu bạn chưa từng thực hiện một loại dự án nhất định nào đó trước đây. May mắn là hiện nay chúng ta có các tác nhân lập trình có thể giúp đẩy nhanh quy trình này.

Trong bước này, thay vì tự viết mã, chúng ta sẽ yêu cầu Gemini CLI (hoặc tác nhân lập trình mà bạn yêu thích) làm việc đó cho chúng ta. Sử dụng câu lệnh sau:

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

Tác nhân có thể cần sắp xếp lại các tệp một chút vì chúng ta không thể có hai hàm "main" trong cùng một mô-đun. Hãy theo dõi quá trình hoạt động và hướng dẫn Gemini triển khai đúng cách, cung cấp mã máy chủ hoặc đoạn mã nếu cần.

Dọn dẹp sau khi thực hành

7. Kết luận

Xin chúc mừng! Bạn đã xây dựng thành công một ứng dụng khôi phục ảnh có độ trung thực cao bằng Genkit và Nano Banana Pro,

Trong lớp học lập trình này, bạn đã tìm hiểu cách:

  • Định cấu hình môi trường để phát triển ứng dụng Genkit Go
  • Tạo câu lệnh đa phương thức bằng dotprompt
  • Tạo quy trình Genkit bằng mẫu câu lệnh
  • Dùng Nano Banana Pro để xử lý hình ảnh
  • Đóng gói các luồng Genkit dưới dạng ứng dụng dòng lệnh và dịch vụ web
  • Triển khai ứng dụng Genkit lên Cloud Run

Sau khi kiểm thử xong, hãy nhớ dọn dẹp môi trường.

Các bước tiếp theo

Bạn có thể tiếp tục hành trình học tập bằng cách khám phá các lớp học lập trình khác trên nền tảng này hoặc tự cải thiện glowUp.

Nếu cần một số ý tưởng để cải thiện, bạn có thể thử:

  • Bật glowUp CLI để khôi phục tệp trên máy
  • Tạo giao diện người dùng cho dịch vụ web GlowUp
  • Tự động phát hiện loại MIME từ dữ liệu
  • Thực hiện các loại xử lý hình ảnh khác (từ ảnh sang bản vẽ, từ bản vẽ sang ảnh, từ bản phác thảo sang tác phẩm nghệ thuật hoàn chỉnh, v.v.
  • Tạo hoặc cải thiện ứng dụng (có thể là xây dựng một ứng dụng cho điện thoại thông minh?)

Bạn có vô số lựa chọn! Nếu cảm thấy hơi e ngại khi tự mình thực hiện, bạn luôn có thể nhờ đến sự trợ giúp của một tác nhân lập trình như Gemini CLI hoặc Antigravity. Và nếu bạn muốn làm được nhiều việc hơn với Genkit, thì các tác nhân lập trình kết hợp với Máy chủ MCP Genkit có thể giúp bạn làm việc dễ dàng hơn nhiều.

Cuối cùng, nếu muốn truy cập vào mã đầy đủ cho kho lưu trữ này, bạn có thể tìm thấy mã đó tại đây.

Chúc bạn lập trình vui vẻ!