4 Perbedaan Inti Panggilan Sinkron dan Asinkron Nano Banana Pro API

Apa perbedaan antara panggilan sinkron dan asinkron saat menggunakan Nano Banana Pro API untuk menghasilkan gambar? Saat ini, baik APIYI maupun Gemini resmi hanya mendukung mode panggilan sinkron, namun APIYI telah secara signifikan meningkatkan pengalaman pengguna dengan menyediakan output gambar melalui URL OSS. Artikel ini akan menganalisis secara sistematis perbedaan inti antara panggilan sinkron dan asinkron, serta solusi optimasi format output gambar di platform APIYI.

Nilai Inti: Setelah membaca artikel ini, Anda akan memahami perbedaan esensial antara panggilan sinkron dan asinkron dalam desain API, keunggulan output URL OSS platform APIYI dibandingkan pengodean base64, serta cara memilih solusi perolehan gambar terbaik berdasarkan skenario bisnis.

Perbandingan Inti Mode Panggilan Nano Banana Pro API

Cara Kerja Panggilan Sinkron

Panggilan Sinkron (Synchronous Call) menggunakan pola Permintaan-Tunggu-Respons:

1. Klien Memulai Permintaan: Mengirim permintaan pembuatan gambar ke server.
2. Menjaga Koneksi HTTP: Klien menjaga koneksi TCP tetap terbuka, menunggu server menyelesaikan inferensi.
3. Menunggu Secara Memblokir (Blocking): Selama waktu inferensi 30-170 detik, klien tidak dapat memproses operasi lain.
4. Menerima Respons Lengkap: Server mengembalikan data gambar yang dihasilkan (base64 atau URL).
5. Tutup Koneksi: Menutup koneksi HTTP setelah selesai.

Karakteristik Kunci: Panggilan sinkron bersifat Memblokir (Blocking), di mana klien harus menunggu respons server sebelum dapat melanjutkan operasi berikutnya. Hal ini memerlukan pengaturan batas waktu (timeout) yang cukup lama (disarankan 300 detik untuk 1K/2K, dan 600 detik untuk 4K) guna menghindari terputusnya koneksi sebelum inferensi selesai.

Cara Kerja Panggilan Asinkron

Panggilan Asinkron (Asynchronous Call) menggunakan pola Permintaan-Terima-Notifikasi:

1. Klien Mengirimkan Tugas: Mengirim permintaan pembuatan gambar ke server.
2. Segera Mengembalikan ID Tugas: Server menerima permintaan, mengembalikan ID tugas (seperti task_abc123), dan segera menutup koneksi.
3. Inferensi Latar Belakang: Server melakukan pembuatan gambar di latar belakang, sementara klien dapat menangani operasi lain.
4. Mendapatkan Hasil: Klien mendapatkan hasil melalui salah satu dari dua cara berikut:
   • Polling (Pengambilan data berkala): Meminta status secara berkala ke /tasks/task_abc123/status.
   • Callback Webhook: Setelah tugas selesai, server secara proaktif memanggil URL callback yang disediakan oleh klien.
5. Unduh Gambar: Setelah tugas selesai, unduh gambar yang dihasilkan melalui URL yang dikembalikan.

Karakteristik Kunci: Panggilan asinkron bersifat Non-blokir (Non-blocking), di mana klien dapat segera memproses permintaan lain setelah mengirimkan tugas tanpa perlu menjaga koneksi dalam waktu lama. Mode ini cocok untuk pemrosesan batch, tugas latar belakang, dan skenario yang tidak memerlukan respons real-time yang ketat.

💡 Saran Teknis: Platform APIYI saat ini hanya mendukung mode panggilan sinkron, namun dengan mengoptimalkan konfigurasi timeout dan menyediakan output URL OSS, pengalaman pengguna telah meningkat secara signifikan. Untuk skenario yang memerlukan pembuatan gambar dalam jumlah banyak, disarankan untuk melakukan panggilan melalui platform APIYI apiyi.com, yang menyediakan antarmuka port HTTP yang stabil, konfigurasi timeout default yang wajar, dan mendukung panggilan sinkron dengan konkurensi tinggi.

Diagram Urutan Panggilan Sinkron vs Asinkron

t=0s

Urutan Panggilan Sinkron

Klien → Server Kirim permintaan POST + petunjuk 0-2 detik

t=0s

🔒 Koneksi Tetap Terbuka Server Sedang Inferensi (1K: 30-60 detik) Server Sedang Inferensi (2K: 60-90 detik) Server Sedang Inferensi (4K: 100-170 detik) ⏳ Klien Menunggu (Blocking) Tidak dapat memproses permintaan lain TCP Keep-Alive menjaga koneksi 30-170 detik

t=2s

Server → Klien Kembalikan respons lengkap (URL atau base64) Tutup koneksi HTTP 2-5 detik

t=125s

Total Waktu: 127-175 Detik

Urutan Panggilan Asinkron

Klien → Server Kirim permintaan POST (async) 1-3 detik

Server → Klien Kembalikan ID Tugas: task_abc123 1 detik

🔓 Koneksi HTTP Ditutup

Inferensi Latar Belakang Server Klien bisa memproses tugas lain ✅ Tidak perlu menjaga koneksi

Klien Melakukan Polling Status GET /tasks/task_abc123 (setiap 5 detik) status: “processing” → “completed” Setiap koneksi 1-2 detik

Unduh Gambar yang Dihasilkan GET image_url (5-10 detik) 5-10 detik

Total Waktu: 127-175 Detik (Tersebar)

Koneksi Terbuka: 127-175 Detik | Blocking

Koneksi Terbuka: Hanya 15-25 Detik | Non-blocking

Perbedaan Inti 1: Durasi Menjaga Koneksi dan Konfigurasi Timeout

Persyaratan Menjaga Koneksi pada Pemanggilan Sinkron

Pemanggilan sinkron mengharuskan klien untuk menjaga koneksi HTTP tetap terbuka selama seluruh proses pembuatan gambar berlangsung. Hal ini menimbulkan tantangan teknis sebagai berikut:

Contoh Pemanggilan Sinkron di Python:

import requests
import time

def generate_image_sync(prompt: str, size: str = "4096x4096") -> dict:
    """
    同步调用 Nano Banana Pro API 生成图像

    Args:
        prompt: 图像提示词
        size: 图像尺寸

    Returns:
        API 响应结果
    """
    start_time = time.time()

    # 同步调用:保持连接直到生成完成
    response = requests.post(
        "http://api.apiyi.com:16888/v1/images/generations",
        json={
            "prompt": prompt,
            "size": size,
            "model": "nano-banana-pro",
            "n": 1,
            "response_format": "url"  # APIYI 支持 URL 输出
        },
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        timeout=(10, 600)  # 连接超时 10 秒,读取超时 600 秒
    )

    elapsed = time.time() - start_time
    print(f"⏱️ 同步调用耗时: {elapsed:.2f} 秒")
    print(f"🔗 连接状态: 保持打开 {elapsed:.2f} 秒")

    return response.json()


# 使用示例
result = generate_image_sync(
    prompt="A futuristic cityscape at sunset",
    size="4096x4096"
)

print(f"✅ 图像 URL: {result['data'][0]['url']}")

Observasi Penting:

• Klien akan terhenti sepenuhnya (blocked) selama waktu inferensi 100-170 detik.
• Koneksi HTTP terus terbuka, mengonsumsi sumber daya sistem.
• Jika pengaturan timeout tidak tepat (misalnya 60 detik), koneksi akan terputus sebelum inferensi selesai.

Keunggulan Koneksi Pendek pada Pemanggilan Asinkron

Pemanggilan asinkron hanya membuat koneksi pendek saat mengirimkan tugas dan mengecek status, sehingga secara signifikan mengurangi waktu koneksi yang harus dijaga:

Contoh Pemanggilan Asinkron di Python (Simulasi dukungan APIYI di masa depan):

import requests
import time

def generate_image_async(prompt: str, size: str = "4096x4096") -> str:
    """
    异步调用 Nano Banana Pro API 生成图像 (未来功能)

    Args:
        prompt: 图像提示词
        size: 图像尺寸

    Returns:
        任务 ID
    """
    # 步骤 1: 提交任务 (短连接)
    response = requests.post(
        "http://api.apiyi.com:16888/v1/images/generations/async",  # 未来接口
        json={
            "prompt": prompt,
            "size": size,
            "model": "nano-banana-pro",
            "n": 1,
            "response_format": "url"
        },
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        timeout=(10, 30)  # 提交任务仅需 30 秒超时
    )

    task_data = response.json()
    task_id = task_data["task_id"]
    print(f"✅ 任务已提交: {task_id}")
    print(f"🔓 连接已关闭,可以处理其他任务")

    return task_id


def poll_task_status(task_id: str, max_wait: int = 300) -> dict:
    """
    轮询任务状态直到完成

    Args:
        task_id: 任务 ID
        max_wait: 最大等待时间 (秒)

    Returns:
        生成结果
    """
    start_time = time.time()
    poll_interval = 5  # 每 5 秒轮询一次

    while time.time() - start_time < max_wait:
        # 查询任务状态 (短连接)
        response = requests.get(
            f"http://api.apiyi.com:16888/v1/tasks/{task_id}",  # 未来接口
            headers={"Authorization": "Bearer YOUR_API_KEY"},
            timeout=(10, 10)  # 查询状态仅需 10 秒超时
        )

        status_data = response.json()
        status = status_data["status"]

        if status == "completed":
            elapsed = time.time() - start_time
            print(f"✅ 任务完成! 总耗时: {elapsed:.2f} 秒")
            return status_data["result"]

        elif status == "failed":
            raise Exception(f"任务失败: {status_data.get('error')}")

        else:
            print(f"⏳ 任务状态: {status}, 等待 {poll_interval} 秒后重试...")
            time.sleep(poll_interval)

    raise TimeoutError(f"任务超时: {task_id}")


# 使用示例
task_id = generate_image_async(
    prompt="A serene mountain landscape",
    size="4096x4096"
)

# 在轮询期间,可以处理其他任务
print("🚀 可以并发处理其他请求...")

# 轮询任务状态
result = poll_task_status(task_id, max_wait=600)
print(f"✅ 图像 URL: {result['data'][0]['url']}")

from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

# 全局字典存储任务结果
task_results = {}


@app.route('/webhook/image_completed', methods=['POST'])
def handle_webhook():
    """接收 APIYI 异步任务完成的 Webhook 回调"""
    data = request.json

    task_id = data['task_id']
    status = data['status']
    result = data.get('result')

    if status == 'completed':
        task_results[task_id] = result
        print(f"✅ 任务 {task_id} 完成: {result['data'][0]['url']}")
    else:
        print(f"❌ 任务 {task_id} 失败: {data.get('error')}")

    return jsonify({"received": True}), 200


def generate_image_with_webhook(prompt: str, size: str = "4096x4096") -> str:
    """
    使用 Webhook 模式异步生成图像

    Args:
        prompt: 图像提示词
        size: 图像尺寸

    Returns:
        任务 ID
    """
    response = requests.post(
        "http://api.apiyi.com:16888/v1/images/generations/async",
        json={
            "prompt": prompt,
            "size": size,
            "model": "nano-banana-pro",
            "n": 1,
            "response_format": "url",
            "webhook_url": "https://your-domain.com/webhook/image_completed"  # 回调 URL
        },
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        timeout=(10, 30)
    )

    task_id = response.json()["task_id"]
    print(f"✅ 任务已提交: {task_id}")
    print(f"📞 Webhook 将回调: https://your-domain.com/webhook/image_completed")

    return task_id


# 启动 Flask 服务器监听 Webhook
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

🎯 Batasan Saat Ini: Saat ini, APIYI dan Gemini resmi hanya mendukung mode pemanggilan sinkron. Fitur pemanggilan asinkron direncanakan akan diluncurkan pada versi mendatang. Untuk skenario yang membutuhkan pembuatan gambar dengan konkurensi tinggi, disarankan untuk menggunakan platform APIYI apiyi.com dengan pemanggilan antarmuka sinkron melalui multi-thread atau multi-proses, serta mengonfigurasi waktu timeout yang wajar.

Perbedaan Inti 2: Kemampuan Pemrosesan Konkuren dan Penggunaan Sumber Daya

Batasan Konkurensi Pemanggilan Sinkron

Dalam skenario konkurensi tinggi, pemanggilan sinkron menghadapi masalah penggunaan sumber daya yang signifikan:

Masalah Pemblokiran Single-thread:

import time

# ❌ 错误: 单线程顺序调用,总耗时 = 单次耗时 × 任务数
def generate_multiple_images_sequential(prompts: list) -> list:
    results = []
    start_time = time.time()

    for prompt in prompts:
        result = generate_image_sync(prompt, size="4096x4096")
        results.append(result)

    elapsed = time.time() - start_time
    print(f"❌ 顺序调用 {len(prompts)} 张图像耗时: {elapsed:.2f} 秒")
    # 假设每张图 120 秒,10 张图 = 1200 秒 (20 分钟!)

    return results

Optimasi Konkurensi Multi-thread:

from concurrent.futures import ThreadPoolExecutor, as_completed
import time

# ✅ 正确: 多线程并发调用,充分利用 I/O 等待时间
def generate_multiple_images_concurrent(prompts: list, max_workers: int = 5) -> list:
    """
    多线程并发生成多张图像

    Args:
        prompts: 提示词列表
        max_workers: 最大并发线程数

    Returns:
        生成结果列表
    """
    results = []
    start_time = time.time()

    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        # 提交所有任务
        future_to_prompt = {
            executor.submit(generate_image_sync, prompt, "4096x4096"): prompt
            for prompt in prompts
        }

        # 等待所有任务完成
        for future in as_completed(future_to_prompt):
            prompt = future_to_prompt[future]
            try:
                result = future.result()
                results.append(result)
                print(f"✅ 完成: {prompt[:30]}...")
            except Exception as e:
                print(f"❌ 失败: {prompt[:30]}... - {e}")

    elapsed = time.time() - start_time
    print(f"✅ 并发调用 {len(prompts)} 张图像耗时: {elapsed:.2f} 秒")
    # 假设每张图 120 秒,10 张图 ≈ 120-150 秒 (2-2.5 分钟)

    return results


# 使用示例
prompts = [
    "A cyberpunk city at night",
    "A serene forest landscape",
    "An abstract geometric pattern",
    "A futuristic space station",
    "A vintage car in the desert",
    # ...更多提示词
]

results = generate_multiple_images_concurrent(prompts, max_workers=5)
print(f"🎉 生成了 {len(results)} 张图像")

Keunggulan Konkurensi Pemanggilan Asinkron

Pemanggilan asinkron memiliki keunggulan signifikan dalam skenario pemrosesan batch:

Pengiriman Batch + Polling Batch:

def generate_batch_async(prompts: list) -> list:
    """
    批量异步生成图像 (未来功能)

    Args:
        prompts: 提示词列表

    Returns:
        任务 ID 列表
    """
    task_ids = []

    # 步骤 1: 快速批量提交所有任务 (每个 1-3 秒)
    for prompt in prompts:
        task_id = generate_image_async(prompt, size="4096x4096")
        task_ids.append(task_id)

    print(f"✅ 批量提交 {len(task_ids)} 个任务,耗时约 {len(prompts) * 2} 秒")

    # 步骤 2: 批量轮询任务状态
    results = []
    for task_id in task_ids:
        result = poll_task_status(task_id, max_wait=600)
        results.append(result)

    return results

💰 Optimasi Biaya: Google Gemini API menyediakan mode Batch API yang mendukung pemrosesan asinkron dengan diskon harga 50% (harga standar $0,133-$0,24/gambar, Batch API $0,067-$0,12/gambar), namun Anda harus mentoleransi waktu pengiriman hingga 24 jam. Untuk skenario yang tidak memerlukan pembuatan real-time, Anda dapat mempertimbangkan penggunaan Batch API untuk menekan biaya.

Perbedaan Inti 3: Keunggulan Output URL OSS di Platform APIYI

Perbandingan antara Encoding base64 vs Output URL

API Nano Banana Pro mendukung dua format output gambar:

Masalah Performa pada Encoding base64:

1. Pembengkakan Body Respons sebesar 33%: Encoding base64 akan menambah jumlah data sekitar 33%.

   • Gambar 4K asli: sekitar 6 MB
   • Setelah encoding base64: sekitar 8 MB

2. Tidak Bisa Memanfaatkan CDN: String base64 tertanam di dalam respons JSON, sehingga tidak bisa di-cache melalui CDN.

3. Tekanan Memori pada Perangkat Mobile: Mendekode string base64 memerlukan sumber daya memori dan CPU tambahan.

Keunggulan Output URL OSS APIYI:

import requests

# ✅ Direkomendasikan: Menggunakan output URL OSS APIYI
response = requests.post(
    "http://api.apiyi.com:16888/v1/images/generations",
    json={
        "prompt": "A beautiful sunset over mountains",
        "size": "4096x4096",
        "model": "nano-banana-pro",
        "n": 1,
        "response_format": "url"  # Menentukan output URL
    },
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    timeout=(10, 600)
)

result = response.json()

# Body respons hanya berisi URL, ukurannya sekitar 200 byte
print(f"Ukuran body respons: {len(response.content)} byte")
# Output: Ukuran body respons: 234 byte

# Contoh URL OSS
image_url = result['data'][0]['url']
print(f"URL Gambar: {image_url}")
# Output: https://apiyi-oss.oss-cn-beijing.aliyuncs.com/nano-banana/abc123.png

# Selanjutnya unduh gambar melalui HTTP standar, nikmati akselerasi CDN
image_response = requests.get(image_url)
with open("output.png", "wb") as f:
    f.write(image_response.content)

Perbandingan: Masalah Performa pada Output base64:

# ❌ Tidak direkomendasikan: Output encoding base64
response = requests.post(
    "https://api.example.com/v1/images/generations",
    json={
        "prompt": "A beautiful sunset over mountains",
        "size": "4096x4096",
        "model": "nano-banana-pro",
        "n": 1,
        "response_format": "b64_json"  # Encoding base64
    },
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    timeout=(10, 600)
)

result = response.json()

# Body respons berisi string base64 lengkap, ukuran sekitar 8 MB
print(f"Ukuran body respons: {len(response.content)} byte")
# Output: Ukuran body respons: 8388608 byte (8 MB!)

# Perlu mendekode string base64
import base64
image_b64 = result['data'][0]['b64_json']
image_bytes = base64.b64decode(image_b64)

with open("output.png", "wb") as f:
    f.write(image_bytes)

🚀 Konfigurasi yang Direkomendasikan: Saat memanggil API Nano Banana Pro di platform APIYI, selalu gunakan response_format: "url" untuk mendapatkan output URL OSS, bukan encoding base64. Hal ini tidak hanya mengurangi ukuran respons API dan waktu transmisi secara signifikan, tetapi juga memanfaatkan sepenuhnya akselerasi CDN dan cache browser untuk meningkatkan pengalaman pengguna.

Perbedaan Inti 4: Skenario Penggunaan dan Rencana Masa Depan

Skenario Penggunaan Terbaik untuk Pemanggilan Sinkron

Skenario yang Direkomendasikan:

1. Generasi Gambar Real-time: Menampilkan gambar yang dihasilkan segera setelah pengguna mengirimkan petunjuk.
2. Pemrosesan Batch Kecil: Menghasilkan 1-10 gambar, pemanggilan konkuren sudah cukup untuk memenuhi kebutuhan performa.
3. Integrasi Sederhana: Tidak perlu mengimplementasikan polling atau Webhook, mengurangi kompleksitas pengembangan.
4. Aplikasi Interaktif: Alat lukis AI, editor gambar, dan skenario lain yang membutuhkan umpan balik instan.

Pola Kode Tipikal:

from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

@app.route('/generate', methods=['POST'])
def generate_image():
    """Interface generasi gambar real-time"""
    data = request.json
    prompt = data['prompt']
    size = data.get('size', '1024x1024')

    # Pemanggilan sinkron, pengguna menunggu hingga generasi selesai
    response = requests.post(
        "http://api.apiyi.com:16888/v1/images/generations",
        json={
            "prompt": prompt,
            "size": size,
            "model": "nano-banana-pro",
            "n": 1,
            "response_format": "url"
        },
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        timeout=(10, 300 if size != '4096x4096' else 600)
    )

    result = response.json()
    return jsonify({
        "success": True,
        "image_url": result['data'][0]['url']
    })

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8000)

Skenario Penggunaan Masa Depan untuk Pemanggilan Asinkron

Skenario yang Sesuai (Dukungan di Masa Depan):

1. Generasi Gambar Batch: Menghasilkan 100+ gambar, seperti gambar produk e-commerce dalam jumlah besar atau perpustakaan aset desain.
2. Tugas Terjadwal Latar Belakang: Secara otomatis menghasilkan jenis gambar tertentu setiap hari tanpa perlu respons real-time.
3. Pemrosesan Biaya Rendah: Menggunakan Google Batch API untuk mendapatkan diskon harga 50%, dengan toleransi waktu pengiriman 24 jam.
4. Skenario Konkurensi Tinggi: Ratusan pengguna mengirimkan permintaan generasi secara bersamaan, menghindari habisnya pool koneksi.

Pola Kode Tipikal (Masa Depan):

from flask import Flask, request, jsonify
from celery import Celery
import requests

app = Flask(__name__)
celery = Celery('tasks', broker='redis://localhost:6379/0')

@celery.task
def generate_image_task(prompt: str, size: str, user_id: str):
    """Tugas asinkron Celery: Menghasilkan gambar"""
    # Mengirimkan tugas asinkron ke APIYI
    response = requests.post(
        "http://api.apiyi.com:16888/v1/images/generations/async",  # Interface masa depan
        json={
            "prompt": prompt,
            "size": size,
            "model": "nano-banana-pro",
            "n": 1,
            "response_format": "url",
            "webhook_url": f"https://your-domain.com/webhook/{user_id}"
        },
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        timeout=(10, 30)
    )

    task_id = response.json()["task_id"]
    return task_id


@app.route('/generate_async', methods=['POST'])
def generate_image_async():
    """Interface generasi gambar asinkron"""
    data = request.json
    prompt = data['prompt']
    size = data.get('size', '1024x1024')
    user_id = data['user_id']

    # Mengirimkan tugas Celery, segera kembali
    task = generate_image_task.delay(prompt, size, user_id)

    return jsonify({
        "success": True,
        "message": "Tugas telah dikirim, akan diberitahukan melalui Webhook setelah selesai",
        "task_id": task.id
    })


@app.route('/webhook/<user_id>', methods=['POST'])
def handle_webhook(user_id: str):
    """Menerima callback Webhook untuk penyelesaian tugas asinkron APIYI"""
    data = request.json
    task_id = data['task_id']
    result = data['result']

    # Memberitahu pengguna bahwa generasi gambar telah selesai (seperti kirim email, push notif, dll)
    notify_user(user_id, result['data'][0]['url'])

    return jsonify({"received": True}), 200

Rencana Masa Depan Platform APIYI

💡 Saran Pengembangan: APIYI berencana meluncurkan fitur pemanggilan asinkron pada kuartal ketiga tahun 2026, yang mendukung pengiriman tugas, kueri status, dan callback Webhook. Bagi pengembang yang memiliki kebutuhan pemrosesan batch saat ini, disarankan untuk menggunakan pemanggilan konkuren multi-threading pada interface sinkron, dan mendapatkan interface port HTTP yang stabil serta konfigurasi timeout yang dioptimalkan melalui platform APIYI apiyi.com.

FAQ (Pertanyaan yang Sering Diajukan)

import requests

# Menghasilkan gambar dan mendapatkan URL
result = generate_image_sync(prompt="A beautiful landscape", size="4096x4096")
temp_url = result['data'][0]['url']
print(f"URL Sementara: {temp_url}")

# Unduh gambar ke lokal atau ke OSS pribadi
image_response = requests.get(temp_url)
with open("permanent_image.png", "wb") as f:
    f.write(image_response.content)

# Atau unggah ke OSS sendiri (contoh dengan Alibaba Cloud OSS)
import oss2
auth = oss2.Auth('YOUR_ACCESS_KEY', 'YOUR_SECRET_KEY')
bucket = oss2.Bucket(auth, 'oss-cn-beijing.aliyuncs.com', 'your-bucket')
bucket.put_object('images/permanent_image.png', image_response.content)

// Kode frontend (Contoh React)
async function generateImage(prompt, size) {
  // Panggil antarmuka backend Anda sendiri
  const response = await fetch('https://your-backend.com/api/generate', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer YOUR_USER_TOKEN'  // Token autentikasi pengguna
    },
    body: JSON.stringify({ prompt, size })
  });

  const result = await response.json();
  return result.image_url;  // Mengembalikan URL OSS APIYI
}

// Penggunaan
const imageUrl = await generateImage("A futuristic city", "4096x4096");
document.getElementById('result-image').src = imageUrl;

# Kode backend (Contoh Flask)
from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

@app.route('/api/generate', methods=['POST'])
def generate():
    # Verifikasi token pengguna
    user_token = request.headers.get('Authorization')
    if not verify_user_token(user_token):
        return jsonify({"error": "Unauthorized"}), 401

    data = request.json

    # Backend memanggil API APIYI (API Key tidak akan terekspos ke frontend)
    response = requests.post(
        "http://api.apiyi.com:16888/v1/images/generations",
        json={
            "prompt": data['prompt'],
            "size": data['size'],
            "model": "nano-banana-pro",
            "n": 1,
            "response_format": "url"
        },
        headers={"Authorization": "Bearer YOUR_APIYI_API_KEY"},  # Disimpan aman di backend
        timeout=(10, 600)
    )

    result = response.json()
    return jsonify({"image_url": result['data'][0]['url']})

Kesimpulan

Poin-poin inti mengenai panggilan sinkron dan asinkron Nano Banana Pro API:

1. Karakteristik Panggilan Sinkron: Menjaga koneksi HTTP tetap terbuka hingga pembuatan selesai, menunggu selama 30-170 detik, perlu konfigurasi timeout yang panjang (300-600 detik).
2. Keuntungan Panggilan Asinkron: Segera mengembalikan ID tugas, non-blocking, cocok untuk pemrosesan batch dan tugas latar belakang, namun saat ini baik APIYI maupun Gemini resmi belum mendukungnya.
3. Output URL OSS APIYI: Dibandingkan dengan pengkodean base64, ukuran respons berkurang 99,998%, mendukung akselerasi CDN dan cache browser, yang secara signifikan meningkatkan performa.
4. Praktik Terbaik Saat Ini: Gunakan panggilan sinkron + konkurensi multi-threading + output URL OSS, dan dapatkan konfigurasi timeout yang dioptimalkan melalui antarmuka port HTTP APIYI.
5. Rencana Masa Depan: APIYI berencana meluncurkan fungsi panggilan asinkron pada Q2 2026, yang mendukung pengiriman tugas, kueri status, dan callback Webhook.

Direkomendasikan untuk mengintegrasikan Nano Banana Pro API dengan cepat melalui APIYI (apiyi.com). Platform ini menyediakan antarmuka port HTTP yang dioptimalkan (http://api.apiyi.com:16888/v1), output gambar URL OSS eksklusif, serta konfigurasi timeout yang masuk akal, sangat cocok untuk skenario pembuatan gambar real-time maupun pemrosesan batch.

Penulis: Tim Teknis APIYI | Jika Anda memiliki pertanyaan teknis, silakan kunjungi APIYI apiyi.com untuk mendapatkan lebih banyak solusi integrasi model AI.