Tio Boot DocsTio Boot Docs
Home
  • java-db
  • api-table
  • Enjoy
  • Tio Boot Admin
  • ai_agent
  • translator
  • knowlege_base
  • ai-search
  • 案例
Abount
  • Github
  • Gitee
Home
  • java-db
  • api-table
  • Enjoy
  • Tio Boot Admin
  • ai_agent
  • translator
  • knowlege_base
  • ai-search
  • 案例
Abount
  • Github
  • Gitee
  • 01_tio-boot 简介

    • tio-boot:新一代高性能 Java Web 开发框架
    • tio-boot 入门示例
    • Tio-Boot 配置 : 现代化的配置方案
    • tio-boot 整合 Logback
    • tio-boot 整合 hotswap-classloader 实现热加载
    • 自行编译 tio-boot
    • 最新版本
    • 开发规范
  • 02_部署

    • 使用 Maven Profile 实现分环境打包 tio-boot 项目
    • Maven 项目配置详解:依赖与 Profiles 配置
    • tio-boot 打包成 FastJar
    • 使用 GraalVM 构建 tio-boot Native 程序
    • 使用 Docker 部署 tio-boot
    • 部署到 Fly.io
    • 部署到 AWS Lambda
    • 到阿里云云函数
    • 使用 Deploy 工具部署
    • 胖包与瘦包的打包与部署
    • 使用 Jenkins 部署 Tio-Boot 项目
    • 使用 Nginx 反向代理 Tio-Boot
    • 使用 Supervisor 管理 Java 应用
  • 03_配置

    • 配置参数
    • 服务器监听器
    • 内置缓存系统 AbsCache
    • 使用 Redis 作为内部 Cache
    • 静态文件处理器
    • 基于域名的静态资源隔离
    • DecodeExceptionHandler
  • 04_原理

    • 生命周期
    • 请求处理流程
    • 重要的类
  • 05_json

    • Json
    • 接受 JSON 和响应 JSON
    • 响应实体类
  • 06_web

    • 概述
    • 文件上传
    • 接收请求参数
    • 接收日期参数
    • 接收数组参数
    • 返回字符串
    • 返回文本数据
    • 返回网页
    • 请求和响应字节
    • 文件下载
    • 返回视频文件并支持断点续传
    • http Session
    • Cookie
    • HttpRequest
    • HttpResponse
    • Resps
    • RespBodyVo
    • /zh/06_web/19.html
    • 全局异常处理器
    • 异步
    • 动态 返回 CSS 实现
    • 返回图片
    • Transfer-Encoding: chunked 实时音频播放
    • Server-Sent Events (SSE)
    • 接口访问统计
    • 接口请求和响应数据记录
    • 自定义 Handler 转发请求
    • 使用 HttpForwardHandler 转发所有请求
    • 跨域
    • 添加 Controller
    • 常用工具类
    • HTTP Basic 认证
    • WebJars
    • JProtobuf
  • 07_validate

    • 数据紧校验规范
    • 参数校验
  • 08_websocket

    • 使用 tio-boot 搭建 WebSocket 服务
    • WebSocket 聊天室项目示例
  • 09_java-db

    • java‑db
    • 操作数据库入门示例
    • SQL 模板
    • 数据源配置与使用
    • ActiveRecord
    • Model
    • 生成器与 Model
    • Db 工具类
    • 批量操作
    • 数据库事务处理
    • Cache 缓存
    • Dialect 多数据库支持
    • 表关联操作
    • 复合主键
    • Oracle 支持
    • Enjoy SQL 模板
    • Java-DB 整合 Enjoy 模板最佳实践
    • 多数据源支持
    • 独立使用 ActiveRecord
    • 调用存储过程
    • java-db 整合 Guava 的 Striped 锁优化
    • 生成 SQL
    • 通过实体类操作数据库
    • java-db 读写分离
    • Spring Boot 整合 Java-DB
    • like 查询
    • 常用操作示例
    • Druid 监控集成指南
    • SQL 统计
  • 10_api-table

    • ApiTable 概述
    • 使用 ApiTable 连接 SQLite
    • 使用 ApiTable 连接 Mysql
    • 使用 ApiTable 连接 Postgres
    • 使用 ApiTable 连接 TDEngine
    • 使用 api-table 连接 oracle
    • 使用 api-table 连接 mysql and tdengine 多数据源
    • EasyExcel 导出
    • EasyExcel 导入
    • TQL(Table SQL)前端输入规范
    • ApiTable 实现增删改查
    • 数组类型
    • 单独使用 ApiTable
  • 11_aop

    • JFinal-aop
    • Aop 工具类
    • 配置
    • 配置
    • 独立使用 JFinal Aop
    • @AImport
    • 原理解析
  • 12_cache

    • Caffine
    • Jedis-redis
    • hutool RedisDS
    • Redisson
    • Caffeine and redis
    • CacheUtils 工具类
    • 使用 CacheUtils 整合 caffeine 和 redis 实现的两级缓存
    • 使用 java-db 整合 ehcache
    • 使用 java-db 整合 redis
    • Java DB Redis 相关 Api
    • redis 使用示例
  • 13_认证和权限

    • hutool-JWT
    • FixedTokenInterceptor
    • 使用内置 TokenManager 实现登录
    • 用户系统
    • 重置密码
    • 匿名登录
    • Google 登录
    • 权限校验注解
    • Sa-Token
    • sa-token 登录注册
    • StpUtil.isLogin() 源码解析
    • 短信登录
    • 移动端微信登录实现指南
    • 移动端重置密码
  • 14_i18n

    • i18n
  • 15_enjoy

    • tio-boot 整合 Enjoy 模版引擎文档
    • 引擎配置
    • 表达式
    • 指令
    • 注释
    • 原样输出
    • Shared Method 扩展
    • Shared Object 扩展
    • Extension Method 扩展
    • Spring boot 整合
    • 独立使用 Enjoy
    • tio-boot enjoy 自定义指令 localeDate
    • PromptEngine
    • Enjoy 入门示例-擎渲染大模型请求体
    • Enjoy 使用示例
  • 16_定时任务

    • Quartz 定时任务集成指南
    • 分布式定时任务 xxl-jb
    • cron4j 使用指南
  • 17_tests

    • TioBootTest 类
  • 18_tio

    • TioBootServer
    • tio-core
    • 内置 TCP 处理器
    • 独立启动 UDPServer
    • 使用内置 UDPServer
    • t-io 消息处理流程
    • tio-运行原理详解
    • TioConfig
    • ChannelContext
    • Tio 工具类
    • 业务数据绑定
    • 业务数据解绑
    • 发送数据
    • 关闭连接
    • Packet
    • 监控: 心跳
    • 监控: 客户端的流量数据
    • 监控: 单条 TCP 连接的流量数据
    • 监控: 端口的流量数据
    • 单条通道统计: ChannelStat
    • 所有通道统计: GroupStat
    • 资源共享
    • 成员排序
    • ssl
    • DecodeRunnable
    • 使用 AsynchronousSocketChannel 响应数据
    • 拉黑 IP
    • 深入解析 Tio 源码:构建高性能 Java 网络应用
  • 19_aio

    • ByteBuffer
    • AIO HTTP 服务器
    • 自定义和线程池和池化 ByteBuffer
    • AioHttpServer 应用示例 IP 属地查询
    • 手写 AIO Http 服务器
  • 20_netty

    • Netty TCP Server
    • Netty Web Socket Server
    • 使用 protoc 生成 Java 包文件
    • Netty WebSocket Server 二进制数据传输
    • Netty 组件详解
  • 21_netty-boot

    • Netty-Boot
    • 原理解析
    • 整合 Hot Reload
    • 整合 数据库
    • 整合 Redis
    • 整合 Elasticsearch
    • 整合 Dubbo
    • Listener
    • 文件上传
    • 拦截器
    • Spring Boot 整合 Netty-Boot
    • SSL 配置指南
    • ChannelInitializer
    • Reserve
  • 22_MQ

    • Mica-mqtt
    • EMQX
    • Disruptor
  • 23_tio-utils

    • tio-utils
    • HttpUtils
    • Notification
    • 邮箱
    • JSON
    • 读取文件
    • Base64
    • 上传和下载
    • Http
    • Telegram
    • RsaUtils
    • EnvUtils 使用文档
    • 系统监控
    • 毫秒并发 ID (MCID) 生成方案
  • 24_tio-http-server

    • 使用 Tio-Http-Server 搭建简单的 HTTP 服务
    • tio-boot 添加 HttpRequestHandler
    • 在 Android 上使用 tio-boot 运行 HTTP 服务
    • tio-http-server-native
    • handler 常用操作
  • 25_tio-websocket

    • WebSocket 服务器
    • WebSocket Client
  • 26_tio-im

    • 通讯协议文档
    • ChatPacket.proto 文档
    • java protobuf
    • 数据表设计
    • 创建工程
    • 登录
    • 历史消息
    • 发消息
  • 27_mybatis

    • Tio-Boot 整合 MyBatis
    • 使用配置类方式整合 MyBatis
    • 整合数据源
    • 使用 mybatis-plus 整合 tdengine
    • 整合 mybatis-plus
  • 28_mongodb

    • tio-boot 使用 mongo-java-driver 操作 mongodb
  • 29_elastic-search

    • Elasticsearch
    • JavaDB 整合 ElasticSearch
    • Elastic 工具类使用指南
    • Elastic-search 注意事项
    • ES 课程示例文档
  • 30_magic-script

    • tio-boot 整合 magic-script
  • 31_groovy

    • tio-boot 整合 Groovy
  • 32_firebase

    • 整合 google firebase
    • Firebase Storage
    • Firebase Authentication
    • 使用 Firebase Admin SDK 进行匿名用户管理与自定义状态标记
    • 导出用户
    • 注册回调
    • 登录注册
  • 33_文件存储

    • 文件上传数据表
    • 本地存储
    • 使用 AWS S3 存储文件并整合到 Tio-Boot 项目中
    • 存储文件到 腾讯 COS
  • 34_spider

    • jsoup
    • 爬取 z-lib.io 数据
    • 整合 WebMagic
    • WebMagic 示例:爬取学校课程数据
    • Playwright
    • Flexmark (Markdown 处理器)
    • tio-boot 整合 Playwright
    • 缓存网页数据
  • 36_integration_thirty_party

    • tio-boot 整合 okhttp
    • 整合 GrpahQL
    • 集成 Mailjet
    • 整合 ip2region
    • 整合 GeoLite 离线库
    • 整合 Lark 机器人指南
    • 集成 Lark Mail 实现邮件发送
    • Thymeleaf
    • Swagger
    • Clerk 验证
  • 37_dubbo

    • 概述
    • dubbo 2.6.0
    • dubbo 2.6.0 调用过程
    • dubbo 3.2.0
  • 38_spring

    • Spring Boot Web 整合 Tio Boot
    • spring-boot-starter-webflux 整合 tio-boot
    • Tio Boot 整合 Spring Boot Starter
    • Tio Boot 整合 Spring Boot Starter Data Redis 指南
  • 39_spring-cloud

    • tio-boot spring-cloud
  • 40_mysql

    • 使用 Docker 运行 MySQL
    • /zh/42_mysql/02.html
  • 41_postgresql

    • PostgreSQL 安装
    • PostgreSQL 主键自增
    • PostgreSQL 日期类型
    • Postgresql 金融类型
    • PostgreSQL 数组类型
    • PostgreSQL 全文检索
    • PostgreSQL 查询优化
    • 获取字段类型
    • PostgreSQL 向量
    • PostgreSQL 优化向量查询
    • PostgreSQL 其他
  • 43_oceanbase

    • 快速体验 OceanBase 社区版
    • 快速上手 OceanBase 数据库单机部署与管理
    • 诊断集群性能
    • 优化 SQL 性能指南
    • /zh/43_oceanbase/05.html
  • 50_media

    • JAVE 提取视频中的声音
    • Jave 提取视频中的图片
    • /zh/50_media/03.html
  • 51_asr

    • Whisper-JNI
  • 54_native-media

    • java-native-media
    • JNI 入门示例
    • mp3 拆分
    • mp4 转 mp3
    • 使用 libmp3lame 实现高质量 MP3 编码
    • Linux 编译
    • macOS 编译
    • 从 JAR 包中加载本地库文件
    • 支持的音频和视频格式
    • 任意格式转为 mp3
    • 通用格式转换
    • 通用格式拆分
    • 视频合并
    • VideoToHLS
    • split_video_to_hls 支持其他语言
    • 持久化 HLS 会话
  • 55_telegram4j

    • 数据库设计
    • /zh/55_telegram4j/02.html
    • 基于 MTProto 协议开发 Telegram 翻译机器人
    • 过滤旧消息
    • 保存机器人消息
    • 定时推送
    • 增加命令菜单
    • 使用 telegram-Client
    • 使用自定义 StoreLayout
    • 延迟测试
    • Reactor 错误处理
    • Telegram4J 常见错误处理指南
  • 56_telegram-bots

    • TelegramBots 入门指南
    • 使用工具库 telegram-bot-base 开发翻译机器人
  • 60_LLM

    • 简介
    • AI 问答
    • /zh/60_LLM/03.html
    • /zh/60_LLM/04.html
    • 增强检索(RAG)
    • 结构化数据检索
    • 搜索+AI
    • 集成第三方 API
    • 后置处理
    • 推荐问题生成
    • 连接代码执行器
    • 避免 GPT 混乱
    • /zh/60_LLM/13.html
  • 61_ai_agent

    • 数据库设计
    • 示例问题管理
    • 会话管理
    • 历史记录
    • 对接 Perplexity API
    • 意图识别与生成提示词
    • 智能问答模块设计与实现
    • 文件上传与解析文档
    • 翻译
    • 名人搜索功能实现
    • Ai studio gemini youbue 问答使用说明
    • 自建 YouTube 字幕问答系统
    • 自建 获取 youtube 字幕服务
    • 通用搜索
    • /zh/61_ai_agent/15.html
    • 16
    • 17
    • 18
    • 在 tio-boot 应用中整合 ai-agent
    • 16
  • 62_translator

    • 简介
  • 63_knowlege_base

    • 数据库设计
    • 用户登录实现
    • 模型管理
    • 知识库管理
    • 文档拆分
    • 片段向量
    • 命中测试
    • 文档管理
    • 片段管理
    • 问题管理
    • 应用管理
    • 向量检索
    • 推理问答
    • 问答模块
    • 统计分析
    • 用户管理
    • api 管理
    • 存储文件到 S3
    • 文档解析优化
    • 片段汇总
    • 段落分块与检索
    • 多文档解析
    • 对话日志
    • 检索性能优化
    • Milvus
    • 文档解析方案和费用对比
    • 离线运行向量模型
  • 64_ai-search

    • ai-search 项目简介
    • ai-search 数据库文档
    • ai-search SearxNG 搜索引擎
    • ai-search Jina Reader API
    • ai-search Jina Search API
    • ai-search 搜索、重排与读取内容
    • ai-search PDF 文件处理
    • ai-search 推理问答
    • Google Custom Search JSON API
    • ai-search 意图识别
    • ai-search 问题重写
    • ai-search 系统 API 接口 WebSocket 版本
    • ai-search 搜索代码实现 WebSocket 版本
    • ai-search 生成建议问
    • ai-search 生成问题标题
    • ai-search 历史记录
    • Discover API
    • 翻译
    • Tavily Search API 文档
    • 对接 Tavily Search
    • 火山引擎 DeepSeek
    • 对接 火山引擎 DeepSeek
    • ai-search 搜索代码实现 SSE 版本
    • jar 包部署
    • Docker 部署
    • 爬取一个静态网站的所有数据
    • 网页数据预处理
    • 网页数据检索与问答流程整合
  • 65_java-linux

    • Java 执行 python 代码
    • 通过大模型执行 Python 代码
    • MCP 协议
    • Cline 提示词
    • Cline 提示词-中文版本
  • 66_manim

    • 简介
    • Manim 开发环境搭建
    • 生成场景提示词
    • 生成代码
    • 完整脚本示例
    • 语音合成系统
    • Fish.audio TTS 接口说明文档与 Java 客户端封装
    • 整合 fishaudio 到 java-uni-ai-server 项目
    • 执行 Python (Manim) 代码
    • 使用 SSE 流式传输生成进度的实现文档
    • 整合全流程完整文档
    • HLS 动态推流技术文档
    • manim 分场景生成代码
    • 分场景运行代码及流式播放支持
    • 分场景业务端完整实现流程
    • Maiim布局管理器
    • 仅仅生成场景代码
    • 使用 modal 运行 manim 代码
    • Python 使用 Modal GPU 加速渲染
    • Modal 平台 GPU 环境下运行 Manim
    • Modal Manim OpenGL 安装与使用
    • 优化 GPU 加速
    • 生成视频封面流程
    • Java 调用 manim 命令 执行代码 生成封面
    • Manim 图像生成服务客户端文档
    • manim render help
    • 显示 中文公式
    • manimgl
    • EGL
    • /zh/66_manim/30.html
    • /zh/66_manim/31.html
    • 成本核算
    • /zh/66_manim/33.html
  • 70_tio-boot-admin

    • 入门指南
    • 初始化数据
    • token 存储
    • 与前端集成
    • 文件上传
    • 网络请求
    • 图片管理
    • /zh/70_tio-boot-admin/08.html
    • Word 管理
    • PDF 管理
    • 文章管理
    • 富文本编辑器
  • 71_tio-boot

    • /zh/71_tio-boot/01.html
    • Swagger 整合到 Tio-Boot 中的指南
    • HTTP/1.1 Pipelining 性能测试报告
  • 80_性能测试

    • 压力测试 - tio-http-serer
    • 压力测试 - tio-boot
    • 压力测试 - tio-boot-native
    • 压力测试 - netty-boot
    • 性能测试对比
    • TechEmpower FrameworkBenchmarks
    • 压力测试 - tio-boot 12 C 32G
  • 99_案例

    • 封装 IP 查询服务
    • tio-boot 案例 - 全局异常捕获与企业微信群通知
    • tio-boot 案例 - 文件上传和下载
    • tio-boot 案例 - 整合 ant design pro 增删改查
    • tio-boot 案例 - 流失响应
    • tio-boot 案例 - 增强检索
    • tio-boot 案例 - 整合 function call
    • tio-boot 案例 - 定时任务 监控 PostgreSQL、Redis 和 Elasticsearch
    • Tio-Boot 案例:使用 SQLite 整合到登录注册系统
    • tio-boot 案例 - 执行 shell 命令

Python 使用 Modal GPU 加速渲染

本文介绍如何利用 Modal.com 的云端 GPU 服务,快速部署并运行 Python 渲染任务。文中不仅对 Modal.com 的 GPU 服务做了简单介绍,还提供了从安装 CLI、创建应用、定制容器,到水平扩展以及 GPU 加速运行的全流程示例。值得注意的是,第一次运行可能会稍慢,但之后的运行速度会显著提升。


一、Modal.com GPU 简介

Modal.com 提供了一套易于使用的云端容器化计算环境,支持 CPU 与 GPU 服务器,非常适合 AI 模型训练、图像处理、视频渲染等任务的快速部署。其主要特点包括:

  • 高性能 GPU 支持:Modal 提供 A100、V100、T4 等多种高性能 GPU,满足各种计算密集型任务的需求。
  • 容器化部署:借助容器技术,可以快速构建、配置和部署所需的运行环境。
  • 自动扩展:Modal 能够根据任务需求自动扩展计算资源,轻松应对大规模并行计算任务。

二、在 Modal 上部署 GPU 渲染(OpenGL)示例教程

下面通过一系列示例,展示如何在 Modal 上部署并加速渲染任务。

1. 安装 Modal CLI 并登录

首先,需要在本地安装 Modal CLI 并进行登录。可以使用 pip 安装并登录:

pip install modal
modal login

或者使用 token 方式登录:

modal token set --token-id id --token-secret secret

2. 入门示例

2.1 运行你的第一个函数

Modal 使得代码部署与扩展变得非常简单。只需按照以下步骤即可在云端运行代码:

  1. 创建一个 Modal 应用
  2. 使用装饰器 @app.function 将 Python 函数包装成云端任务
  3. Modal 会将代码打包到容器中并在云端运行

示例代码如下:

import modal

# 1) 创建一个 Modal 应用
app = modal.App("example-get-started")

# 2) 添加装饰器,在云端运行此函数
@app.function()
def square(x=2):
    print(f"The square of {x} is {x**2}")  # 这段代码将在远程工作节点上运行!

运行函数

modal run get_started.py

运行后将看到类似如下的输出:

✓ Initialized. View run at https://modal.com/apps/kaizhao/main/ap-qF7yK83DktpGusQUsJJ2HS
✓ Created objects.
├── 🔨 Created mount ...
└── 🔨 Created function square.
The square of 2 is 4
Stopping app - local entrypoint completed.
✓ App completed. View run at https://modal.com/apps/kaizhao/main/ap-qF7yK83DktpGusQUsJJ2HS

2.2 定制容器

如果需要在云端容器中预装特定的 Python 库(例如 NumPy),可以通过定义自定义镜像来实现。步骤如下:

  1. 定义一个基于 Debian slim 的 Modal Image 并安装 NumPy
  2. 将镜像附加到 Modal 应用中
  3. 在函数中导入并使用该库

示例代码:

import modal

# 1) 定义一个包含 NumPy 的 Modal 镜像
image = modal.Image.debian_slim().pip_install("numpy")

# 2) 将镜像附加到应用中
app = modal.App("example-custom-container", image=image)

@app.function()
def square(x=2):
    # 3) 在容器中导入并使用 NumPy 库
    import numpy as np
    print(f"The square of {x} is {np.square(x)}")

运行效果与前一个示例类似,输出中依旧会计算出数字的平方。


2.3 水平扩展

Modal 支持瞬间扩展到数百个容器,以实现大规模并行处理。通过 .map 方法,可以轻松将函数并行运行在一组输入上。

步骤如下:

  1. 创建一个本地入口函数(使用装饰器 @app.local_entrypoint)
  2. 使用 .map 方法对函数进行并行调用

示例代码:

import modal

image = modal.Image.debian_slim().pip_install("numpy")
app = modal.App("example-scaling-out", image=image)

@app.function()
def square(x=2):
    import numpy as np
    print(f"The square of {x} is {np.square(x)}")

# 1) 创建本地入口函数
@app.local_entrypoint()
def main():
    # 2) 使用 `.map` 方法并行处理 100 个输入
    list(square.map(range(100)))

运行后,应用会将 100 个任务并行分发到各个容器中执行,并在终端显示每个输入对应的平方值。


2.4 使用 GPU 加速

为了进一步加速运算任务,可以利用 GPU。常见的步骤包括:

  1. 使用官方支持的 CUDA 镜像
  2. 在镜像中安装 GPU 加速所需的依赖库(如 cupy,作为 NumPy 的 CUDA 替代品)
  3. 在函数中指定 GPU 资源,例如 gpu="A10G"

在开始之前 可以不在本地使用 pip 安装 cupy:

示例代码如下:

import subprocess
import modal

# 1) 使用官方支持的 CUDA 镜像,并添加 Python 3.11
image = (
    modal.Image.from_registry("nvidia/cuda:12.4.0-devel-ubuntu22.04", add_python="3.11")
    # 2) 安装 cupy(作为 CUDA 加速的 NumPy 替代品)
    .pip_install("cupy-cuda12x")
)

app = modal.App("example-gpu", image=image)

# 3) 为函数分配 GPU 资源(例如 A10G)
@app.function(gpu="A10G")
def square(x=2):
    import cupy as cp
    # 调用 nvidia-smi 查看 GPU 状态
    subprocess.run(["nvidia-smi"])
    print(f"The square of {x} is {cp.square(x)}")

运行时,将首先显示 CUDA 相关信息及 GPU 状态(例如 NVIDIA-SMI 输出),随后输出计算结果。请注意,第一次运行可能由于镜像构建和依赖安装较慢,而后续运行则会更快、更流畅。


三 GPU 加速

1. 完整输出信息

在 GPU 加速示例中,完整的输出日志如下(注意每次运行输出可能略有不同,但大致流程一致):

✓ Initialized. View run at https://modal.com/apps/kaizhao/main/ap-FDotngEg7iQ3rZeottuTyh
Building image im-4aHNFoxxG1mA87xYsEUUqb

=> Step 0: FROM nvidia/cuda:12.4.0-devel-ubuntu22.04
Getting image source signatures
Copying blob sha256:3bd5db8307cf789162a5a096889ea97023d5795068bdd8f07a0b09b3615d17df
Copying blob sha256:e06eb1b5c4cc0283389710e45402738c973f9c27a4cbdf90d53751723279e001
Copying blob sha256:6005190795580507557f886a8cb09d07f48a293591caa5f686ae89e2f363a350
Copying blob sha256:80150f70fb1e403d909539844a70fcb152ecfbd994a2c2c186dd71abb90be693
Copying blob sha256:7f308a7652768c0a964eb1720554421079b6a956110c7a12362380d2372fe82f
Copying blob sha256:3af11d09e9cd1eb9c379f0a4071231e5a5642eb728b4b33bcb76be291f3c9488
Copying blob sha256:edd1dba56169c724e9377dafe9d6dd34c0ef9585109fa8366b4a3ee68e07fd25
Copying blob sha256:0ae42424cadfa646dc06982b0ed3d08688b628c43fc379782b3b5d2d578eb041
Copying blob sha256:73b7968785dcb3e277c8de18c033614246b9419edb40941a0fc66aed6c831edb
Copying blob sha256:bccd10f490ab0f3fba61b193d1b80af91b17ca9bdca9768a16ed05ce16552fcb
Copying blob sha256:42896cdfd7b6a3e75be89e9fbc327a2dc8a1f56ab23a994553c28125ed85f528
Copying config sha256:d6b74566255fb8fb6e0ab61f2d2e7c3671b9f1233676ee374a104df2b43b2c04
Writing manifest to image destination
Unpacking OCI image
   • unpacking rootfs ...
   • ... done
   • unpacked image rootfs: /tmp/.tmpoEHILt
Copied image in 1.40s

=> Step 1: COPY /python/. /usr/local

=> Step 2: RUN ln -s /usr/local/bin/python3 /usr/local/bin/python

=> Step 3: ENV TERMINFO_DIRS=/etc/terminfo:/lib/terminfo:/usr/share/terminfo:/usr/lib/terminfo

=> Step 4: COPY /modal_requirements.txt /modal_requirements.txt

=> Step 5: RUN python -m pip install --upgrade pip wheel uv
Looking in indexes: http://pypi-mirror.modal.local:5555/simple
Requirement already satisfied: pip in /usr/local/lib/python3.11/site-packages (23.2.1)
Collecting pip
  Obtaining dependency information for pip from http://pypi-mirror.modal.local:5555/simple/pip/pip-25.0.1-py3-none-any.whl.metadata
  Downloading http://pypi-mirror.modal.local:5555/simple/pip/pip-25.0.1-py3-none-any.whl.metadata (3.7 kB)
Collecting wheel
  Obtaining dependency information for wheel from http://pypi-mirror.modal.local:5555/simple/wheel/wheel-0.45.1-py3-none-any.whl.metadata
  Downloading http://pypi-mirror.modal.local:5555/simple/wheel/wheel-0.45.1-py3-none-any.whl.metadata (2.3 kB)
Collecting uv
  Obtaining dependency information for uv from http://pypi-mirror.modal.local:5555/simple/uv/uv-0.6.10-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata
  Downloading http://pypi-mirror.modal.local:5555/simple/uv/uv-0.6.10-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (11 kB)
Downloading http://pypi-mirror.modal.local:5555/simple/pip/pip-25.0.1-py3-none-any.whl (1.8 MB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 1.8/1.8 MB 165.2 MB/s eta 0:00:00
Downloading http://pypi-mirror.modal.local:5555/simple/wheel/wheel-0.45.1-py3-none-any.whl (72 kB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 72.5/72.5 kB 313.1 MB/s eta 0:00:00
Downloading http://pypi-mirror.modal.local:5555/simple/uv/uv-0.6.10-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (16.6 MB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 16.6/16.6 MB 135.0 MB/s eta 0:00:00
Installing collected packages: wheel, uv, pip
  Attempting uninstall: pip
    Found existing installation: pip 23.2.1
    Uninstalling pip-23.2.1:
      Successfully uninstalled pip-23.2.1
Successfully installed pip-25.0.1 uv-0.6.10 wheel-0.45.1

=> Step 6: RUN uv pip install --system --compile-bytecode --no-cache --no-deps -r /modal_requirements.txt
Using Python 3.11.5 environment at: /usr/local
Resolved 15 packages in 184ms
Downloading aiohttp (1.2MiB)
   Building grpclib==0.4.7
 Downloaded aiohttp
      Built grpclib==0.4.7
Prepared 15 packages in 1.17s
Installed 15 packages in 24ms
Bytecode compiled 871 files in 456ms
 + aiohappyeyeballs==2.4.3
 + aiohttp==3.10.8
 + aiosignal==1.3.1
 + attrs==24.2.0
 + certifi==2024.8.30
 + frozenlist==1.4.1
 + grpclib==0.4.7
 + h2==4.1.0
 + hpack==4.0.0
 + hyperframe==6.0.1
 + idna==3.10
 + multidict==6.1.0
 + protobuf==5.29.4
 + typing-extensions==4.12.2
 + yarl==1.13.1

=> Step 7: RUN rm /modal_requirements.txt
Saving image...
Image saved, took 5.24s

Built image im-4aHNFoxxG1mA87xYsEUUqb in 129.31s

Building image im-QeSqRPPfuR6PNrYdomv273

=> Step 0: FROM base

=> Step 1: RUN python -m pip install cupy-cuda12x
Looking in indexes: http://pypi-mirror.modal.local:5555/simple
Collecting cupy-cuda12x
  Downloading http://pypi-mirror.modal.local:5555/simple/cupy-cuda12x/cupy_cuda12x-13.4.1-cp311-cp311-manylinux2014_x86_64.whl.metadata (2.6 kB)
Collecting numpy<2.3,>=1.22 (from cupy-cuda12x)
  Downloading http://pypi-mirror.modal.local:5555/simple/numpy/numpy-2.2.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (62 kB)
Collecting fastrlock>=0.5 (from cupy-cuda12x)
  Downloading http://pypi-mirror.modal.local:5555/simple/fastrlock/fastrlock-0.8.3-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_28_x86_64.whl.metadata (7.7 kB)
Downloading http://pypi-mirror.modal.local:5555/simple/cupy-cuda12x/cupy_cuda12x-13.4.1-cp311-cp311-manylinux2014_x86_64.whl (105.4 MB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 105.4/105.4 MB 82.9 MB/s eta 0:00:00
Downloading http://pypi-mirror.modal.local:5555/simple/fastrlock/fastrlock-0.8.3-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_28_x86_64.whl (54 kB)
Downloading http://pypi-mirror.modal.local:5555/simple/numpy/numpy-2.2.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (16.4 MB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 16.4/16.4 MB 93.3 MB/s eta 0:00:00
Installing collected packages: fastrlock, numpy, cupy-cuda12x
Successfully installed cupy-cuda12x-13.4.1 fastrlock-0.8.3 numpy-2.2.4
Saving image...
Image saved, took 1.51s

Built image im-QeSqRPPfuR6PNrYdomv273 in 13.77s

✓ Created objects.
├── 🔨 Created mount E:\code\java\project-litongjava\java-generative-manim\src\main\resources\modal\get_started.py
└── 🔨 Created function square.

==========
== CUDA ==
==========

CUDA Version 12.4.0

Container image Copyright (c) 2016-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.

This container image and its contents are governed by the NVIDIA Deep Learning Container License.
By pulling and using the container, you accept the terms and conditions of this license:
https://developer.nvidia.com/ngc/nvidia-deep-learning-container-license

A copy of this license is made available in this container at /NGC-DL-CONTAINER-LICENSE for your convenience.

Sat Mar 29 19:38:57 2025
+-----------------------------------------------------------------------------------------+
| NVIDIA-SMI 570.86.15              Driver Version: 570.86.15      CUDA Version: 12.8     |
|-----------------------------------------+------------------------+----------------------+
| GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |
| Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
|                                         |                        |               MIG M. |
|=========================================+========================+======================|
|   0  NVIDIA A10G                    On  |   00000000:00:1E.0 Off |                    0 |
|  0%   35C    P8             17W /  300W |       1MiB /  23028MiB |      0%      Default |
|                                         |                        |                  N/A |
+-----------------------------------------+------------------------+----------------------+

+-----------------------------------------------------------------------------------------+
| Processes:                                                                              |
|  GPU   GI   CI              PID   Type   Process name                        GPU Memory |
|        ID   ID                                                               Usage      |
|=========================================================================================|
|  No running processes found                                                             |
+-----------------------------------------------------------------------------------------+
The square of 2 is 4
Stopping app - local entrypoint completed.
✓ App completed. View run at https://modal.com/apps/kaizhao/main/ap-FDotngEg7iQ3rZeottuTyh

2.使用 Gpu 加速的原理介绍

在构建 GPU 容器镜像过程中,步骤为

FROM nvidia/cuda:12.4.0-devel-ubuntu22.04
COPY /python/. /usr/local
RUN ln -s /usr/local/bin/python3 /usr/local/bin/python
ENV TERMINFO_DIRS=/etc/terminfo:/lib/terminfo:/usr/share/terminfo:/usr/lib/terminfo
COPY /modal_requirements.txt /modal_requirements.txt
RUN python -m pip install --upgrade pip wheel uv
RUN uv pip install --system --compile-bytecode --no-cache --no-deps -r /modal_requirements.txt
RUN rm /modal_requirements.txt

FROM base
RUN python -m pip install cupy-cuda12x

下面对整个容器镜像构建过程中的每一步进行详细说明:


第一阶段:基于 CUDA 开发镜像构建基础环境

  1. FROM nvidia/cuda:12.4.0-devel-ubuntu22.04

    • 作用:使用 NVIDIA 官方提供的 CUDA 开发版镜像作为基础环境。
    • 目的:该镜像内预装了 CUDA 工具链和相应的驱动支持,使得后续可以直接进行 GPU 编程、调试和加速。
    • 机制:这是 Dockerfile 中的基础镜像声明,所有后续指令都基于这个镜像进行构建。
  2. COPY /python/. /usr/local

    • 作用:将本地目录 /python/ 下的所有文件复制到容器内的 /usr/local 目录。
    • 目的:确保本地配置的 Python 环境文件或工具能够被容器使用,从而提供完善的 Python 运行环境。
    • 机制:类似于 Docker 的 COPY 命令,将构建上下文中的文件复制到镜像内指定位置。
  3. RUN ln -s /usr/local/bin/python3 /usr/local/bin/python

    • 作用:在容器内建立一个软链接,使得 python 命令指向 python3。
    • 目的:方便调用,避免因系统中默认指向 Python 2 或未定义而产生兼容性问题,确保所有 Python 命令调用的是 Python3。
    • 机制:通过创建符号链接实现命令别名,简化后续脚本和应用的调用方式。
  4. ENV TERMINFO_DIRS=/etc/terminfo:/lib/terminfo:/usr/share/terminfo:/usr/lib/terminfo

    • 作用:设置环境变量 TERMINFO_DIRS。
    • 目的:指定容器内查找终端信息(terminfo)数据库的路径,确保在不同终端环境下输出和交互信息能正确显示。
    • 机制:利用 Docker 的 ENV 指令,将变量注入到容器环境中,使得所有运行的程序都能访问并使用这个变量。
  5. COPY /modal_requirements.txt /modal_requirements.txt

    • 作用:将本地的 modal_requirements.txt 文件复制到容器根目录下。
    • 目的:该文件记录了应用所需要的所有 Python 包及其版本,通过复制进容器后便于统一安装依赖,从而实现依赖版本锁定和环境的一致性。
    • 机制:类似前面的 COPY 指令,将本地文件纳入镜像构建上下文,供后续步骤使用。
  6. RUN python -m pip install --upgrade pip wheel uv

    • 作用:升级 pip,并安装 wheel 和 uv 工具。
    • 目的:
      • 升级 pip 确保使用最新版本的包管理器,获得更好的性能和安全性;
      • 安装 wheel 有助于构建和安装 Python 包;
      • uv 是一种加速 pip 安装过程的工具。
    • 机制:使用 Python 的模块调用方式来运行 pip 命令,对基础 Python 环境进行更新和扩展。
  7. RUN uv pip install --system --compile-bytecode --no-cache --no-deps -r /modal_requirements.txt

    • 作用:利用 uv pip 根据 modal_requirements.txt 中的内容安装所有依赖包。
    • 目的:
      • 统一安装所有依赖,确保远程环境与本地环境一致;
      • 同时编译字节码,提高后续运行速度;
      • 禁用缓存和依赖检查,以避免不必要的安装或版本冲突。
    • 机制:该命令通过读取依赖文件,在容器中安装指定的包,并生成相应的字节码,确保环境构建完成后无需在运行时重新安装依赖。
  8. RUN rm /modal_requirements.txt

    • 作用:删除容器内的 modal_requirements.txt 文件。
    • 目的:减少镜像体积,防止泄露依赖列表(可能包含敏感信息),保持镜像整洁。
    • 机制:简单的文件删除操作,清除构建过程中临时使用的文件。

第二阶段:基于精简基础镜像安装 GPU 加速库

  1. FROM base

    • 作用:使用名为 base 的镜像作为新的构建基础。
    • 目的:在完成初步依赖安装后,切换到一个更精简的镜像,通常用于构建最终的生产环境镜像。
    • 机制:Docker 的多阶段构建,通过多个 FROM 指令构建出一个较小且仅包含必要运行环境的最终镜像。
  2. RUN python -m pip install cupy-cuda12x

    • 作用:在最终镜像中使用 pip 安装 cupy-cuda12x 包。
    • 目的:
      • cupy-cuda12x 是基于 CUDA 的加速库,旨在替代 NumPy 在 GPU 上的运算,从而显著提升计算性能。
      • 通过预装该包,可以确保在远程运行时无需再次进行安装,加速启动过程。
    • 机制:利用 pip 命令在最终环境中安装特定的 GPU 加速库,这一步通常在镜像构建过程中完成,而非在容器启动后再动态安装。

通过以上各步骤,整个 GPU 容器镜像构建过程实现了以下目标:

  • 依赖固定和环境一致性:将所有必要的 Python 包和工具在镜像构建时预先安装好,确保无论在本地还是远程运行,都能获得一致的环境。
  • 高性能 GPU 支持:使用 NVIDIA CUDA 镜像和安装 cupy-cuda12x,使得容器能够充分利用 GPU 进行加速运算。
  • 镜像精简与安全:利用多阶段构建和删除不必要的文件,减少最终镜像体积,同时避免敏感信息泄露。

这样的构建流程既保证了环境的稳定性与高效性,又方便后续的部署与扩展。


3. 远程环境下 安装原理

在 Modal 的远程容器环境中,所有依赖包(包括 cupy)应当在构建镜像时提前安装。如果你仅在函数内部调用 pip install cupy,那么由于远程运行时容器已经构建好并缓存,运行时不会再去安装 cupy。


4. 指定 token

Modal 推荐不要在代码中直接硬编码或设置 token,因为这会带来安全隐患。最佳做法是通过 CLI 命令(如 modal token set --token-id id --token-secret secret)或将 token 配置为环境变量(例如 MODAL_API_KEY),由 Modal 客户端在运行时自动加载这些凭据。如果你确实需要在代码中使用 token,建议将它存储在安全的配置文件或秘密管理系统中,然后读取到环境变量中,但直接硬编码到代码中是不被推荐的。

cat /root/.modal.toml 笔者的选择是维护配置文件

[kaizhao]
token_id = "ak-NXw"
token_secret = "as-moKQN8"
active = true

4. 如何在远程服务器上读取并运行本地脚本文件

要在 Modal 的远程环境中运行本地脚本文件,可以使用以下方法:

  1. 挂载本地目录
    利用 Modal 的挂载功能,将本地脚本所在目录挂载到远程容器。例如:

model_run_with_script.py

import modal

# 将本地脚本目录挂载到容器中的 /scripts 目录
local_scripts = modal.Mount.from_local_dir("scripts")
image = modal.Image.debian_slim().pip_install("numpy")

app = modal.App("example-run-local-script", image=image, mounts=[local_scripts])

@app.function()
def run_script():
    # 例如读取并执行 /scripts/test.py 脚本
    with open("/scripts/numpy_square.py", "r", encoding="utf-8") as f:
        script_content = f.read()
    exec(script_content)

modal.Mount usage will soon be deprecated. Use image.add_local_dir instead, which is functionally and performance-wise equivalent.

切换为使用 add_local_dir

import modal

# 创建镜像,并将本地 "scripts" 目录挂载到容器中的 /scripts 目录
image = modal.Image.debian_slim().pip_install("numpy").add_local_dir("scripts", "/scripts")

# 创建 Modal 应用,并指定使用更新后的镜像
app = modal.App("example-run-local-script", image=image)

@app.function()
def run_script():
    # 例如读取并执行 /scripts/numpy_square.py 脚本
    with open("/scripts/numpy_square.py", "r", encoding="utf-8") as f:
        script_content = f.read()
    exec(script_content)

  1. 将脚本打包进容器镜像
    另一种方法是在构建镜像时将本地脚本文件包含进去。可以在 modal.Image 构建过程中指定上下文目录,这样所有文件都会被打包到镜像中,然后在远程环境中直接调用。例如:

    image = modal.Image.debian_slim().pip_install("numpy")
    # 假设本地目录 "my_scripts" 包含需要运行的脚本
    # 可将该目录作为挂载目录或直接构建镜像时包含该目录
    app = modal.App("example-embed-script", image=image, mounts=[modal.Mount.from_local_dir("my_scripts")])
    
    @app.function()
    def run_script():
        exec(open("my_scripts/test.py", "r", encoding="utf-8").read())
    

这种方式能够确保在远程容器中顺利读取到本地文件,并按需执行脚本内容。


四、总结

本文详细介绍了如何借助 Modal.com 的云端 GPU 服务来加速 Python 渲染任务。通过以下步骤,用户可以轻松完成从环境配置、函数部署、容器定制、水平扩展到 GPU 加速运行的全过程:

  • 环境搭建与登录:使用 Modal CLI 快速登录并初始化应用。
  • 简单函数部署:将本地代码通过装饰器包装为云端任务,并验证输出。
  • 定制镜像:根据需要预装特定依赖(如 NumPy 或 cupy)。
  • 大规模并行处理:利用 .map 方法实现任务的水平扩展。
  • GPU 加速:结合官方 CUDA 镜像和 GPU 资源,实现更高效的渲染运算。

通过 Modal.com 强大的 GPU 加速能力,用户可以显著提升渲染与计算任务的执行效率,尤其适用于 AI 训练、视频处理和高性能图形渲染等场景。第一次运行可能稍慢,但随着缓存和镜像构建的完成,后续运行将会更加迅捷高效。


这就是利用 Modal.com 进行 Python GPU 加速渲染的完整流程。希望这篇文档对你在实际项目中的部署和优化有所帮助。

Edit this page
Last Updated:
Contributors: Tong Li
Prev
使用 modal 运行 manim 代码
Next
Modal 平台 GPU 环境下运行 Manim