Maîtriser 3 méthodes pratiques pour le monitoring de la disponibilité de l’API Nano Banana Pro

Surveiller la disponibilité de l'API Nano Banana Pro est essentiel pour les développeurs afin de garantir le bon fonctionnement des services de génération d'images. Cet article présente 3 méthodes pratiques pour surveiller l'API Nano Banana Pro, vous permettant de suivre l'état du service en temps réel et de réagir rapidement en cas de panne.

Valeur ajoutée : En lisant cet article, vous apprendrez à utiliser la page d'état officielle de Google et les outils de surveillance tiers comme OpenRouter pour mettre en place un système complet de suivi de la disponibilité de l'API Nano Banana Pro.

Points clés de la surveillance de l'API Nano Banana Pro

Nano Banana Pro (basé sur Google Imagen 3) est actuellement l'un des modèles de génération d'images par IA les plus performants. Comme il repose sur l'infrastructure Google Cloud, votre stratégie de surveillance doit couvrir plusieurs niveaux.

Indicateurs clés pour la surveillance de l'API Nano Banana Pro

Lors de la surveillance de l'API Nano Banana Pro, vous devez prêter une attention particulière aux indicateurs suivants :

🎯 Conseil technique : Pour vos développements, nous vous recommandons d'utiliser la plateforme APIYI (apiyi.com) pour vos appels API Nano Banana Pro. Elle propose un suivi d'état unifié et des services d'alerte, réduisant ainsi vos coûts de mise en œuvre interne.

Méthode de surveillance 1 de l'API Nano Banana Pro : Page de statut officielle de Google

Surveillance de Google Cloud Status

La page Google Cloud Status fournit des informations en temps réel sur l'état de l'infrastructure Google. C'est la source privilégiée pour surveiller les services sous-jacents de Nano Banana Pro.

Adresse de la page de statut officielle : status.cloud.google.com

Services de surveillance clés

Configuration des abonnements aux statuts

Google Cloud Status prend en charge plusieurs modes d'abonnement :

# Exemple : Utilisation de l'API Google Cloud Status pour obtenir l'état
import requests

def check_google_cloud_status():
    """
    Vérifier l'état des services Google Cloud
    Appel via l'interface unifiée d'APIYI (apiyi.com)
    """
    # Flux RSS Google Cloud Status
    status_url = "https://status.cloud.google.com/incidents.json"

    try:
        response = requests.get(status_url, timeout=10)
        incidents = response.json()

        # Filtrer les incidents liés à Vertex AI
        vertex_incidents = [
            inc for inc in incidents
            if 'Vertex AI' in str(inc.get('affected_products', []))
        ]

        return {
            'status': 'healthy' if not vertex_incidents else 'degraded',
            'incidents': vertex_incidents
        }
    except Exception as e:
        return {'status': 'unknown', 'error': str(e)}

# Exécuter la vérification
result = check_google_cloud_status()
print(f"État de Vertex AI : {result['status']}")

Surveillance d'AI Studio Status

Google AI Studio propose une page de statut dédiée aux modèles Gemini et Imagen.

Adresse de la page de statut AI Studio : aistudio.google.com/status

import requests
from datetime import datetime, timedelta
import json

class AIStudioMonitor:
    """
    Classe de surveillance de l'état d'AI Studio
    Adaptée à la surveillance de l'état du service Nano Banana Pro (Imagen 3)
    """

    def __init__(self, api_key: str):
        self.api_key = api_key
        # Utilisation de l'interface unifiée APIYI
        self.base_url = "https://api.apiyi.com/v1"
        self.status_history = []

    def check_imagen_health(self) -> dict:
        """
        Détecter l'état de santé du service Imagen 3 via un appel API réel
        """
        try:
            headers = {
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json"
            }

            # Envoyer une requête de test légère
            test_payload = {
                "model": "nano-banana-pro",
                "prompt": "health check test",
                "n": 1,
                "size": "256x256"  # Taille minimale pour réduire les coûts
            }

            start_time = datetime.now()
            response = requests.post(
                f"{self.base_url}/images/generations",
                headers=headers,
                json=test_payload,
                timeout=60
            )
            latency = (datetime.now() - start_time).total_seconds()

            if response.status_code == 200:
                return {
                    'status': 'healthy',
                    'latency': latency,
                    'timestamp': datetime.now().isoformat()
                }
            elif response.status_code == 429:
                return {
                    'status': 'rate_limited',
                    'latency': latency,
                    'timestamp': datetime.now().isoformat()
                }
            else:
                return {
                    'status': 'degraded',
                    'error_code': response.status_code,
                    'timestamp': datetime.now().isoformat()
                }

        except requests.Timeout:
            return {
                'status': 'timeout',
                'timestamp': datetime.now().isoformat()
            }
        except Exception as e:
            return {
                'status': 'error',
                'error': str(e),
                'timestamp': datetime.now().isoformat()
            }

    def get_uptime_stats(self, hours: int = 24) -> dict:
        """
        Calculer les statistiques de disponibilité des dernières N heures
        """
        cutoff = datetime.now() - timedelta(hours=hours)
        recent_checks = [
            s for s in self.status_history
            if datetime.fromisoformat(s['timestamp']) > cutoff
        ]

        if not recent_checks:
            return {'uptime': 'N/A', 'sample_count': 0}

        healthy_count = sum(1 for s in recent_checks if s['status'] == 'healthy')
        uptime_pct = (healthy_count / len(recent_checks)) * 100

        return {
            'uptime': f"{uptime_pct:.2f}%",
            'sample_count': len(recent_checks),
            'healthy_count': healthy_count,
            'period_hours': hours
        }

# Exemple d'utilisation
monitor = AIStudioMonitor(api_key="votre-cle-apiyi")
health = monitor.check_imagen_health()
print(f"État de santé de Nano Banana Pro : {health}")

💡 Conseil de choix : Le choix d'une solution de surveillance dépend principalement de vos besoins spécifiques. Nous vous recommandons d'effectuer des tests d'appels API via la plateforme APIYI (apiyi.com), qui propose un tableau de bord de surveillance intégré pour visualiser rapidement la disponibilité du service.

Méthode de surveillance 2 de l'API Nano Banana Pro : Surveillance tierce via OpenRouter

OpenRouter propose un service professionnel de surveillance de modèles d'IA tiers, ce qui constitue un complément important pour surveiller la disponibilité de l'API Nano Banana Pro.

Page de surveillance de la disponibilité (Uptime) OpenRouter

Adresse de surveillance de Nano Banana Pro : openrouter.ai/google/gemini-3-pro-image-preview/uptime

Interprétation des données de surveillance OpenRouter

Script de récupération des données de surveillance

import requests
from bs4 import BeautifulSoup
import json

def get_openrouter_uptime(model_id: str = "google/gemini-3-pro-image-preview"):
    """
    获取 OpenRouter 模型可用性数据
    适用于 Nano Banana Pro (Imagen 3) 监控
    """
    uptime_url = f"https://openrouter.ai/{model_id}/uptime"

    # 注意: OpenRouter 可能需要 API 调用获取详细数据
    # 这里展示基本的可用性检查思路

    try:
        # 通过 OpenRouter API 获取模型信息
        api_url = "https://openrouter.ai/api/v1/models"
        response = requests.get(api_url, timeout=10)
        models = response.json().get('data', [])

        # 查找目标模型
        target_model = next(
            (m for m in models if m.get('id') == model_id),
            None
        )

        if target_model:
            return {
                'model_id': model_id,
                'status': 'available' if target_model else 'unknown',
                'pricing': target_model.get('pricing', {}),
                'context_length': target_model.get('context_length'),
                'uptime_url': uptime_url
            }
        else:
            return {
                'model_id': model_id,
                'status': 'not_found',
                'uptime_url': uptime_url
            }

    except Exception as e:
        return {
            'model_id': model_id,
            'status': 'error',
            'error': str(e)
        }

# 检查 Nano Banana Pro 状态
nano_status = get_openrouter_uptime()
print(json.dumps(nano_status, indent=2))

Surveillance comparative multi-modèles

Grâce à OpenRouter, vous pouvez surveiller simultanément l'état de plusieurs modèles de génération d'images :

🚀 Démarrage rapide : Nous recommandons d'utiliser la plateforme APIYI (apiyi.com) pour prototyper rapidement vos projets de génération d'images. Cette plateforme offre une capacité de basculement multi-modèles prête à l'emploi, permettant de passer automatiquement à un modèle de secours si le modèle principal est indisponible.

Méthode de surveillance 3 de l'API Nano Banana Pro : La détection active

En plus de l'abonnement passif aux pages de statut, la détection active (probing) est un levier essentiel pour garantir la stabilité de votre activité.

Script de détection périodique

import openai
import time
import json
from datetime import datetime
import schedule

# 使用 APIYI 统一接口
client = openai.OpenAI(
    api_key="your-apiyi-key",
    base_url="https://api.apiyi.com/v1"
)

class NanoBananaProMonitor:
    """
    Nano Banana Pro API 主动探测监控
    """

    def __init__(self):
        self.check_results = []
        self.alert_threshold = 3  # 连续失败 3 次触发告警
        self.consecutive_failures = 0

    def health_check(self) -> dict:
        """
        执行一次健康检查
        """
        start_time = time.time()

        try:
            response = client.images.generate(
                model="nano-banana-pro",
                prompt="A simple red circle on white background",
                n=1,
                size="256x256"
            )

            latency = time.time() - start_time

            result = {
                'timestamp': datetime.now().isoformat(),
                'status': 'success',
                'latency': round(latency, 2),
                'model': 'nano-banana-pro'
            }

            self.consecutive_failures = 0

        except openai.RateLimitError:
            result = {
                'timestamp': datetime.now().isoformat(),
                'status': 'rate_limited',
                'latency': time.time() - start_time,
                'model': 'nano-banana-pro'
            }
            # Rate limit 不计入失败

        except openai.APIError as e:
            result = {
                'timestamp': datetime.now().isoformat(),
                'status': 'api_error',
                'error': str(e),
                'model': 'nano-banana-pro'
            }
            self.consecutive_failures += 1

        except Exception as e:
            result = {
                'timestamp': datetime.now().isoformat(),
                'status': 'error',
                'error': str(e),
                'model': 'nano-banana-pro'
            }
            self.consecutive_failures += 1

        self.check_results.append(result)

        # 检查是否需要告警
        if self.consecutive_failures >= self.alert_threshold:
            self.send_alert(result)

        return result

    def send_alert(self, result: dict):
        """
        发送告警通知
        可对接: 企业微信、钉钉、飞书、Slack、邮件等
        """
        alert_message = f"""
        🚨 Nano Banana Pro API 告警

        状态: {result.get('status')}
        时间: {result.get('timestamp')}
        错误: {result.get('error', 'N/A')}
        连续失败: {self.consecutive_failures} 次
        """

        print(alert_message)
        # 实际项目中对接通知渠道
        # self.send_wechat(alert_message)
        # self.send_feishu(alert_message)

    def get_statistics(self, hours: int = 24) -> dict:
        """
        获取监控统计数据
        """
        from datetime import timedelta

        cutoff = datetime.now() - timedelta(hours=hours)
        recent = [
            r for r in self.check_results
            if datetime.fromisoformat(r['timestamp']) > cutoff
        ]

        if not recent:
            return {'message': 'No data available'}

        success_count = sum(1 for r in recent if r['status'] == 'success')
        total_count = len(recent)

        latencies = [r['latency'] for r in recent if 'latency' in r and r['status'] == 'success']
        avg_latency = sum(latencies) / len(latencies) if latencies else 0

        return {
            'period_hours': hours,
            'total_checks': total_count,
            'success_count': success_count,
            'uptime_percentage': round((success_count / total_count) * 100, 2),
            'avg_latency': round(avg_latency, 2),
            'last_check': recent[-1] if recent else None
        }

# 创建监控实例
monitor = NanoBananaProMonitor()

# 设置定时任务: 每 5 分钟检查一次
schedule.every(5).minutes.do(monitor.health_check)

# 运行监控 (生产环境使用)
# while True:
#     schedule.run_pending()
#     time.sleep(1)

# 单次检查示例
result = monitor.health_check()
print(json.dumps(result, indent=2, ensure_ascii=False))

import openai
import requests
import time
import json
import schedule
import threading
from datetime import datetime, timedelta
from typing import Optional, List, Dict
from dataclasses import dataclass, asdict
from enum import Enum

class AlertChannel(Enum):
    FEISHU = "feishu"
    WECHAT = "wechat"
    DINGTALK = "dingtalk"
    SLACK = "slack"
    EMAIL = "email"

@dataclass
class CheckResult:
    timestamp: str
    status: str
    latency: Optional[float] = None
    error: Optional[str] = None
    model: str = "nano-banana-pro"

@dataclass
class AlertConfig:
    enabled: bool = True
    channels: List[AlertChannel] = None
    threshold: int = 3
    cooldown_minutes: int = 30
    webhook_urls: Dict[str, str] = None

class EnterpriseMonitor:
    """
    企业级 Nano Banana Pro API 监控系统
    支持多通道告警、数据持久化、监控面板
    """

    def __init__(
        self,
        api_key: str,
        base_url: str = "https://api.apiyi.com/v1",
        alert_config: Optional[AlertConfig] = None
    ):
        self.client = openai.OpenAI(
            api_key=api_key,
            base_url=base_url
        )
        self.alert_config = alert_config or AlertConfig()
        self.check_results: List[CheckResult] = []
        self.consecutive_failures = 0
        self.last_alert_time: Optional[datetime] = None
        self._lock = threading.Lock()

    def health_check(self) -> CheckResult:
        """
        执行健康检查
        """
        start_time = time.time()

        try:
            response = self.client.images.generate(
                model="nano-banana-pro",
                prompt="health check: simple geometric shape",
                n=1,
                size="256x256"
            )

            latency = time.time() - start_time
            result = CheckResult(
                timestamp=datetime.now().isoformat(),
                status="success",
                latency=round(latency, 2)
            )

            with self._lock:
                self.consecutive_failures = 0

        except openai.RateLimitError:
            result = CheckResult(
                timestamp=datetime.now().isoformat(),
                status="rate_limited",
                latency=round(time.time() - start_time, 2)
            )

        except openai.APIError as e:
            result = CheckResult(
                timestamp=datetime.now().isoformat(),
                status="api_error",
                error=str(e)
            )
            with self._lock:
                self.consecutive_failures += 1

        except Exception as e:
            result = CheckResult(
                timestamp=datetime.now().isoformat(),
                status="error",
                error=str(e)
            )
            with self._lock:
                self.consecutive_failures += 1

        with self._lock:
            self.check_results.append(result)

            # 保留最近 1000 条记录
            if len(self.check_results) > 1000:
                self.check_results = self.check_results[-1000:]

        # 检查告警条件
        self._check_alert(result)

        return result

    def _check_alert(self, result: CheckResult):
        """
        检查是否需要发送告警
        """
        if not self.alert_config.enabled:
            return

        if self.consecutive_failures < self.alert_config.threshold:
            return

        # 检查告警冷却
        if self.last_alert_time:
            cooldown = timedelta(minutes=self.alert_config.cooldown_minutes)
            if datetime.now() - self.last_alert_time < cooldown:
                return

        self._send_alerts(result)
        self.last_alert_time = datetime.now()

    def _send_alerts(self, result: CheckResult):
        """
        发送多通道告警
        """
        message = self._format_alert_message(result)

        if not self.alert_config.webhook_urls:
            print(f"[ALERT] {message}")
            return

        for channel, webhook_url in self.alert_config.webhook_urls.items():
            try:
                if channel == "feishu":
                    self._send_feishu_alert(webhook_url, message)
                elif channel == "wechat":
                    self._send_wechat_alert(webhook_url, message)
                elif channel == "dingtalk":
                    self._send_dingtalk_alert(webhook_url, message)
                elif channel == "slack":
                    self._send_slack_alert(webhook_url, message)
            except Exception as e:
                print(f"Failed to send {channel} alert: {e}")

    def _format_alert_message(self, result: CheckResult) -> str:
        """
        格式化告警消息
        """
        return f"""
🚨 Nano Banana Pro API 异常告警

📊 状态详情:
• 状态: {result.status}
• 时间: {result.timestamp}
• 错误: {result.error or 'N/A'}
• 连续失败: {self.consecutive_failures} 次

🔗 监控来源:
• Google Cloud Status: status.cloud.google.com
• OpenRouter Uptime: openrouter.ai/google/gemini-3-pro-image-preview/uptime
• APIYI 监控: apiyi.com

⚡ 建议操作:
1. 检查 Google Cloud 状态页
2. 验证 API 密钥是否有效
3. 检查网络连接状态
4. 联系 APIYI 技术支持
        """.strip()

    def _send_feishu_alert(self, webhook_url: str, message: str):
        """飞书机器人告警"""
        payload = {
            "msg_type": "text",
            "content": {"text": message}
        }
        requests.post(webhook_url, json=payload, timeout=10)

    def _send_wechat_alert(self, webhook_url: str, message: str):
        """企业微信机器人告警"""
        payload = {
            "msgtype": "text",
            "text": {"content": message}
        }
        requests.post(webhook_url, json=payload, timeout=10)

    def _send_dingtalk_alert(self, webhook_url: str, message: str):
        """钉钉机器人告警"""
        payload = {
            "msgtype": "text",
            "text": {"content": message}
        }
        requests.post(webhook_url, json=payload, timeout=10)

    def _send_slack_alert(self, webhook_url: str, message: str):
        """Slack 机器人告警"""
        payload = {"text": message}
        requests.post(webhook_url, json=payload, timeout=10)

    def get_dashboard_data(self) -> dict:
        """
        获取监控面板数据
        """
        now = datetime.now()

        # 计算不同时间段统计
        periods = {
            '1h': timedelta(hours=1),
            '6h': timedelta(hours=6),
            '24h': timedelta(hours=24),
            '7d': timedelta(days=7)
        }

        stats = {}
        for period_name, delta in periods.items():
            cutoff = now - delta
            recent = [
                r for r in self.check_results
                if datetime.fromisoformat(r.timestamp) > cutoff
            ]

            if recent:
                success = sum(1 for r in recent if r.status == 'success')
                latencies = [r.latency for r in recent if r.latency]

                stats[period_name] = {
                    'total': len(recent),
                    'success': success,
                    'uptime': round((success / len(recent)) * 100, 2),
                    'avg_latency': round(sum(latencies) / len(latencies), 2) if latencies else None
                }
            else:
                stats[period_name] = None

        return {
            'model': 'nano-banana-pro',
            'current_status': self.check_results[-1].status if self.check_results else 'unknown',
            'consecutive_failures': self.consecutive_failures,
            'statistics': stats,
            'last_update': now.isoformat()
        }

# 使用示例
if __name__ == "__main__":
    # 配置告警
    alert_config = AlertConfig(
        enabled=True,
        threshold=3,
        cooldown_minutes=30,
        webhook_urls={
            "feishu": "https://open.feishu.cn/open-apis/bot/v2/hook/xxx",
            # "wechat": "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=xxx",
        }
    )

    # 创建监控实例
    monitor = EnterpriseMonitor(
        api_key="your-apiyi-key",
        base_url="https://api.apiyi.com/v1",
        alert_config=alert_config
    )

    # 执行检查
    result = monitor.health_check()
    print("检查结果:", asdict(result))

    # 获取面板数据
    dashboard = monitor.get_dashboard_data()
    print("面板数据:", json.dumps(dashboard, indent=2, ensure_ascii=False))

Configuration des alertes de surveillance de l'API Nano Banana Pro

Intégration des canaux d'alerte

Définition des niveaux d'alerte

# Configuration des niveaux d'alerte
ALERT_LEVELS = {
    'info': {
        'triggers': ['rate_limited'],
        'channels': ['log'],
        'color': '#36a64f'
    },
    'warning': {
        'triggers': ['timeout', 'degraded'],
        'channels': ['feishu', 'slack'],
        'color': '#ff9800'
    },
    'critical': {
        'triggers': ['api_error', 'error'],
        'channels': ['feishu', 'wechat', 'slack', 'email'],
        'color': '#f44336'
    }
}

💰 Optimisation des coûts : Pour les projets sensibles au budget, vous pouvez envisager d'appeler l'API Nano Banana Pro via la plateforme APIYI (apiyi.com). Cette plateforme propose des modes de facturation flexibles et des fonctions de surveillance intégrées, réduisant ainsi les coûts liés à la mise en place d'une infrastructure de monitoring propre.

Bonnes pratiques de surveillance de l'API Nano Banana Pro

Combinaisons de stratégies de surveillance

Choisissez la combinaison de stratégies de surveillance la plus adaptée en fonction de la criticité de votre activité :

Processus de réponse aux incidents

Anomalie détectée
    ↓
Confirmer la portée de l'impact (Production / Test)
    ↓
Vérifier la page de statut officielle
    ↓
├── Panne confirmée par l'officiel → Attendre le rétablissement + Informer les utilisateurs
├── Statut officiel normal → Vérifier sa propre configuration
│   ├── Validité de la clé API
│   ├── État de consommation des quotas
│   ├── État de la connexion réseau
│   └── Conformité des paramètres de la requête
└── Impossible de déterminer → Contacter le support technique

Analyse des données de surveillance

import pandas as pd
from datetime import datetime, timedelta

def analyze_monitoring_data(check_results: list) -> dict:
    """
    Analyse les données de surveillance et génère un rapport
    """
    df = pd.DataFrame(check_results)
    df['timestamp'] = pd.to_datetime(df['timestamp'])

    # Statistiques par heure
    df['hour'] = df['timestamp'].dt.floor('H')
    hourly_stats = df.groupby('hour').agg({
        'status': lambda x: (x == 'success').mean() * 100,
        'latency': 'mean'
    }).rename(columns={
        'status': 'uptime_pct',
        'latency': 'avg_latency'
    })

    # Identifier les périodes d'anomalie
    anomalies = hourly_stats[hourly_stats['uptime_pct'] < 99]

    # Tendance de la latence
    df['date'] = df['timestamp'].dt.date
    daily_latency = df.groupby('date')['latency'].mean()

    return {
        'hourly_stats': hourly_stats.to_dict(),
        'anomaly_periods': anomalies.index.tolist(),
        'daily_latency_trend': daily_latency.to_dict(),
        'overall_uptime': df[df['status'] == 'success'].shape[0] / len(df) * 100
    }

Questions fréquemment posées

Résumé

La surveillance de la disponibilité de l'API Nano Banana Pro est un maillon essentiel pour garantir la stabilité de vos services de génération d'images. Cet article a présenté 3 méthodes de surveillance pratiques :

1. Page de statut officielle de Google : Surveillez le "Cloud Status" et l' "AI Studio Status" pour obtenir des informations officielles de première main.
2. Surveillance tierce via OpenRouter : Utilisez la page Uptime d'openrouter.ai pour accéder aux données de disponibilité de la communauté.
3. Surveillance par sondage actif : Réalisez des vérifications de disponibilité de bout en bout grâce à des appels API planifiés.

Nous vous recommandons d'utiliser APIYI (apiyi.com) pour tester rapidement l'efficacité de votre solution de surveillance. Cette plateforme propose une interface API unifiée et un tableau de bord de surveillance intégré, aidant les développeurs à réduire leurs coûts d'exploitation et de maintenance.

Auteur : Équipe technique APIYI

Échanges techniques : N'hésitez pas à visiter APIYI (apiyi.com) pour plus d'astuces et de meilleures pratiques sur l'utilisation des API d'IA.

Date de mise à jour : 28 janvier 2026

Ressources utiles