วิธีใช้ Google Nano Banana 2 API

การสร้างแอปพลิเคชันด้วย AI สร้างภาพนั้นให้ความรู้สึกเหมือนเวทมนตร์—จนกว่าคุณจะเจออุปสรรคของเอกสาร API ที่ซับซ้อน ปัญหาการยืนยันตัวตน และฝันร้ายในการแก้ไขข้อผิดพลาด คุณเคยเห็น สิ่งที่ Nano Banana 2 ทำได้ มาแล้ว: ภาพที่น่าทึ่งที่สร้างจากข้อความแจ้ง (text prompt) ผลลัพธ์คุณภาพระดับ Pro ที่ความเร็วสูง และคุณสมบัติเช่นความสอดคล้องของวัตถุที่ทำให้เวิร์กโฟลว์หลายภาพเป็นไปได้ แต่การรวมเข้ากับ codebase ของคุณจริงๆ ล่ะ? นั่นคือจุดที่นักพัฒนาส่วนใหญ่ติดขัด

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

ในคู่มือนี้ เราจะแนะนำทุกสิ่งที่คุณต้องรู้เพื่อรวม Nano Banana 2 เข้ากับแอปพลิเคชันของคุณ ตั้งแต่การตั้งค่าโปรเจกต์ Google Cloud ไปจนถึงการเขียนโค้ดที่พร้อมใช้งานจริงใน Python และ JavaScript แต่สิ่งที่ทำให้คู่มือนี้แตกต่างคือ: เราจะแสดงวิธีทดสอบและแก้ไขข้อผิดพลาดในทุกขั้นตอนโดยใช้ Apidog ดังนั้นคุณไม่เพียงแค่คัดลอกโค้ดเท่านั้น แต่คุณกำลังสร้างเวิร์กโฟลว์ที่คุณสามารถบำรุงรักษาและปรับขนาดได้

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

ก่อนเริ่มต้น โปรดตรวจสอบให้แน่ใจว่าคุณมีสิ่งต่อไปนี้:

• บัญชี Google Cloud (หรือสมัครได้ที่ cloud.google.com)
• ความเข้าใจพื้นฐานเกี่ยวกับ REST API
• ติดตั้ง Python 3.8+ หรือ Node.js 18+ แล้ว
• ไคลเอนต์ API เช่น Apidog สำหรับการทดสอบ

คู่มือนี้สมมติว่าคุณคุ้นเคยกับการส่งคำขอ HTTP และการจัดการข้อมูล JSON หากคุณยังใหม่กับ API โปรดดู คู่มือการทดสอบ API ของเราสำหรับข้อมูลพื้นฐาน

การตั้งค่าโปรเจกต์ Google Cloud ของคุณ

ในการใช้ Nano Banana 2 API คุณต้องมีโปรเจกต์ Google Cloud ที่เปิดใช้งาน Generative Language API

ขั้นตอนที่ 1: สร้างโปรเจกต์ใหม่

1. ไปที่ Google Cloud Console
2. คลิก "เลือกโปรเจกต์" → "โปรเจกต์ใหม่"
3. ป้อนชื่อโปรเจกต์ (เช่น "nano-banana-image-gen")
4. คลิก "สร้าง"
5. รอให้โปรเจกต์ถูกสร้างขึ้น

ขั้นตอนที่ 2: กำหนดค่าการเข้าถึง API

1. ไปที่ "APIs & Services" → "Credentials"
2. คลิก "สร้างข้อมูลรับรอง" → "API Key"
3. คัดลอกคีย์ API ของคุณ (คุณจะต้องใช้ในภายหลัง)

เคล็ดลับมืออาชีพ:

การรับคีย์ API ของคุณ

มีสองวิธีในการเข้าถึง API:

ตัวเลือกที่ 1: Google Cloud Console (แนะนำสำหรับการใช้งานจริง)

ทำตามขั้นตอนข้างต้น—คีย์ API ที่คุณสร้างขึ้นคือข้อมูลรับรองการเข้าถึงของคุณ

ตัวเลือกที่ 2: Google AI Studio (แนะนำสำหรับการพัฒนา)

1. ไปที่ Google AI Studio
2. ลงชื่อเข้าใช้ด้วยบัญชี Google ของคุณ
3. คลิก "รับคีย์ API" ในแถบนำทาง
4. คลิก "สร้างคีย์ API" (หรือเลือกโปรเจกต์ที่มีอยู่)
5. คัดลอกคีย์ API ของคุณ

คีย์ AI Studio เหมาะสำหรับการพัฒนาและทดสอบ สำหรับการใช้งานจริง ให้ใช้คีย์ Google Cloud Console เพื่อการจัดการและความปลอดภัยที่ดีขึ้น

คำขอ API แรกของคุณ

มาลองสร้างคำขอสร้างภาพแบบง่ายๆ เพื่อตรวจสอบว่าทุกอย่างทำงานได้

การใช้ 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
  }'

ทำความเข้าใจการตอบสนอง

{
  "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"
    }
  }
}

ฟิลด์ data มีรูปภาพ PNG ที่เข้ารหัสแบบ base64 คุณจะต้องถอดรหัสเพื่อบันทึกหรือแสดงรูปภาพ

การรวม Python

นี่คือวิธีการรวม Nano Banana 2 เข้ากับแอปพลิเคชัน Python ของคุณ:

การติดตั้งไลบรารีไคลเอนต์

pip install google-generativeai

การสร้างภาพเบื้องต้น

import google.generativeai as genai
import base64
import os

# Configure the API with your key
genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))

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

# Generate an image
response = model.generate_images(
    prompt="A modern minimalist office with natural lighting, indoor plants, standing desk, 4k quality",
    number_of_images=1
)

# Save the image
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")

การสร้างภาพขั้นสูงพร้อมพารามิเตอร์

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

# Generate with advanced parameters
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"
)

# Process the response
for idx, generated_image in enumerate(response.generated_images):
    # Convert to PIL Image
    image = Image.open(io.BytesIO(generated_image.image_bytes))

    # Save with custom name
    image.save(f"generated_image_{idx}.png")

    # Access metadata
    print(f"Image {idx}: {generated_image.finish_reason}")
    print(f"Seed: {generated_image.seed}")

การสร้างภาพแบบแบทช์

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

# Generate multiple images at once
prompts = [
    "A red sports car on a mountain road",
    "A cozy coffee shop interior",
    "A minimalist bedroom design",
    "A tropical beach sunset"
]

# Generate all images
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")

ตัวอย่างความสอดคล้องของตัวละคร

import google.generativeai as genai

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

# Base character description
base_character = "A friendly cartoon robot with round body, blue eyes, antenna on head, white and light blue color scheme"

# Generate base character (note the seed for consistency)
response1 = model.generate_images(
    prompt=base_character + ", front view, standing pose",
    number_of_images=1,
    seed=42  # Important: note this seed
)

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

# Generate variations using the same 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  # Same seed maintains consistency
    )

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

การรวม JavaScript/Node.js

การติดตั้งไลบรารีไคลเอนต์

npm install @google/generative-ai

การสร้างภาพเบื้องต้น

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

// Initialize with API key
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);

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

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

  // Process the response
  if (result.generatedImages && result.generatedImages.length > 0) {
    const imageData = result.generatedImages[0].imageBytes;

    // Save to file
    fs.writeFileSync("sunset.png", Buffer.from(imageData, "base64"));
    console.log("Image saved to sunset.png");

    // Log metadata
    console.log("Seed:", result.generatedImages[0].seed);
    console.log("Finish Reason:", result.generatedImages[0].finishReason);
  }
}

generateImage().catch(console.error);

การจัดการการตอบสนอง 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];

  // Decode base64
  const imageBuffer = Buffer.from(generatedImage.imageBytes, "base64");

  // Save with metadata in filename
  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));

ตัวอย่าง 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());

// Image generation endpoint
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
    });

    // Convert images to base64 for response
    const images = result.generatedImages.map((img, idx) => ({
      id: idx,
      seed: img.seed,
      finishReason: img.finishReason,
      data: img.imageBytes // Base64 encoded
    }));

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

// Batch generation endpoint
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");
});

พารามิเตอร์ขั้นสูง

Nano Banana 2 รองรับพารามิเตอร์ต่างๆ เพื่อปรับแต่งการสร้างภาพของคุณ:

การอ้างอิงพารามิเตอร์

ตัวเลือกความละเอียด

# Available resolutions
resolutions = [
    "512x512",    # Thumbnail, social media
    "768x768",    # Small web images
    "1024x1024",  # Standard square
    "1024x768",   # 4:3 landscape
    "1280x720",   # HD ready
    "1920x1080",  # Full HD
    "2048x2048",  # High quality
    "3840x2160"   # 4K
]

# Using specific resolution
response = model.generate_images(
    prompt="Professional product photography of a watch",
    resolution="2048x2048"
)

อัตราส่วนภาพ

aspect_ratios = [
    "1:1",    # Square (Instagram posts)
    "4:3",    # Standard photo
    "16:9",   # Landscape (YouTube, web)
    "9:16",   # Portrait (Stories, TikTok)
    "21:9",   # Ultrawide
    "3:4",    # Portrait standard
    "2:3"     # Portrait photo
]

# Using specific aspect ratio
response = model.generate_images(
    prompt="Modern office interior design",
    aspect_ratio="16:9"
)

การจัดการการตอบสนอง

การแยกวิเคราะห์โครงสร้างการตอบสนอง

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
)

# Access predictions (generated images)
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)}")

# Access 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}")

การแปลงเป็นรูปแบบต่างๆ

from PIL import Image
import io
import base64

def image_to_different_formats(image_bytes):
    """Convert generated image to multiple formats."""
    # Load as PIL Image
    img = Image.open(io.BytesIO(image_bytes))

    # Save as PNG
    img.save("image.png", "PNG")

    # Save as JPEG (with quality)
    img.save("image.jpg", "JPEG", quality=95)

    # Convert to WebP (smaller file size)
    img.save("image.webp", "WEBP", quality=85)

    # Get base64 for embedding
    buffered = io.BytesIO()
    img.save(buffered, format="PNG")
    base64_str = base64.b64encode(buffered.getvalue()).decode()

    return base64_str

การจัดการข้อผิดพลาด

การจัดการข้อผิดพลาดที่เหมาะสมเป็นสิ่งจำเป็นสำหรับแอปพลิเคชันที่ใช้งานจริง:

การจัดการข้อผิดพลาด 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):
    """Generate image with retry logic."""

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

        except ResourceExhausted as e:
            # Rate limit or quota exceeded
            print(f"Rate limited (attempt {attempt + 1}/{max_retries})")
            if attempt < max_retries - 1:
                import time
                time.sleep(2 ** attempt)  # Exponential backoff
            else:
                raise Exception("Rate limit exceeded. Please try again later.")

        except InvalidArgument as e:
            # Invalid prompt or parameters
            raise ValueError(f"Invalid request: {e}")

        except ServiceUnavailable as e:
            # Service temporarily unavailable
            print(f"Service unavailable (attempt {attempt + 1}/{max_retries})")
            if attempt < max_retries - 1:
                import time
                time.sleep(5)  # Wait 5 seconds
            else:
                raise Exception("Service unavailable. Please try again later.")

    return None

# Usage
try:
    result = generate_image_with_retry("A beautiful landscape")
    if result:
        print("Image generated successfully")
except Exception as e:
    print(f"Error: {e}")

การจัดการข้อผิดพลาด 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")) {
        // Rate limited
        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")) {
        // Invalid prompt
        throw new Error(`Invalid prompt: ${error.message}`);
      } else if (attempt === maxRetries - 1) {
        throw error;
      }
    }
  }

  return null;
}

// Usage
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);
  });

รหัสข้อผิดพลาดทั่วไป

การทดสอบด้วย Apidog

Apidog เป็นเครื่องมือที่ยอดเยี่ยมสำหรับการทดสอบและแก้ไขข้อผิดพลาดในการรวม Nano Banana 2 API ของคุณ:

การตั้งค่าพื้นที่ทำงาน Apidog ของคุณ

1. เปิด Apidog และสร้างโปรเจกต์ใหม่
2. เพิ่มตัวแปรสภาพแวดล้อม:

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

การสร้างคำขอ API

Endpoint: POST /models/gemini-3.1-flash-image-preview:predict

Headers:

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

Request Body:

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

Query Parameters:

key: {{GEMINI_API_KEY}}

การเขียนสคริปต์ทดสอบ

// Test: Successful generation
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');
});

// Test: Response contains metadata
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');
});

// Test: Content authenticity verified
pm.test("Content authenticity enabled", function() {
    var jsonData = pm.response.json();
    pm.expect(jsonData.metadata.contentAuthenticity.synthID).to.eql('enabled');
});

// Test: Response time acceptable
pm.test("Response time under 5 seconds", function() {
    pm.expect(pm.response.responseTime).to.be.below(5000);
});

การสร้างคอลเลกชันสำหรับการทดสอบแบบแบทช์

บันทึกคำขอเหล่านี้ใน Apidog เพื่อสร้างคอลเลกชันทดสอบ:

1. การสร้างพื้นฐาน - การสร้างภาพเดียว
2. การสร้างแบบแบทช์ - พรอมต์หลายรายการ
3. ความสอดคล้องของตัวละคร - การทดสอบ Seed เดียวกัน
4. การจัดการข้อผิดพลาด - การทดสอบพรอมต์ไม่ถูกต้อง
5. การทดสอบประสิทธิภาพ - คำขอพร้อมกันหลายรายการ

แนวทางปฏิบัติที่ดีที่สุดสำหรับการใช้งานจริง

เมื่อปรับใช้ Nano Banana 2 ในการใช้งานจริง:

1. รักษาความปลอดภัยคีย์ API ของคุณ

# Never hardcode API keys
# Use environment variables
import os

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

# Or use a secrets manager
# AWS Secrets Manager, HashiCorp Vault, etc.

2. ใช้การแคช

import hashlib
import redis

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

def generate_image_cached(prompt, seed=None):
    """Generate image with caching."""
    # Create cache key from prompt + seed
    cache_key = f"image:{hashlib.md5(f'{prompt}:{seed}'.encode()).hexdigest()}"

    # Check cache
    cached = redis_client.get(cache_key)
    if cached:
        return cached

    # Generate new image
    response = model.generate_images(prompt=prompt, seed=seed)
    image_data = response.generated_images[0].image_bytes

    # Cache for 24 hours
    redis_client.setex(cache_key, 86400, image_data)

    return image_data

3. การจำกัดอัตรา

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")  # Adjust based on your quota
def generate():
    # Your generation logic
    pass

4. การตรวจสอบและการบันทึก

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 สำหรับการประมวลผลแบบอะซิงโครนัส

สำหรับงานแบทช์ขนาดใหญ่ ให้ใช้ webhooks:

# Request with webhook
response = model.generate_images(
    prompt="Generate 10 product images",
    number_of_images=10,
    webhook_url="https://your-server.com/webhook/nano-banana"
)

# Your webhook handler
@app.route("/webhook/nano-banana", methods=["POST"])
def handle_webhook():
    data = request.json

    if data["status"] == "completed":
        images = data["images"]
        # Process completed images
    elif data["status"] == "failed":
        # Handle failure
        pass

    return jsonify({"received": True})

สรุป

Nano Banana 2 API มอบวิธีที่ทรงพลังในการรวมการสร้างภาพ AI เข้ากับแอปพลิเคชันของคุณ ด้วยการรองรับภาษาโปรแกรมที่หลากหลาย พารามิเตอร์ที่ยืดหยุ่น และการจัดการข้อผิดพลาดที่แข็งแกร่ง คุณสามารถสร้างทุกอย่างตั้งแต่โปรแกรมสร้างภาพง่ายๆ ไปจนถึงเวิร์กโฟลว์การผลิตที่ซับซ้อน

ประเด็นสำคัญ:

• การเริ่มต้น ต้องมีโปรเจกต์ Google Cloud และคีย์ API
• Python และ JavaScript SDK ช่วยให้การรวมเป็นไปอย่างตรงไปตรงมา
• พารามิเตอร์ขั้นสูง เช่น seeds และ negative prompts ให้การควบคุมที่ละเอียดอ่อน
• Apidog ช่วยทดสอบและแก้ไขข้อผิดพลาดการรวม API ของคุณ
• การปรับใช้จริง ต้องการความปลอดภัย การแคช การจำกัดอัตรา และการตรวจสอบ

เริ่มต้นด้วยตัวอย่างพื้นฐานในคู่มือนี้ จากนั้นค่อยๆ เพิ่มคุณสมบัติขั้นสูงเมื่อคุณคุ้นเคยกับ API มากขึ้น

ขั้นตอนต่อไป: