Domine 3 métodos práticos para monitoramento de disponibilidade da API Nano Banana Pro

import requests
from datetime import datetime, timedelta
import json

class AIStudioMonitor:
    """
    Classe de monitoramento de status do AI Studio
    Adequado para monitorar o status do serviço Nano Banana Pro (Imagen 3)
    """

    def __init__(self, api_key: str):
        self.api_key = api_key
        # Usa a interface unificada da APIYI
        self.base_url = "https://api.apiyi.com/v1"
        self.status_history = []

    def check_imagen_health(self) -> dict:
        """
        Detecta o estado de saúde do serviço Imagen 3 através de chamadas de API reais
        """
        try:
            headers = {
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json"
            }

            # Envia uma solicitação de teste leve
            test_payload = {
                "model": "nano-banana-pro",
                "prompt": "health check test",
                "n": 1,
                "size": "256x256"  # Tamanho mínimo para reduzir custos
            }

            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:
        """
        Calcula estatísticas de disponibilidade para as últimas N horas
        """
        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
        }

# Exemplo de uso
monitor = AIStudioMonitor(api_key="seu-token-apiyi")
health = monitor.check_imagen_health()
print(f"Estado de saúde do Nano Banana Pro: {health}")

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:
    """
    Sistema de monitoramento empresarial da API Nano Banana Pro.
    Suporta alertas multicanal, persistência de dados e painel de monitoramento.
    """

    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:
        """
        Executa a verificação de integridade (health check)
        """
        start_time = time.time()

        try:
            # Usando um comando simples para teste
            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)

            # Mantém os últimos 1000 registros
            if len(self.check_results) > 1000:
                self.check_results = self.check_results[-1000:]

        # Verifica condições de alerta
        self._check_alert(result)

        return result

    def _check_alert(self, result: CheckResult):
        """
        Verifica se é necessário enviar um alerta
        """
        if not self.alert_config.enabled:
            return

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

        # Verifica o intervalo de "resfriamento" (cooldown) do alerta
        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):
        """
        Envia alertas por múltiplos canais
        """
        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:
        """
        Formata a mensagem de alerta
        """
        return f"""
🚨 Alerta de Anomalia na API Nano Banana Pro

📊 Detalhes do Status:
• Status: {result.status}
• Horário: {result.timestamp}
• Erro: {result.error or 'N/A'}
• Falhas consecutivas: {self.consecutive_failures} vezes

🔗 Fonte de monitoramento:
• Google Cloud Status: status.cloud.google.com
• OpenRouter Uptime: openrouter.ai/google/gemini-3-pro-image-preview/uptime
• Monitoramento APIYI: apiyi.com

⚡ Ações Sugeridas:
1. Verifique a página de status do Google Cloud
2. Valide se a chave da API é válida
3. Verifique o status da conexão de rede
4. Entre em contato com o suporte técnico da APIYI
        """.strip()

    def _send_feishu_alert(self, webhook_url: str, message: str):
        """Alerta via bot do Feishu"""
        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):
        """Alerta via bot do WeChat Work (Enterprise WeChat)"""
        payload = {
            "msgtype": "text",
            "text": {"content": message}
        }
        requests.post(webhook_url, json=payload, timeout=10)

    def _send_dingtalk_alert(self, webhook_url: str, message: str):
        """Alerta via bot do DingTalk"""
        payload = {
            "msgtype": "text",
            "text": {"content": message}
        }
        requests.post(webhook_url, json=payload, timeout=10)

    def _send_slack_alert(self, webhook_url: str, message: str):
        """Alerta via bot do Slack"""
        payload = {"text": message}
        requests.post(webhook_url, json=payload, timeout=10)

    def get_dashboard_data(self) -> dict:
        """
        Obtém dados para o painel de monitoramento
        """
        now = datetime.now()

        # Calcula estatísticas para diferentes períodos
        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()
        }

# Exemplo de uso
if __name__ == "__main__":
    # Configuração de alertas
    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",
        }
    )

    # Cria instância de monitoramento
    monitor = EnterpriseMonitor(
        api_key="your-apiyi-key",
        base_url="https://api.apiyi.com/v1",
        alert_config=alert_config
    )

    # Executa a verificação
    result = monitor.health_check()
    print("Resultado da verificação:", asdict(result))

    # Obtém dados do painel
    dashboard = monitor.get_dashboard_data()
    print("Dados do painel:", json.dumps(dashboard, indent=2, ensure_ascii=False))

A frequência de monitoramento depende da importância do seu negócio:

• Ambientes de produção críticos: Recomendamos verificar a cada 1-2 minutos.
• Negócios importantes: Verificar a cada 5 minutos.
• Negócios comuns: Verificar a cada 10-15 minutos.

Através da plataforma APIYI (apiyi.com), você pode obter créditos de teste gratuitos para validar rapidamente a viabilidade do seu plano de monitoramento. Lembre-se de equilibrar o custo do monitoramento com a velocidade de resposta necessária.

Sugerimos adotar as seguintes estratégias:

1. Limite de falhas consecutivas: Configure o alerta para disparar apenas após 3 ou mais falhas seguidas.
2. Janela deslizante: Considere uma falha real apenas se a taxa de erro for superior a 50% em um intervalo de 5 minutos.
3. Validação multi-fonte: Verifique simultaneamente a página de status oficial para confirmar se é um problema global.
4. Descartar Rate Limit: Limitação de taxa (muitas requisições) não é o mesmo que uma falha no sistema.

Pelo painel de monitoramento da APIYI (apiyi.com), você consegue visualizar intuitivamente as tendências históricas de disponibilidade, facilitando o julgamento de falhas sistêmicas.

Como uma plataforma agregadora de modelos de IA bem conhecida, os dados do OpenRouter têm alto valor de referência:

• Vantagem: Agregam dados de requisições de usuários globais, oferecendo uma grande base de amostras.
• Limitação: Os dados podem incluir problemas na própria infraestrutura de rede do OpenRouter.
• Sugestão: Combine as informações da página de status oficial com seu próprio monitoramento para uma análise mais precisa.

A fadiga de alertas é um problema comum. Recomendamos:

1. Definir níveis de alerta: Diferencie entre Informação, Aviso (Warning) e Crítico.
2. Configurar tempo de espera (Cooldown): Configure para que o mesmo problema gere apenas um alerta a cada 30 minutos.
3. Agrupar alertas: Combine problemas semelhantes em uma única notificação.
4. Supressão de alertas: Desative temporariamente os alertas durante períodos de manutenção programada.
5. Otimização contínua: Revise regularmente os falsos positivos e ajuste os limites de disparo.

Resumo

O monitoramento de disponibilidade da API Nano Banana Pro é fundamental para garantir a estabilidade de operações de geração de imagens. Este artigo apresentou 3 métodos práticos de monitoramento:

1. Página de Status oficial do Google: Monitore o Cloud Status e o AI Studio Status para obter informações oficiais de primeira mão.
2. Monitoramento de terceiros (OpenRouter): Utilize a página de Uptime do openrouter.ai para obter dados de disponibilidade da comunidade.
3. Sondagem ativa: Implemente chamadas de API periódicas para realizar uma verificação de disponibilidade de ponta a ponta.

Recomendamos utilizar a APIYI (apiyi.com) para validar rapidamente a eficácia da sua estratégia de monitoramento. A plataforma oferece uma interface de API unificada e painéis de monitoramento integrados, ajudando desenvolvedores a reduzir custos operacionais.

Autor: Equipe Técnica APIYI

Troca de experiências técnicas: Visite APIYI (apiyi.com) para mais dicas e melhores práticas sobre o uso de APIs de IA.

Data de atualização: 28 de janeiro de 2026

Recursos Relacionados