企业官网建设流程全解析

在实际 AI 应用开发中，图像和视频生成往往面临两个核心挑战：既要保证生成质量，又要控制成本和响应时间。Google 最新发布的 Gemini Nano Banana 2 Lite 和 Gemini Omni Flash 正是针对这两个不同场景的优化方案。Nano Banana 2 Lite 专注于高速、低成本的图像生成，而 Omni Flash 则提供了高质量的视频生成和对话式编辑能力。对于需要构建端到端多媒体体验的开发者来说，这两款模型的组合使用可以显著提升创作效率。

本文将基于官方发布的技术细节，详细介绍如何在实际项目中集成和使用这两款模型。我们会从环境准备开始，逐步讲解 API 调用方法、参数配置技巧，并通过完整示例展示如何将图像生成与视频动画流程串联起来。最后还会分享在实际部署中可能遇到的常见问题及排查方法。

1. 理解 Gemini Nano Banana 2 Lite 和 Omni Flash 的定位差异

在选择合适的 AI 模型时，首先需要明确不同模型的适用场景。Google 的 Gemini 系列模型针对不同的性能需求和成本约束提供了多个版本，Nano Banana 2 Lite 和 Omni Flash 分别专注于图像和视频生成的两个关键维度。

1.1 Nano Banana 2 Lite：为速度和成本优化的小型图像模型

Nano Banana 2 Lite（模型标识符：gemini-3.1-flash-lite-image）是 Gemini 图像生成模型家族中的轻量级版本，专门为高吞吐量、低延迟场景设计。与之前的版本相比，它在保持合理生成质量的同时，显著提升了响应速度并降低了使用成本。

关键性能指标：

• 生成延迟：平均 4 秒完成文本到图像的生成
• 成本效率：每张 1K 分辨率图像仅需 $0.034
• 适用场景：交互式原型设计、快速视觉草稿生成、批量图像处理

在实际项目中，这意味着如果应用需要实时生成大量图像预览，或者预算有限但需要处理大量图像生成任务，Nano Banana 2 Lite 是最合适的选择。它特别适合电商平台的商品图生成、内容创作工具的快速预览功能等场景。

1.2 Omni Flash：多模态视频生成与编辑的专业工具

Gemini Omni Flash（模型标识符：gemini-omni-flash-preview）是 Google 在视频生成领域的重要进展，它将 Gemini 的多模态推理能力与视频生成技术相结合。与传统的视频生成模型不同，Omni Flash 支持基于自然语言的对话式编辑，允许开发者通过文本指令对视频进行精细化调整。

核心特性：

• 多模态输入：支持文本、图像、视频的组合输入
• 对话式编辑：可通过自然语言指令迭代修改视频内容
• 知识整合：利用 Gemini 的广泛知识库生成符合逻辑的视频叙事
• 成本结构：按视频输出时长计费，每秒 $0.10

当前版本支持生成 10 秒时长的视频，较长的视频生成功能将在后续版本中提供。对于需要制作营销视频、教育内容或创意短片的项目，Omni Flash 提供了强大的创作工具。

1.3 模型选型决策指南

为了帮助开发者根据具体需求选择合适的模型，以下对比表总结了关键差异：

在实际项目规划中，如果工作流程同时涉及图像和视频生成，可以考虑组合使用这两个模型：先用 Nano Banana 2 Lite 快速生成基础图像，再将其作为输入传递给 Omni Flash 进行视频动画处理。

2. 环境准备与 API 配置

要开始使用 Google 的 Gemini 模型，需要先完成开发环境的准备工作。这包括获取 API 访问权限、配置认证凭证以及安装必要的开发工具。

2.1 获取 Google AI Studio 访问权限

Google AI Studio 是体验和测试 Gemini 模型的最便捷途径，它提供了基于 Web 的交互式界面，无需编写代码即可快速验证模型能力。

访问步骤：

1. 打开 Google AI Studio 网站
2. 使用 Google 账号登录
3. 在模型选择界面中，找到 "Gemini 3.1 Flash Lite Image"（Nano Banana 2 Lite）和 "Gemini Omni Flash Preview"（Omni Flash）
4. 开始通过提示词测试模型响应

AI Studio 的免费额度通常足够进行初步的功能验证，但要注意用量限制。对于生产环境的使用，需要通过 Gemini API 进行集成。

2.2 设置 Gemini API 访问凭证

要通过代码调用 Gemini 模型，需要先创建 API 密钥并配置到开发环境中。

创建 API 密钥的步骤：

1. 访问 Google AI Studio 的 API 密钥管理页面
2. 点击 "Create API Key" 按钮
3. 为密钥设置描述性名称（如 "production-gemini-api"）
4. 复制生成的 API 密钥并安全存储

重要：API 密钥具有完全的账户访问权限，切勿直接提交到代码仓库或客户端应用中。生产环境应使用环境变量或安全的密钥管理服务。

2.3 安装必要的开发依赖

根据使用的编程语言，需要安装相应的 Google Gemini SDK。以下以 Python 为例展示环境配置：

# 安装 Google 的 Generative AI Python SDK pip install google-generativeai # 如果需要处理图像和视频文件，建议安装额外的依赖 pip install pillow opencv-python

对于其他语言的支持，Google 提供了多种官方 SDK：

• JavaScript/Node.js:@google/generative-ai
• Java:google-cloud-aiplatform（通过 Vertex AI）
• Go:cloud.google.com/go/aiplatform

验证安装是否成功：

import google.generativeai as genai # 配置 API 密钥（实际项目中应从环境变量读取） genai.configure(api_key="YOUR_API_KEY") # 列出可用模型，验证连接 models = genai.list_models() for model in models: if 'gemini' in model.name: print(f"找到模型: {model.name}")

2.4 项目结构规划

对于集成 Gemini 模型的应用，建议采用模块化的项目结构：

gemini-integration-project/ ├── config/ │ └── api_config.py # API 配置管理 ├── services/ │ ├── image_generation.py # Nano Banana 2 Lite 服务 │ └── video_generation.py # Omni Flash 服务 ├── utils/ │ ├── file_processor.py # 文件处理工具 │ └── prompt_optimizer.py # 提示词优化 ├── examples/ │ ├── basic_usage.py # 基础使用示例 │ └── workflow_demo.py # 完整工作流演示 └── requirements.txt # 项目依赖

这种结构有助于分离关注点，使图像生成和视频生成逻辑保持独立，便于后续维护和扩展。

3. 使用 Nano Banana 2 Lite 进行图像生成

Nano Banana 2 Lite 的核心优势在于其快速的图像生成能力。在实际集成中，不仅需要掌握基本的 API 调用方法，还需要了解如何通过参数调优获得最佳结果。

3.1 基础图像生成实现

以下代码展示了如何使用 Python SDK 调用 Nano Banana 2 Lite 生成图像：

import google.generativeai as genai import PIL.Image import io class NanoBananaImageGenerator: def __init__(self, api_key): genai.configure(api_key=api_key) self.model = genai.GenerativeModel('gemini-3.1-flash-lite-image') def generate_image(self, prompt, width=1024, height=1024, output_format='JPEG'): """ 使用 Nano Banana 2 Lite 生成图像 Args: prompt (str): 图像描述提示词 width (int): 图像宽度，默认1024 height (int): 图像高度，默认1024 output_format (str): 输出格式，JPEG或PNG Returns: PIL.Image.Image: 生成的图像对象 """ try: # 构建生成配置 generation_config = { "temperature": 0.7, # 控制创造性，0-1范围 "top_k": 40, # 采样多样性 "top_p": 0.95, # 核采样参数 "max_output_tokens": 2048, } # 调用模型生成图像 response = self.model.generate_content( prompt, generation_config=generation_config, stream=False ) # 处理响应并转换为图像 if response.candidates and response.candidates[0].content.parts: image_data = response.candidates[0].content.parts[0].inline_data.data image = PIL.Image.open(io.BytesIO(image_data)) # 调整尺寸（如果与默认不同） if image.size != (width, height): image = image.resize((width, height), PIL.Image.Resampling.LANCZOS) return image else: raise ValueError("API 响应中未找到图像数据") except Exception as e: print(f"图像生成失败: {str(e)}") return None # 使用示例 if __name__ == "__main__": generator = NanoBananaImageGenerator(api_key="your_api_key_here") # 生成一张风景图像 prompt = "一张日落时分的海滩风景，有棕榈树和波浪，风格写实" image = generator.generate_image(prompt) if image: image.save("generated_beach.png", "PNG") print("图像生成成功并已保存")

3.2 高级提示词技巧与参数优化

Nano Banana 2 Lite 对提示词的质量比较敏感。以下是一些经过验证的提示词优化策略：

结构化提示词模板：

[主体描述] + [环境背景] + [风格指示] + [技术参数] 示例： "一位穿着现代商务装的专业人士（主体），在现代化的办公室环境中（背景），照片级真实感，柔和自然光线（风格），4K分辨率，细节丰富（参数）"

负面提示词的使用：在提示词中明确排除不想要的元素可以显著改善输出质量：

positive_prompt = "一个干净的现代客厅，有简约家具和大窗户" negative_prompt = "避免杂乱、昏暗光线、老旧家具" effective_prompt = f"{positive_prompt}。不要包含：{negative_prompt}"

参数调优建议：

3.3 批量生成与性能优化

对于需要大量图像的应用场景，可以通过异步处理和连接池优化提升吞吐量：

import asyncio import aiohttp from concurrent.futures import ThreadPoolExecutor class BatchImageGenerator: def __init__(self, api_key, max_workers=5): self.api_key = api_key self.max_workers = max_workers async def generate_batch(self, prompts, callback=None): """批量生成图像，支持进度回调""" results = [] # 使用线程池处理IO密集型任务 with ThreadPoolExecutor(max_workers=self.max_workers) as executor: loop = asyncio.get_event_loop() tasks = [] for i, prompt in enumerate(prompts): task = loop.run_in_executor( executor, self._generate_single, prompt, i ) tasks.append(task) # 等待所有任务完成 for task in asyncio.as_completed(tasks): result = await task results.append(result) if callback: callback(result) return results def _generate_single(self, prompt, index): """单个图像生成任务""" generator = NanoBananaImageGenerator(self.api_key) image = generator.generate_image(prompt) return { 'index': index, 'prompt': prompt, 'image': image, 'success': image is not None } # 使用示例 async def main(): prompts = [ "春天的花园，鲜花盛开", "夏日的海滩，阳光明媚", "秋天的森林，落叶纷飞", "冬天的雪山，白雪皑皑" ] def progress_callback(result): print(f"完成第 {result['index'] + 1} 张图像生成") generator = BatchImageGenerator(api_key="your_api_key") results = await generator.generate_batch(prompts, progress_callback) success_count = sum(1 for r in results if r['success']) print(f"批量生成完成，成功 {success_count}/{len(prompts)}") # asyncio.run(main())

这种批量处理方式可以充分利用 Nano Banana 2 Lite 的低延迟特性，在短时间内生成大量图像，特别适合电商平台的产品图生成、内容创作平台的模板生成等场景。

4. 集成 Omni Flash 进行视频生成与编辑

Gemini Omni Flash 的视频生成能力为多媒体应用开辟了新的可能性。与传统的视频生成工具不同，Omni Flash 支持基于多模态输入的对话式编辑，大大提升了创作的灵活性和效率。

4.1 基础视频生成流程

以下代码展示了如何使用 Omni Flash 生成基础视频：

import google.generativeai as genai import base64 import json from typing import Optional, Dict, Any class OmniFlashVideoGenerator: def __init__(self, api_key): genai.configure(api_key=api_key) self.model = genai.GenerativeModel('gemini-omni-flash-preview') def generate_video(self, prompt: str, reference_image: Optional[str] = None, duration_seconds: int = 10) -> Dict[str, Any]: """ 使用 Omni Flash 生成视频 Args: prompt: 视频描述提示词 reference_image: 参考图像的base64编码或文件路径 duration_seconds: 视频时长（秒），当前最大10秒 Returns: 包含视频数据和元信息的字典 """ try: # 构建多模态输入 contents = [] # 文本提示词部分 text_part = { "text": f"生成一个{duration_seconds}秒的视频：{prompt}" } contents.append(text_part) # 如果提供了参考图像 if reference_image: image_part = self._prepare_image_input(reference_image) contents.append(image_part) # 视频生成配置 generation_config = { "temperature": 0.3, # 视频生成建议使用较低temperature "video_length": duration_seconds, "resolution": "1024x576" # 支持多种分辨率 } # 调用API生成视频 response = self.model.generate_content( contents, generation_config=generation_config, stream=False ) return self._process_video_response(response) except Exception as e: print(f"视频生成失败: {str(e)}") return {"success": False, "error": str(e)} def _prepare_image_input(self, image_input: str) -> Dict[str, Any]: """准备图像输入数据""" if image_input.startswith('data:image'): # 已经是base64格式 image_data = image_input.split(',')[1] else: # 从文件读取 with open(image_input, "rb") as f: image_data = base64.b64encode(f.read()).decode('utf-8') return { "inline_data": { "mime_type": "image/jpeg", "data": image_data } } def _process_video_response(self, response) -> Dict[str, Any]: """处理视频生成响应""" if (response.candidates and response.candidates[0].content.parts and response.candidates[0].content.parts[0].inline_data): video_data = response.candidates[0].content.parts[0].inline_data.data mime_type = response.candidates[0].content.parts[0].inline_data.mime_type return { "success": True, "video_data": base64.b64decode(video_data), "mime_type": mime_type, "duration": 10 # 当前固定10秒 } else: return {"success": False, "error": "响应中未找到视频数据"} # 使用示例 def create_simple_video(): generator = OmniFlashVideoGenerator(api_key="your_api_key") prompt = "一只蝴蝶在花丛中飞舞的慢动作视频，阳光明媚，风格自然纪录片" result = generator.generate_video(prompt) if result["success"]: with open("generated_butterfly.mp4", "wb") as f: f.write(result["video_data"]) print("视频生成成功") else: print(f"生成失败: {result['error']}")

4.2 对话式视频编辑实战

Omni Flash 的核心特性之一是支持多轮对话式编辑。这意味着可以在生成初始视频后，通过自然语言指令进行迭代优化：

class ConversationalVideoEditor: def __init__(self, api_key): genai.configure(api_key=api_key) self.model = genai.GenerativeModel('gemini-omni-flash-preview') self.conversation = None self.session_history = [] def start_new_session(self, initial_prompt: str, reference_image: str = None): """开始新的编辑会话""" contents = [{"text": f"生成视频：{initial_prompt}"}] if reference_image: contents.append(self._prepare_image_input(reference_image)) self.conversation = self.model.start_chat(history=[]) response = self.conversation.send_message(contents) # 保存会话历史 self.session_history.append({ "type": "initial", "prompt": initial_prompt, "response": response }) return response def edit_video(self, edit_instruction: str) -> Dict[str, Any]: """基于对话历史进行视频编辑""" if not self.conversation: raise ValueError("需要先调用 start_new_session() 开始会话") edit_prompt = f"基于之前的视频，进行以下编辑：{edit_instruction}" response = self.conversation.send_message(edit_prompt) # 保存编辑历史 self.session_history.append({ "type": "edit", "instruction": edit_instruction, "response": response }) return self._process_video_response(response) def get_edit_suggestions(self) -> list: """获取可能的编辑建议""" suggestion_prompt = """ 基于当前的视频内容和编辑历史，提供3个具体的视频优化建议。 每个建议应该是可行的编辑指令。 """ response = self.conversation.send_message(suggestion_prompt) return self._parse_suggestions(response.text) def _parse_suggestions(self, text: str) -> list: """从模型响应中解析编辑建议""" # 简化实现，实际项目中可能需要更复杂的解析逻辑 suggestions = [] lines = text.split('\n') for line in lines: if line.strip() and any(keyword in line.lower() for keyword in ['调整', '改变', '添加', '优化', '修改']): suggestions.append(line.strip()) return suggestions[:3] # 返回最多3个建议 # 使用示例 def demo_conversational_editing(): editor = ConversationalVideoEditor(api_key="your_api_key") # 初始视频生成 print("生成初始视频...") initial_response = editor.start_new_session( "一个城市天际线的延时摄影，从白天到夜晚" ) # 第一轮编辑：调整风格 print("进行风格调整...") edit1_result = editor.edit_video("将风格改为卡通渲染，色彩更鲜艳") # 第二轮编辑：添加元素 print("添加动态元素...") edit2_result = editor.edit_video("在天空中添加一些飞鸟和云朵移动的效果") # 获取进一步优化建议 suggestions = editor.get_edit_suggestions() print("优化建议:", suggestions) return editor.session_history

4.3 高级视频生成技巧

为了获得最佳的视频生成效果，需要掌握一些高级技巧：

时序控制提示词：

"视频的前3秒展示全景，中间4秒聚焦细节特写，最后3秒缓慢拉远镜头。整体节奏平稳过渡。"

风格一致性维护：

style_reference = """ 保持一致的视觉风格：柔和色彩、电影感色调、平滑运镜。 避免突然的镜头切换或风格变化。 """ def generate_consistent_video(prompt, style_guide=style_reference): enhanced_prompt = f"{prompt}。风格要求：{style_guide}" return generator.generate_video(enhanced_prompt)

多场景串联：对于复杂的视频需求，可以分段生成后拼接，或者使用场景描述语法：

"场景1（0-3秒）：日出时的海滩空镜。 过渡：淡入淡出。 场景2（3-7秒）：人物沿海滩散步的中景。 场景3（7-10秒）：日落时分的全景收尾。"

5. 构建端到端的多媒体工作流

将 Nano Banana 2 Lite 和 Omni Flash 组合使用，可以创建强大的端到端多媒体生成管道。这种工作流特别适合需要从概念到最终视频的完整创作场景。

5.1 图像到视频的完整转换流程

以下示例展示了如何将静态图像通过 Omni Flash 转换为动态视频：

class MediaWorkflowEngine: def __init__(self, api_key): self.image_gen = NanoBananaImageGenerator(api_key) self.video_gen = OmniFlashVideoGenerator(api_key) def image_to_video_workflow(self, image_prompt: str, video_instruction: str, output_prefix: str) -> Dict[str, Any]: """ 完整的图像到视频工作流 Args: image_prompt: 图像生成提示词 video_instruction: 视频动画描述 output_prefix: 输出文件前缀 Returns: 工作流执行结果 """ results = { "image_generated": False, "video_generated": False, "output_files": [], "errors": [] } try: # 步骤1：使用 Nano Banana 2 Lite 生成基础图像 print("步骤1: 生成基础图像...") base_image = self.image_gen.generate_image(image_prompt) if not base_image: results["errors"].append("图像生成失败") return results image_path = f"{output_prefix}_base_image.png" base_image.save(image_path) results["image_generated"] = True results["output_files"].append(image_path) # 步骤2：使用 Omni Flash 将图像动画化 print("步骤2: 将图像转换为视频...") video_prompt = f"基于这张图像，{video_instruction}" video_result = self.video_gen.generate_video( prompt=video_prompt, reference_image=image_path ) if video_result["success"]: video_path = f"{output_prefix}_animated.mp4" with open(video_path, "wb") as f: f.write(video_result["video_data"]) results["video_generated"] = True results["output_files"].append(video_path) results["video_duration"] = video_result["duration"] else: results["errors"].append(f"视频生成失败: {video_result['error']}") except Exception as e: results["errors"].append(f"工作流执行异常: {str(e)}") return results def batch_media_workflow(self, workflow_items: list) -> list: """批量处理多个工作流项目""" from concurrent.futures import ThreadPoolExecutor import threading results = [] lock = threading.Lock() def process_single_item(item): try: result = self.image_to_video_workflow( item["image_prompt"], item["video_instruction"], item["output_prefix"] ) result["item_id"] = item["id"] with lock: results.append(result) return result except Exception as e: error_result = { "item_id": item["id"], "errors": [f"处理异常: {str(e)}"] } with lock: results.append(error_result) return error_result # 使用线程池并行处理（注意API速率限制） with ThreadPoolExecutor(max_workers=3) as executor: executor.map(process_single_item, workflow_items) return results # 使用示例 def demo_complete_workflow(): workflow_engine = MediaWorkflowEngine(api_key="your_api_key") # 单个工作流示例 result = workflow_engine.image_to_video_workflow( image_prompt="一个未来城市的科幻风格概念图，高楼林立，飞行汽车", video_instruction="创建城市中飞行汽车穿梭的动态场景，添加霓虹灯光效", output_prefix="future_city" ) print(f"工作流完成: 图像{result['image_generated']}, 视频{result['video_generated']}") print(f"生成文件: {result['output_files']}") if result["errors"]: print(f"错误: {result['errors']}") return result

5.2 交互式创作应用架构

对于需要用户交互的应用，可以设计基于会话的架构来维护创作上下文：

class InteractiveCreationSession: def __init__(self, session_id, api_key): self.session_id = session_id self.api_key = api_key self.workflow_engine = MediaWorkflowEngine(api_key) self.conversation_editor = ConversationalVideoEditor(api_key) # 会话状态 self.current_stage = "concept" # concept, image_generation, video_creation, editing self.assets = {} # 生成的资源 self.edit_history = [] def process_user_input(self, user_message: str) -> Dict[str, Any]: """处理用户输入，推进创作流程""" response = { "action": "continue", "message": "", "assets": [], "suggestions": [] } if self.current_stage == "concept": # 概念阶段：生成初始图像 image_result = self._generate_initial_concept(user_message) response.update(image_result) self.current_stage = "image_generation" elif self.current_stage == "image_generation": # 图像生成后：提供编辑选项或推进到视频 if "视频" in user_message or "动画" in user_message: video_result = self._create_video_from_image(user_message) response.update(video_result) self.current_stage = "video_creation" else: response["suggestions"] = self._get_image_edit_suggestions() elif self.current_stage in ["video_creation", "editing"]: # 视频编辑阶段 edit_result = self.conversation_editor.edit_video(user_message) response.update(edit_result) self.edit_history.append(user_message) return response def _generate_initial_concept(self, concept_description: str) -> Dict[str, Any]: """生成初始概念图像""" image = self.workflow_engine.image_gen.generate_image(concept_description) if image: filename = f"{self.session_id}_concept.png" image.save(filename) self.assets["concept_image"] = filename return { "message": "已生成概念图像，您希望基于此创建视频还是继续调整图像？", "assets": [filename], "suggestions": [ "基于此图像创建视频动画", "调整图像风格或内容", "生成其他概念选项" ] } else: return {"message": "图像生成失败，请重新描述您的概念"} def get_session_summary(self) -> Dict[str, Any]: """获取会话摘要""" return { "session_id": self.session_id, "current_stage": self.current_stage, "asset_count": len(self.assets), "edit_count": len(self.edit_history), "latest_assets": list(self.assets.values())[-3:] # 最近3个资源 }

这种架构特别适合构建创意工具、内容创作平台或教育应用，用户可以通过自然语言交互逐步完善他们的多媒体作品。

6. 生产环境部署与优化建议

将 Gemini 模型集成到生产环境时，需要考虑性能、可靠性、成本控制等多个方面。以下是在实际部署中需要关注的关键点。

6.1 API 使用优化与成本控制

Gemini API 按使用量计费，合理的用量管理对控制成本至关重要。

用量监控实现：

import time from dataclasses import dataclass from typing import Dict, List @dataclass class APIUsageRecord: timestamp: float operation: str model: str cost: float duration: float class UsageTracker: def __init__(self, budget_limit: float = 100.0): # 默认月度预算100美元 self.records: List[APIUsageRecord] = [] self.budget_limit = budget_limit self.monthly_reset() def monthly_reset(self): """月度重置用量统计""" current_month = time.localtime().tm_mon self.current_month = current_month self.monthly_usage = 0.0 self.records.clear() def record_usage(self, operation: str, model: str, cost: float, duration: float): """记录API使用情况""" # 检查是否跨月 if time.localtime().tm_mon != self.current_month: self.monthly_reset() record = APIUsageRecord( timestamp=time.time(), operation=operation, model=model, cost=cost, duration=duration ) self.records.append(record) self.monthly_usage += cost # 预算预警 if self.monthly_usage > self.budget_limit * 0.8: self._send_budget_alert() def get_usage_summary(self) -> Dict[str, float]: """获取用量摘要""" model_costs = {} for record in self.records: model_costs[record.model] = model_costs.get(record.model, 0) + record.cost return { "total_cost": self.monthly_usage, "model_breakdown": model_costs, "remaining_budget": self.budget_limit - self.monthly_usage, "record_count": len(self.records) } def _send_budget_alert(self): """发送预算预警""" print(f"预算预警: 本月已使用 {self.monthly_usage:.2f} 美元，预算限额 {self.budget_limit} 美元")

成本优化策略：

1. 缓存策略：对常见提示词的生成结果进行缓存
2. 预览模式：使用低分辨率预览，用户确认后再生成高质量版本
3. 批量优化：合理安排批量请求，避免频繁小请求
4. 模型选型：根据质量要求选择合适的模型版本

6.2 错误处理与重试机制

生产环境中必须健壮地处理API错误和网络问题。

import random from typing import Callable, Any def resilient_api_call(api_function: Callable, max_retries: int = 3, base_delay: float = 1.0) -> Any: """ 带指数退避的重试机制封装 Args: api_function: 要执行的API函数 max_retries: 最大重试次数 base_delay: 基础延迟时间（秒） Returns: API调用结果 """ last_exception = None for attempt in range(max_retries + 1): try: return api_function() except Exception as e: last_exception = e # 检查是否为可重试错误 if not _is_retryable_error(e): raise if attempt < max_retries: # 指数退避 + 随机抖动 delay = base_delay * (2 ** attempt) + random.uniform(0, 0.1) print(f"API调用失败，{delay:.2f}秒后重试 (尝试 {attempt + 1}/{max_retries})") time.sleep(delay) else: print(f"API调用失败，已达最大重试次数") raise last_exception def _is_retryable_error(exception: Exception) -> bool: """判断错误是否可重试""" error_msg = str(exception).lower() # 可重试的错误类型 retryable_patterns = [ "timeout", "connection", "rate limit", "quota", "internal error", "service unavailable" ] # 不可重试的错误类型 non_retryable_patterns = [ "invalid argument", "permission denied", "auth", "billing", "not found" ] if any(pattern in error_msg for pattern in non_retryable_patterns): return False return any(pattern in error_msg for pattern in retryable_patterns) # 使用示例 def safe_image_generation(prompt: str) -> Any: """安全的图像生成封装""" def _generate(): generator = NanoBananaImageGenerator(api_key="your_api_key") return generator.generate_image(prompt) return resilient_api_call(_generate)

6.3 性能监控与日志记录

完善的监控体系有助于及时发现和解决问题。

import logging from datetime import datetime class PerformanceMonitor: def __init__(self): self.logger = logging.getLogger('gemini_performance') self.logger.setLevel(logging.INFO) # 添加文件处理器 handler = logging.FileHandler('gemini_performance.log') formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname