Hướng Dẫn Sử Dụng Google Nano Banana 2 API

Xây dựng ứng dụng với tính năng tạo ảnh AI cứ như phép thuật—cho đến khi bạn vấp phải bức tường tài liệu API phức tạp, những cơn đau đầu về xác thực và ác mộng gỡ lỗi. Bạn đã thấy những gì Nano Banana 2 có thể làm: những hình ảnh tuyệt đẹp được tạo ra từ văn bản mô tả (text prompts), đầu ra chất lượng Pro với tốc độ Flash, và các tính năng như tính nhất quán của đối tượng (subject consistency) giúp quy trình làm việc với nhiều hình ảnh trở nên khả thi. Nhưng việc thực sự tích hợp nó vào mã nguồn của bạn? Đó là lúc hầu hết các nhà phát triển bị mắc kẹt.

Bạn có thể đã cố gắng tìm hiểu tài liệu của Google, ghép nối các luồng xác thực và kiểm tra thủ công các yêu cầu trong CLI. Có thể bạn đã đốt hết hạn mức API để gỡ lỗi các yêu cầu bị lỗi định dạng hoặc tự hỏi tại sao hình ảnh của bạn luôn bị mờ. Sự thật là, việc tích hợp bất kỳ API mới nào, đặc biệt là một API mạnh mẽ như Nano Banana 2, đòi hỏi nhiều hơn là chỉ đọc tài liệu. Bạn cần một quy trình làm việc cho phép bạn kiểm tra nhanh chóng, lặp lại các mô tả (prompts) và quản lý các lệnh gọi API của mình một cách hiệu quả.

Trong hướng dẫn này, chúng ta sẽ xem xét mọi thứ bạn cần để tích hợp Nano Banana 2 vào các ứng dụng của mình, từ việc thiết lập dự án Google Cloud đến viết mã sẵn sàng cho sản xuất bằng Python và JavaScript. Nhưng đây là điều làm cho hướng dẫn này khác biệt: chúng tôi sẽ chỉ cho bạn cách kiểm tra và gỡ lỗi từng bước bằng Apidog, để bạn không chỉ sao chép mã, mà còn xây dựng một quy trình làm việc mà bạn có thể duy trì và mở rộng.

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

Trước khi bắt đầu, hãy đảm bảo bạn có:

• Tài khoản Google Cloud (hoặc đăng ký tại cloud.google.com)
• Hiểu biết cơ bản về REST API
• Python 3.8+ hoặc Node.js 18+ đã được cài đặt
• Một ứng dụng khách API (API client) như Apidog để kiểm thử

Hướng dẫn này giả định bạn đã quen thuộc với việc thực hiện các yêu cầu HTTP và xử lý dữ liệu JSON. Nếu bạn mới làm quen với API, hãy xem Hướng dẫn kiểm thử API của chúng tôi để nắm vững các kiến thức cơ bản.

Thiết lập dự án Google Cloud của bạn

Để sử dụng Nano Banana 2 API, bạn cần một dự án Google Cloud đã bật API Generative Language.

Bước 1: Tạo dự án mới

1. Truy cập Google Cloud Console
2. Nhấp vào "Chọn một dự án" (Select a project) → "Dự án mới" (New Project)
3. Nhập tên dự án (ví dụ: "nano-banana-image-gen")
4. Nhấp vào "Tạo" (Create)
5. Chờ dự án được tạo

Bước 2: Cấu hình quyền truy cập API

1. Truy cập "API & Dịch vụ" (APIs & Services) → "Thông tin xác thực" (Credentials)
2. Nhấp vào "Tạo thông tin xác thực" (Create Credentials) → "Khóa API" (API Key)
3. Sao chép khóa API của bạn (bạn sẽ cần nó sau này)

Mẹo chuyên nghiệp:

Lấy khóa API của bạn

Có hai cách để có quyền truy cập API:

Tùy chọn 1: Google Cloud Console (Được khuyến nghị cho môi trường sản xuất)

Thực hiện theo các bước trên—khóa API bạn đã tạo là thông tin xác thực truy cập của bạn.

Tùy chọn 2: Google AI Studio (Được khuyến nghị cho môi trường phát triển)

1. Truy cập Google AI Studio
2. Đăng nhập bằng tài khoản Google của bạn
3. Nhấp vào "Lấy khóa API" (Get API Key) trong điều hướng
4. Nhấp vào "Tạo khóa API" (Create API Key) (hoặc chọn một dự án hiện có)
5. Sao chép khóa API của bạn

Khóa AI Studio rất tốt cho việc phát triển và thử nghiệm. Đối với môi trường sản xuất, hãy sử dụng khóa Google Cloud Console để quản lý và bảo mật tốt hơn.

Yêu cầu API đầu tiên của bạn

Hãy thực hiện một yêu cầu tạo ảnh đơn giản để xác minh mọi thứ hoạt động.

Sử dụng cURL

curl -X POST \
  "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-exp-image-generation:predict?key=YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A cute banana character wearing sunglasses, fun cartoon style",
    "number_of_images": 1
  }'

Tìm hiểu phản hồi

{
  "predictions": [
    {
      "image": {
        "mimeType": "image/png",
        "data": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=="
      },
      "generatedImageId": "img_abc123xyz",
      "metadata": {
        "prompt": "A cute banana character wearing sunglasses, fun cartoon style",
        "seed": 12345,
        "finishReason": "SUCCESS"
      }
    }
  ],
  "metadata": {
    "modelVersion": "gemini-3.1-flash-image-preview",
    "processingTimeMs": 1250,
    "contentAuthenticity": {
      "synthID": "enabled",
      "c2pa": "enabled"
    }
  }
}

Trường data chứa một hình ảnh PNG được mã hóa base64. Bạn sẽ cần giải mã nó để lưu hoặc hiển thị hình ảnh.

Tích hợp Python

Dưới đây là cách tích hợp Nano Banana 2 vào các ứng dụng Python của bạn:

Cài đặt thư viện máy khách

pip install google-generativeai

Tạo ảnh cơ bản

import google.generativeai as genai
import base64
import os

# Cấu hình API với khóa của bạn
genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))

# Tạo model
model = genai.GenerativeModel("gemini-3.1-flash-image-preview")

# Tạo một hình ảnh
response = model.generate_images(
    prompt="A modern minimalist office with natural lighting, indoor plants, standing desk, 4k quality",
    number_of_images=1
)

# Lưu hình ảnh
if response.generated_images:
    image_data = response.generated_images[0].image_bytes
    with open("output_image.png", "wb") as f:
        f.write(image_data)
    print("Image saved to output_image.png")

Tạo ảnh nâng cao với các tham số

import google.generativeai as genai
from PIL import Image
import io

genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))

model = genai.GenerativeModel("gemini-3.1-flash-image-preview")

# Tạo với các tham số nâng cao
response = model.generate_images(
    prompt="A futuristic cityscape at night with neon lights, flying cars, cyberpunk aesthetic",
    number_of_images=1,
    aspect_ratio="16:9",
    negative_prompt="blurry, low quality, distorted, ugly",
    safety_filter_level="block_medium_and_above"
)

# Xử lý phản hồi
for idx, generated_image in enumerate(response.generated_images):
    # Chuyển đổi sang PIL Image
    image = Image.open(io.BytesIO(generated_image.image_bytes))

    # Lưu với tên tùy chỉnh
    image.save(f"generated_image_{idx}.png")

    # Truy cập siêu dữ liệu (metadata)
    print(f"Image {idx}: {generated_image.finish_reason}")
    print(f"Seed: {generated_image.seed}")

Tạo ảnh hàng loạt

import google.generativeai as genai
import os

genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))
model = genai.GenerativeModel("gemini-3.1-flash-image-preview")

# Tạo nhiều hình ảnh cùng một lúc
prompts = [
    "A red sports car on a mountain road",
    "A cozy coffee shop interior",
    "A minimalist bedroom design",
    "A tropical beach sunset"
]

# Tạo tất cả hình ảnh
for idx, prompt in enumerate(prompts):
    response = model.generate_images(
        prompt=prompt,
        number_of_images=1,
        aspect_ratio="16:9"
    )

    if response.generated_images:
        image_data = response.generated_images[0].image_bytes
        with open(f"image_{idx + 1}.png", "wb") as f:
            f.write(image_data)
        print(f"Generated: image_{idx + 1}.png")

Ví dụ về tính nhất quán của nhân vật

import google.generativeai as genai

genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))
model = genai.GenerativeModel("gemini-3.1-flash-image-preview")

# Mô tả nhân vật cơ bản
base_character = "A friendly cartoon robot with round body, blue eyes, antenna on head, white and light blue color scheme"

# Tạo nhân vật cơ bản (lưu ý seed để nhất quán)
response1 = model.generate_images(
    prompt=base_character + ", front view, standing pose",
    number_of_images=1,
    seed=42  # Quan trọng: ghi lại seed này
)

base_seed = response1.generated_images[0].seed
print(f"Base character seed: {base_seed}")

# Tạo các biến thể sử dụng cùng một seed
poses = [
    "sitting pose",
    "waving hand",
    "holding a ball",
    "walking"
]

for pose in poses:
    response = model.generate_images(
        prompt=f"{base_character}, {pose}, same character as seed {base_seed}",
        number_of_images=1,
        seed=base_seed  # Cùng seed duy trì tính nhất quán
    )

    if response.generated_images:
        filename = f"robot_{pose.replace(' ', '_')}.png"
        with open(filename, "wb") as f:
            f.write(response.generated_images[0].image_bytes)
        print(f"Generated: {filename}")

Tích hợp JavaScript/Node.js

Cài đặt thư viện máy khách

npm install @google/generative-ai

Tạo ảnh cơ bản

const { GoogleGenerativeAI } = require("@google/generative-ai");
const fs = require("fs");
const path = require("path");

// Khởi tạo với khóa API
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);

async function generateImage() {
  // Lấy model
  const model = genAI.getGenerativeModel({
    model: "gemini-3.1-flash-image-preview",
  });

  // Tạo ảnh
  const result = await model.generateImages({
    prompt: "A beautiful sunset over the ocean with palm trees silhouette",
    numberOfImages: 1,
  });

  // Xử lý phản hồi
  if (result.generatedImages && result.generatedImages.length > 0) {
    const imageData = result.generatedImages[0].imageBytes;

    // Lưu vào file
    fs.writeFileSync("sunset.png", Buffer.from(imageData, "base64"));
    console.log("Image saved to sunset.png");

    // Ghi nhật ký siêu dữ liệu
    console.log("Seed:", result.generatedImages[0].seed);
    console.log("Finish Reason:", result.generatedImages[0].finishReason);
  }
}

generateImage().catch(console.error);

Xử lý phản hồi Base64

const { GoogleGenerativeAI } = require("@google/generative-ai");
const fs = require("fs");

const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);

async function generateAndProcessImage() {
  const model = genAI.getGenerativeModel({
    model: "gemini-3.1-flash-image-preview",
  });

  const result = await model.generateImages({
    prompt: "Professional headshot of a person in business attire, studio lighting",
    numberOfImages: 1,
    aspectRatio: "1:1",
    resolution: "1024x1024"
  });

  const generatedImage = result.generatedImages[0];

  // Giải mã base64
  const imageBuffer = Buffer.from(generatedImage.imageBytes, "base64");

  // Lưu với siêu dữ liệu trong tên tệp
  const filename = `portrait_${generatedImage.seed}.png`;
  fs.writeFileSync(filename, imageBuffer);

  return {
    filename,
    seed: generatedImage.seed,
    finishReason: generatedImage.finishReason
  };
}

generateAndProcessImage()
  .then(info => console.log("Generated:", info))
  .catch(err => console.error("Error:", err));

Ví dụ về Express.js REST API

const express = require("express");
const { GoogleGenerativeAI } = require("@google/generative-ai");
const multer = require("multer");
const fs = require("fs");

const app = express();
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);

app.use(express.json());

// Điểm cuối tạo ảnh
app.post("/api/generate", async (req, res) => {
  try {
    const { prompt, aspect_ratio, negative_prompt, number_of_images } = req.body;

    const model = genAI.getGenerativeModel({
      model: "gemini-2.0-flash-exp-image-generation",
    });

    const result = await model.generateImages({
      prompt,
      numberOfImages: number_of_images || 1,
      aspectRatio: aspect_ratio || "1:1",
      negativePrompt: negative_prompt
    });

    // Chuyển đổi hình ảnh sang base64 để phản hồi
    const images = result.generatedImages.map((img, idx) => ({
      id: idx,
      seed: img.seed,
      finishReason: img.finishReason,
      data: img.imageBytes // Mã hóa Base64
    }));

    res.json({
      success: true,
      images,
      metadata: {
        modelVersion: result.response?.metadata?.modelVersion,
        processingTimeMs: result.response?.metadata?.processingTimeMs
      }
    });
  } catch (error) {
    console.error("Generation error:", error);
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

// Điểm cuối tạo hàng loạt
app.post("/api/generate/batch", async (req, res) => {
  try {
    const { prompts } = req.body;
    const model = genAI.getGenerativeModel({
      model: "gemini-3.1-flash-image-preview",
    });

    const results = [];

    for (const prompt of prompts) {
      const result = await model.generateImages({
        prompt,
        numberOfImages: 1
      });

      results.push({
        prompt,
        seed: result.generatedImages[0]?.seed,
        success: !!result.generatedImages[0]
      });
    }

    res.json({ success: true, results });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

app.listen(3000, () => {
  console.log("Server running on port 3000");
});

Các tham số nâng cao

Nano Banana 2 hỗ trợ nhiều tham số khác nhau để tinh chỉnh việc tạo ảnh của bạn:

Tham chiếu tham số

Các tùy chọn độ phân giải

# Các độ phân giải có sẵn
resolutions = [
    "512x512",    # Ảnh thumbnail, mạng xã hội
    "768x768",    # Ảnh web nhỏ
    "1024x1024",  # Tiêu chuẩn vuông
    "1024x768",   # Phong cảnh 4:3
    "1280x720",   # HD ready
    "1920x1080",  # Full HD
    "2048x2048",  # Chất lượng cao
    "3840x2160"   # 4K
]

# Sử dụng độ phân giải cụ thể
response = model.generate_images(
    prompt="Professional product photography of a watch",
    resolution="2048x2048"
)

Tỷ lệ khung hình

aspect_ratios = [
    "1:1",    # Hình vuông (Bài đăng Instagram)
    "4:3",    # Ảnh tiêu chuẩn
    "16:9",   # Phong cảnh (YouTube, web)
    "9:16",   # Chân dung (Stories, TikTok)
    "21:9",   # Siêu rộng
    "3:4",    # Tiêu chuẩn chân dung
    "2:3"     # Ảnh chân dung
]

# Sử dụng tỷ lệ khung hình cụ thể
response = model.generate_images(
    prompt="Modern office interior design",
    aspect_ratio="16:9"
)

Xử lý phản hồi

Phân tích cấu trúc phản hồi

import google.generativeai as genai

genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))
model = genai.GenerativeModel("gemini-3.1-flash-image-preview")

response = model.generate_images(
    prompt="A fantasy castle on a mountain",
    number_of_images=2
)

# Truy cập các dự đoán (hình ảnh được tạo)
for idx, image in enumerate(response.generated_images):
    print(f"Image {idx + 1}:")
    print(f"  - Seed: {image.seed}")
    print(f"  - Finish Reason: {image.finish_reason}")
    print(f"  - Image Bytes Length: {len(image.image_bytes)}")

# Truy cập siêu dữ liệu (metadata)
print("\nMetadata:")
print(f"  - Model Version: {response.response.metadata.model_version}")
print(f"  - Processing Time: {response.response.metadata.processing_time_ms}ms")
print(f"  - SynthID: {response.response.metadata.content_authenticity.synth_id}")

Chuyển đổi sang các định dạng khác nhau

from PIL import Image
import io
import base64

def image_to_different_formats(image_bytes):
    """Chuyển đổi hình ảnh đã tạo sang nhiều định dạng."""
    # Tải dưới dạng PIL Image
    img = Image.open(io.BytesIO(image_bytes))

    # Lưu dưới dạng PNG
    img.save("image.png", "PNG")

    # Lưu dưới dạng JPEG (với chất lượng)
    img.save("image.jpg", "JPEG", quality=95)

    # Chuyển đổi sang WebP (kích thước tệp nhỏ hơn)
    img.save("image.webp", "WEBP", quality=85)

    # Lấy base64 để nhúng
    buffered = io.BytesIO()
    img.save(buffered, format="PNG")
    base64_str = base64.b64encode(buffered.getvalue()).decode()

    return base64_str

Xử lý lỗi

Xử lý lỗi đúng cách là điều cần thiết cho các ứng dụng sản xuất:

Xử lý lỗi Python

import google.generativeai as genai
from google.api_core.exceptions import (
    ResourceExhausted,
    InvalidArgument,
    ServiceUnavailable
)

genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))
model = genai.GenerativeModel("gemini-3.1-flash-image-preview")

def generate_image_with_retry(prompt, max_retries=3):
    """Tạo ảnh với logic thử lại."""

    for attempt in range(max_retries):
        try:
            response = model.generate_images(
                prompt=prompt,
                number_of_images=1
            )
            return response

        except ResourceExhausted as e:
            # Hạn mức hoặc giới hạn tốc độ vượt quá
            print(f"Rate limited (attempt {attempt + 1}/{max_retries})")
            if attempt < max_retries - 1:
                import time
                time.sleep(2 ** attempt)  # Tăng dần thời gian chờ
            else:
                raise Exception("Rate limit exceeded. Please try again later.")

        except InvalidArgument as e:
            # Mô tả (prompt) hoặc tham số không hợp lệ
            raise ValueError(f"Invalid request: {e}")

        except ServiceUnavailable as e:
            # Dịch vụ tạm thời không khả dụng
            print(f"Service unavailable (attempt {attempt + 1}/{max_retries})")
            if attempt < max_retries - 1:
                import time
                time.sleep(5)  # Chờ 5 giây
            else:
                raise Exception("Service unavailable. Please try again later.")

    return None

# Cách sử dụng
try:
    result = generate_image_with_retry("A beautiful landscape")
    if result:
        print("Image generated successfully")
except Exception as e:
    print(f"Error: {e}")

Xử lý lỗi JavaScript

const { GoogleGenerativeAI } = require("@google/generative-ai");

const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);

async function generateImageWithRetry(prompt, maxRetries = 3) {
  const model = genAI.getGenerativeModel({
    model: "gemini-3.1-flash-image-preview",
  });

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const result = await model.generateImages({
        prompt,
        numberOfImages: 1
      });
      return result;
    } catch (error) {
      console.error(`Attempt ${attempt + 1} failed:`, error.message);

      if (error.message.includes("RESOURCE_EXHAUSTED")) {
        // Vượt quá giới hạn tốc độ
        const delay = Math.pow(2, attempt) * 1000;
        console.log(`Rate limited. Retrying in ${delay}ms...`);
        await new Promise(resolve => setTimeout(resolve, delay));
      } else if (error.message.includes("INVALID_ARGUMENT")) {
        // Prompt không hợp lệ
        throw new Error(`Invalid prompt: ${error.message}`);
      } else if (attempt === maxRetries - 1) {
        throw error;
      }
    }
  }

  return null;
}

// Cách sử dụng
generateImageWithRetry("A serene mountain lake at sunrise")
  .then(result => {
    if (result) {
      console.log("Image generated successfully");
    }
  })
  .catch(err => {
    console.error("Failed to generate image:", err.message);
  });

Các mã lỗi phổ biến

Kiểm thử với Apidog

Apidog là một công cụ tuyệt vời để kiểm thử và gỡ lỗi tích hợp Nano Banana 2 API của bạn:

Thiết lập không gian làm việc Apidog của bạn

1. Mở Apidog và tạo một dự án mới
2. Thêm các biến môi trường:

GEMINI_API_KEY: your_api_key_here
BASE_URL: https://generativelanguage.googleapis.com/v1beta

Tạo yêu cầu API

Điểm cuối (Endpoint): POST /models/gemini-3.1-flash-image-preview:predict

Tiêu đề (Headers):

Authorization: Bearer {{GEMINI_API_KEY}}
Content-Type: application/json

Nội dung yêu cầu (Request Body):

{
  "prompt": "{{prompt}}",
  "number_of_images": 1,
  "aspect_ratio": "1:1"
}

Tham số truy vấn (Query Parameters):

key: {{GEMINI_API_KEY}}

Viết các tập lệnh kiểm thử

// Kiểm thử: Tạo ảnh thành công
pm.test("Image generation successful", function() {
    var jsonData = pm.response.json();
    pm.expect(jsonData.predictions).to.have.property('image');
    pm.expect(jsonData.predictions[0].metadata.finishReason).to.eql('SUCCESS');
});

// Kiểm thử: Phản hồi chứa siêu dữ liệu
pm.test("Response has required metadata", function() {
    var jsonData = pm.response.json();
    pm.expect(jsonData.metadata).to.have.property('modelVersion');
    pm.expect(jsonData.metadata).to.have.property('processingTimeMs');
});

// Kiểm thử: Xác thực nội dung được bật
pm.test("Content authenticity enabled", function() {
    var jsonData = pm.response.json();
    pm.expect(jsonData.metadata.contentAuthenticity.synthID).to.eql('enabled');
});

// Kiểm thử: Thời gian phản hồi chấp nhận được
pm.test("Response time under 5 seconds", function() {
    pm.expect(pm.response.responseTime).to.be.below(5000);
});

Tạo một bộ sưu tập để kiểm thử hàng loạt

Lưu các yêu cầu này trong Apidog để xây dựng một bộ sưu tập kiểm thử:

1. Tạo ảnh cơ bản - Tạo một hình ảnh đơn lẻ
2. Tạo ảnh hàng loạt - Nhiều prompt
3. Tính nhất quán của nhân vật - Kiểm thử cùng seed
4. Xử lý lỗi - Kiểm thử prompt không hợp lệ
5. Kiểm thử hiệu suất - Nhiều yêu cầu đồng thời

Các phương pháp hay nhất trong sản xuất

Khi triển khai Nano Banana 2 trong môi trường sản xuất:

1. Bảo mật khóa API của bạn

# Không bao giờ mã hóa cứng khóa API
# Sử dụng biến môi trường
import os

API_KEY = os.environ.get("GEMINI_API_KEY")

# Hoặc sử dụng trình quản lý bí mật
# AWS Secrets Manager, HashiCorp Vault, v.v.

2. Thực hiện cơ chế caching

import hashlib
import redis

redis_client = redis.Redis(host='localhost', port=6379, db=0)

def generate_image_cached(prompt, seed=None):
    """Tạo ảnh với cơ chế caching."""
    # Tạo khóa cache từ prompt + seed
    cache_key = f"image:{hashlib.md5(f'{prompt}:{seed}'.encode()).hexdigest()}"

    # Kiểm tra cache
    cached = redis_client.get(cache_key)
    if cached:
        return cached

    # Tạo hình ảnh mới
    response = model.generate_images(prompt=prompt, seed=seed)
    image_data = response.generated_images[0].image_bytes

    # Cache trong 24 giờ
    redis_client.setex(cache_key, 86400, image_data)

    return image_data

3. Giới hạn tốc độ yêu cầu (Rate Limiting)

from flask import Flask, request, jsonify
from flask_limiter import Limiter

app = Flask(__name__)
limiter = Limiter(app, key_func=lambda: request.headers.get("X-API-Key"))

@app.route("/generate", methods=["POST"])
@limiter.limit("10 per minute")  # Điều chỉnh dựa trên hạn mức của bạn
def generate():
    # Logic tạo ảnh của bạn
    pass

4. Giám sát và ghi nhật ký

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def generate_with_logging(prompt):
    logger.info(f"Generating image for prompt: {prompt[:50]}...")

    start_time = time.time()
    try:
        response = model.generate_images(prompt=prompt)
        elapsed = time.time() - start_time

        logger.info(f"Generated successfully in {elapsed:.2f}s")
        return response

    except Exception as e:
        elapsed = time.time() - start_time
        logger.error(f"Failed after {elapsed:.2f}s: {e}")
        raise

5. Webhook cho xử lý bất đồng bộ

Đối với các công việc hàng loạt lớn, hãy sử dụng webhook:

# Yêu cầu với webhook
response = model.generate_images(
    prompt="Generate 10 product images",
    number_of_images=10,
    webhook_url="https://your-server.com/webhook/nano-banana"
)

# Trình xử lý webhook của bạn
@app.route("/webhook/nano-banana", methods=["POST"])
def handle_webhook():
    data = request.json

    if data["status"] == "completed":
        images = data["images"]
        # Xử lý hình ảnh đã hoàn thành
    elif data["status"] == "failed":
        # Xử lý lỗi
        pass

    return jsonify({"received": True})

Kết luận

API Nano Banana 2 cung cấp một cách mạnh mẽ để tích hợp tính năng tạo ảnh AI vào các ứng dụng của bạn. Với sự hỗ trợ cho nhiều ngôn ngữ lập trình, các tham số linh hoạt và khả năng xử lý lỗi mạnh mẽ, bạn có thể xây dựng mọi thứ từ các trình tạo ảnh đơn giản đến các quy trình làm việc sản xuất phức tạp.

Những điểm chính cần nhớ:

• Bắt đầu yêu cầu một dự án Google Cloud và khóa API
• Các bộ công cụ phát triển phần mềm (SDK) Python và JavaScript giúp việc tích hợp trở nên đơn giản
• Các tham số nâng cao như seed và negative prompts mang lại cho bạn quyền kiểm soát tốt
• Apidog giúp kiểm thử và gỡ lỗi tích hợp API của bạn
• Triển khai sản xuất cần bảo mật, caching, giới hạn tốc độ và giám sát

Hãy bắt đầu với các ví dụ cơ bản trong hướng dẫn này, sau đó dần dần thêm các tính năng nâng cao khi bạn trở nên thoải mái hơn với API.

Bước tiếp theo: