SpacetimeDB 深度实战：当数据库成为服务器——从"光速开发"到生产级实时应用的完全指南（2026）

小编语：当整个行业还在争论"该用 ORM 还是原生 SQL"、"该用 MySQL 还是 PostgreSQL"的时候，SpacetimeDB 直接把问题本身颠覆了——为什么我们需要服务器？为什么数据库不能既是数据库又是服务器？

前言：一场静悄悄的架构革命

2026 年的某个凌晨，我正在调试一个实时多人协作应用的延迟问题。

客户端 → Load Balancer → Web Server → Application Server → Cache → Database，这趟"往返旅行"花了 200ms。用户说"卡"。我深知，这不是优化能解决的问题，这是架构原罪。

然后我遇到了 SpacetimeDB。

"Development at the speed of light"——这是 SpacetimeDB 的 Slogan。初看觉得是夸张的营销语言，但深入使用后我才明白：它不是在夸耀速度快，而是在描述一种开发范式的变化——当你把应用逻辑直接跑在数据库里，当客户端直连数据库，当你不再需要维护一堆服务器...那种感觉，确实像"光速"。

本文将带你：

1. 理解 SpacetimeDB 的核心创新：数据库即服务器范式
2. 深入 Rust 模块开发：从 Schema 定义到业务逻辑
3. 实战实时数据同步：原理、API、性能调优
4. 生产级架构设计：认证、权限、扩容、监控
5. 与其他技术栈的深度对比：为什么传统架构注定被淘汰

第一章：颠覆认知——SpacetimeDB 到底是什么？

1.1 传统架构的原罪

先看看我们熟悉的传统 Web/移动应用架构：

[Client] 
   ↓ HTTP/WebSocket
[Load Balancer]  ← 第一层抽象
   ↓
[Web Server] (Nginx/Apache)  ← 第二层抽象
   ↓
[App Server] (Node.js/Go/Rust)  ← 第三层抽象，这里写业务逻辑
   ↓ TCP/Connection Pool
[Database] (PostgreSQL/MySQL)  ← 第四层，存数据的地方

这个架构有什么问题？

1. 网络延迟叠加：每一次客户端请求，都要经过 3-4 层网络跳转
2. 数据序列化/反序列化开销：App Server 从 DB 取数据 → 转成对象 → 序列化成 JSON → 发给客户端
3. 状态不同步：多个 App Server 实例之间需要共享状态（用 Redis 吧？又多了一层）
4. 运维复杂度：要管 Load Balancer、Web Server、App Server、Cache、DB... 每个都是故障点

更要命的是：现代实时应用（游戏、协作编辑、IoT、金融交易）对延迟的要求是 <50ms，传统架构天生做不到。

1.2 SpacetimeDB 的范式转移

SpacetimeDB 的核心创新：把应用逻辑直接跑在数据库里。

[Client] 
   ↓ WebSocket (Single Connection)
[SpacetimeDB]  ← 既是数据库，又是服务器
   ↓
 (你的业务逻辑在这里运行)

关键差异：

这意味着什么？

1. 零网络开销：业务逻辑操作数据，不再需要网络通信
2. 类型安全：用 Rust 写逻辑，编译时保证类型正确
3. 实时推送：数据库主动推送数据变更到客户端（不是客户端轮询）
4. 简化运维：只需要部署 SpacetimeDB，不需要管服务器

1.3 适用场景：什么时候该用 SpacetimeDB？

✅ 非常适合：

1. 实时多人应用：游戏、协作编辑、聊天、白板
2. IoT 数据处理：传感器数据实时入库 + 实时分析
3. 金融交易系统：订单匹配、实时风控（延迟要求极高）
4. 实时监控系统：设备状态实时更新、告警推送

❌ 不适合：

1. 纯 CRUD 应用：内容管理系统、博客、电商后台（传统架构更合适）
2. 超大规模单表：PB 级数据分析（用专门的数据仓库）
3. 复杂报表生成：需要大量扫描和聚合（SpacetimeDB 主打 OLTP，不是 OLAP）

第二章：核心概念与架构深度解析

2.1 模块（Module）：你的应用逻辑载体

在 SpacetimeDB 中，Module 是应用逻辑的载体。你用 Rust（或 C#、TypeScript、C++）写一个模块，编译成 .spacetime 文件，然后上传到 SpacetimeDB。

模块包含：

• Schema 定义：表结构、索引、约束
• 业务逻辑：函数、过程、事件处理
• 客户端接口：自动生成 TypeScript/Unity/C++ SDK

示例：定义一个简单的聊天消息表

// 定义表
#[spacetime::table(name = "messages", index(name = "room_id_idx", btree(columns = ["room_id"])))]
pub struct Message {
    #[primary_key]
    pub id: u64,
    pub room_id: u64,
    pub sender: String,
    pub content: String,
    pub timestamp: Timestamp,
}

// 初始化函数（模块加载时执行）
#[spacetime::reducer(init)]
pub fn init() {
    log::info!("Chat module initialized!");
}

// Reducer：客户端可以调用的函数
#[spacetime::reducer]
pub fn send_message(ctx: &Context, room_id: u64, sender: String, content: String) {
    let message = Message {
        id: generate_id(),
        room_id,
        sender,
        content,
        timestamp: ctx.timestamp(),
    };
    
    // 插入数据库
    ctx.db.messages().insert(message);
    
    // 自动推送：所有订阅了 room_id 的客户端会收到这条消息
}

关键概念：

• Reducer：客户端可以调用的函数（类似传统架构的 API Endpoint）
• Table：数据库表（自动生成 CRUD 接口）
• Context：运行时上下文（提供数据库访问、时间戳、调用者信息等）

2.2 实时数据同步：Magic 是如何发生的？

SpacetimeDB 最强大的功能是自动实时数据同步。

传统方式（Polling）：

客户端: "有新消息吗？"
服务器: "没有。"
客户端: "现在有吗？"
服务器: "还没有。"
客户端: "现在呢？"
服务器: "有了！"

延迟高、服务器负载高、浪费带宽

SpacetimeDB 方式（Push）：

客户端: "订阅 room_id=123 的消息"
SpacetimeDB: "好的，以后有新消息我主动推给你"
...
[有新消息插入]
SpacetimeDB: "嘿，这是新消息！"  ← 主动推送

技术原理：

1. 客户端订阅查询：客户端执行一个 Query，SpacetimeDB 记录这个订阅
2. 数据变更检测：当有 Reducer 插入/更新/删除数据时，SpacetimeDB 检查哪些订阅的 Query 结果会变化
3. 增量推送：只推送变化的部分（不是整个表）

代码示例（TypeScript 客户端）：

import { ChatModule } from './generated/chat_module';

const client = new ChatModule.Client('ws://localhost:3000');

// 订阅某个房间的消息
const roomId = 123n;
const subscription = client.subscribe('messages', (messages) => {
    console.log('收到新消息:', messages);
});

// 发送消息（调用服务器端的 Reducer）
await client.reducers.sendMessage(roomId, 'Alice', 'Hello, SpacetimeDB!');

2.3 事务模型：Serializability 保证

SpacetimeDB 提供 Serializable 事务隔离级别（最高级别）。

这意味着：

• 所有 Reducer 调用都是原子性的（要么全成功，要么全失败）
• 并发调用会串行执行（不会相互干扰）
• 不需要手动加锁（数据库自动处理）

示例：转账操作

#[spacetime::reducer]
pub fn transfer(ctx: &Context, from: String, to: String, amount: u64) -> Result<(), String> {
    let mut accounts = ctx.db.accounts();
    
    // 查询余额
    let mut from_account = accounts.find_by_username(&from)
        .ok_or("Sender not found")?;
    
    if from_account.balance < amount {
        return Err("Insufficient balance".to_string());
    }
    
    let mut to_account = accounts.find_by_username(&to)
        .ok_or("Receiver not found")?;
    
    // 更新余额
    from_account.balance -= amount;
    to_account.balance += amount;
    
    accounts.update(&from_account);
    accounts.update(&to_account);
    
    // 事务提交：要么两个更新都成功，要么都失败
    Ok(())
}

关键点：

• 不需要 BEGIN TRANSACTION / COMMIT（自动管理）
• 如果 Reducer 返回 Err，事务自动回滚
• 如果 Reducer panic，事务自动回滚

第三章：Rust 模块开发实战

3.1 环境搭建

安装 SpacetimeDB：

# 安装 CLI
curl --proto '=https' --tlsv1.2 -sSf https://install.spacetimedb.com | sh

# 启动本地开发服务器
spacetime start

# 验证安装
spacetime version

创建新项目：

# 创建 Rust 模块项目
spacetime module new my_chat_app

# 项目结构
my_chat_app/
├── Cargo.toml
├── src/
│   └── lib.rs       ← 主入口
├── .spacetime/      ← 编译配置
└── generated/       ← 自动生成的客户端 SDK

3.2 第一个模块：实时聊天室

Step 1: 定义 Schema

// src/lib.rs
use spacetime::*;

// 定义用户表
#[table(name = "users", index(name = "name_idx", btree(columns = ["name"])))]
pub struct User {
    #[primary_key]
    pub identity: Identity,  // SpacetimeDB 自动管理的用户身份
    pub name: String,
    pub online: bool,
    pub last_seen: Timestamp,
}

// 定义房间表
#[table(name = "rooms")]
pub struct Room {
    #[primary_key]
    pub id: u64,
    pub name: String,
    pub created_by: Identity,
    pub created_at: Timestamp,
}

// 定义消息表
#[table(name = "messages", index(name = "room_idx", btree(columns = ["room_id"])))]
pub struct Message {
    #[primary_key]
    pub id: u64,
    pub room_id: u64,
    pub sender_identity: Identity,
    pub sender_name: String,
    pub content: String,
    pub sent_at: Timestamp,
}

Step 2: 实现 Reducers（客户端可调用的函数）

// 用户加入
#[reducer]
pub fn join_chat(ctx: &Context, name: String) -> Result<(), String> {
    let identity = ctx.sender();
    let mut users = ctx.db.users();
    
    // 检查用户名是否已存在
    if users.filter_by_name(&name).next().is_some() {
        return Err("Username already taken".to_string());
    }
    
    // 插入用户
    users.insert(User {
        identity,
        name,
        online: true,
        last_seen: ctx.timestamp(),
    });
    
    log::info!("User {} joined", name);
    Ok(())
}

// 创建房间
#[reducer]
pub fn create_room(ctx: &Context, room_name: String) -> Result<u64, String> {
    let identity = ctx.sender();
    let rooms = ctx.db.rooms();
    
    let room_id = generate_id();
    rooms.insert(Room {
        id: room_id,
        name: room_name,
        created_by: identity,
        created_at: ctx.timestamp(),
    });
    
    log::info!("Room created: id={}, by={:?}", room_id, identity);
    Ok(room_id)
}

// 发送消息
#[reducer]
pub fn send_message(ctx: &Context, room_id: u64, content: String) -> Result<(), String> {
    let identity = ctx.sender();
    let users = ctx.db.users();
    let messages = ctx.db.messages();
    
    // 获取发送者信息
    let user = users.find_by_identity(&identity)
        .ok_or("User not found")?;
    
    // 插入消息
    let message_id = generate_id();
    messages.insert(Message {
        id: message_id,
        room_id,
        sender_identity: identity,
        sender_name: user.name.clone(),
        content,
        sent_at: ctx.timestamp(),
    });
    
    // 自动推送：所有订阅了这个房间的客户端会收到新消息
    Ok(())
}

// 用户离开（可选：也可以用心跳机制自动检测离线）
#[reducer]
pub fn leave_chat(ctx: &Context) {
    let identity = ctx.sender();
    let mut users = ctx.db.users();
    
    if let Some(mut user) = users.find_by_identity(&identity) {
        user.online = false;
        user.last_seen = ctx.timestamp();
        users.update(&user);
    }
}

Step 3: 编译和部署

# 编译模块
spacetime module build

# 部署到本地开发服务器
spacetime module publish my_chat_app

# 查看日志
spacetime module logs my_chat_app

3.3 客户端集成（TypeScript）

SpacetimeDB 会自动生成 TypeScript SDK：

// 安装生成的 SDK
npm install ./generated/typescript_client

// 使用示例
import { MyChatApp } from 'my_chat_app_client';

const client = new MyChatApp.Client('ws://localhost:3000');

// 连接数据库
await client.connect();

// 调用 Reducer
await client.reducers.joinChat('Alice');

// 订阅消息表的变化
client.subscriptionBuilder()
    .on('messages', (messages) => {
        messages.forEach(msg => {
            console.log(`${msg.senderName}: ${msg.content}`);
        });
    })
    .subscribe();

// 发送消息
await client.reducers.sendMessage(1n, 'Hello, everyone!');

第四章：性能优化与最佳实践

4.1 索引设计

SpacetimeDB 支持两种索引：

• BTree 索引：适合范围查询（<, >, BETWEEN）
• Hash 索引：适合精确匹配（=）

示例：为消息表添加复合索引

#[table(
    name = "messages",
    index(name = "room_time_idx", btree(columns = ["room_id", "sent_at"]))
)]
pub struct Message {
    // ...
}

** optimize 查询：**

// 慢查询：全表扫描
let all_messages = ctx.db.messages().iter();  // ❌ 避免

// 快查询：使用索引
let room_messages = ctx.db.messages()
    .filter_by_room_id(room_id)  // ✅ 使用索引
    .filter(|msg| msg.sent_at > since);

4.2 批量操作

避免逐行插入/更新：

// ❌ 慢：每次 insert 都触发一次推送
for i in 0..1000 {
    ctx.db.messages().insert(Message { ... });
}

// ✅ 快：批量操作后统一推送
let messages = ctx.db.messages();
for i in 0..1000 {
    messages.insert(Message { ... });
}
// 只触发一次批量推送

4.3 订阅优化

只订阅需要的数据：

// ❌ 差：订阅整个表
client.subscriptionBuilder().on('messages', callback).subscribe();

// ✅ 好：只订阅特定房间
client.subscriptionBuilder()
    .sql(`SELECT * FROM messages WHERE room_id = ${roomId}`)
    .on('messages', callback)
    .subscribe();

4.4 内存管理

SpacetimeDB 运行在内存中，需要注意：

1. 限制表大小：定期归档旧数据
2. 使用 Timestamp 分区：按时间分表
3. 避免大字段：不要把文件、图片存到数据库

示例：自动清理 30 天前的消息

#[reducer]
pub fn cleanup_old_messages(ctx: &Context) {
    let threshold = ctx.timestamp() - Duration::days(30);
    let messages = ctx.db.messages();
    
    let old_messages: Vec<_> = messages
        .filter(|msg| msg.sent_at < threshold)
        .collect();
    
    for msg in old_messages {
        messages.delete(&msg);
    }
    
    log::info!("Cleaned up old messages");
}

第五章：生产级部署与监控

5.1 认证与权限

SpacetimeDB 提供内置的身份管理：

// 获取调用者身份
let identity = ctx.sender();

// 检查权限
#[reducer]
pub fn delete_message(ctx: &Context, message_id: u64) -> Result<(), String> {
    let identity = ctx.sender();
    let messages = ctx.db.messages();
    
    let msg = messages.find_by_id(&message_id)
        .ok_or("Message not found")?;
    
    // 只有发送者可以删除
    if msg.sender_identity != identity {
        return Err("Permission denied".to_string());
    }
    
    messages.delete(&msg);
    Ok(())
}

集成外部认证（如 JWT）：

#[reducer]
pub fn authenticate(ctx: &Context, jwt_token: String) -> Result<(), String> {
    // 验证 JWT
    let claims = verify_jwt(&jwt_token)?;
    
    // 将 JWT 中的 user_id 与 SpacetimeDB identity 关联
    let mut users = ctx.db.users();
    if let Some(mut user) = users.find_by_identity(&ctx.sender()) {
        user.external_id = Some(claims.user_id);
        users.update(&user);
    }
    
    Ok(())
}

5.2 监控与日志

内置日志：

#[reducer]
pub fn my_reducer(ctx: &Context) {
    log::info!("Info level log");
    log::warn!("Warning: something unusual");
    log::error!("Error occurred: {}", error);
}

查看日志：

spacetime module logs my_app --follow

性能指标：

SpacetimeDB 提供内置的性能监控：

• Reducer 执行时间
• 订阅数量
• 内存使用量

访问 Web UI：http://localhost:3000/metrics

5.3 高可用部署

单机部署（开发/测试）：

spacetime start

集群部署（生产）：

目前 SpacetimeDB 还在快速迭代中，生产级集群方案建议：

1. 使用 Kubernetes 部署多个实例
2. 用 Load Balancer 做流量分发
3. 定期备份数据（SpacetimeDB 支持快照）

第六章：与其他技术的深度对比

6.1 SpacetimeDB vs PostgreSQL + 服务器

6.2 SpacetimeDB vs Firebase Realtime Database

6.3 SpacetimeDB vs 传统游戏服务器（如 Unity Netcode）

第七章：真实案例——构建实时协作白板

7.1 需求分析

我们要构建一个实时协作白板应用，功能包括：

• 多个用户同时绘制
• 实时看到其他人的光标位置
• 支持文字聊天
• 保存白板状态

7.2 数据模型设计

// 白板表
#[table(name = "whiteboards")]
pub struct Whiteboard {
    #[primary_key]
    pub id: u64,
    pub name: String,
    pub created_by: Identity,
    pub created_at: Timestamp,
}

// 绘图对象表
#[table(name = "drawings", index(name = "board_idx", btree(columns = ["board_id"])))]
pub struct Drawing {
    #[primary_key]
    pub id: u64,
    pub board_id: u64,
    pub object_type: String,  // "line", "circle", "rect"
    pub points: Vec<Point>,   // 坐标点
    pub color: String,
    pub thickness: f32,
    pub created_by: Identity,
}

// 光标位置表（临时数据，不需要持久化）
#[table(name = "cursors")]
pub struct Cursor {
    #[primary_key]
    pub user_identity: Identity,
    pub board_id: u64,
    pub x: f32,
    pub y: f32,
    pub updated_at: Timestamp,
}

7.3 核心 Reducer 实现

// 绘制
#[reducer]
pub fn draw(ctx: &Context, board_id: u64, object_type: String, points: Vec<Point>, color: String, thickness: f32) {
    let identity = ctx.sender();
    let drawings = ctx.db.drawings();
    
    let drawing_id = generate_id();
    drawings.insert(Drawing {
        id: drawing_id,
        board_id,
        object_type,
        points,
        color,
        thickness,
        created_by: identity,
    });
}

// 更新光标位置
#[reducer]
pub fn update_cursor(ctx: &Context, board_id: u64, x: f32, y: f32) {
    let identity = ctx.sender();
    let mut cursors = ctx.db.cursors();
    
    if let Some(mut cursor) = cursors.find_by_user_identity(&identity) {
        cursor.x = x;
        cursor.y = y;
        cursor.updated_at = ctx.timestamp();
        cursors.update(&cursor);
    } else {
        cursors.insert(Cursor {
            user_identity: identity,
            board_id,
            x,
            y,
            updated_at: ctx.timestamp(),
        });
    }
}

7.4 客户端实现（TypeScript + React）

import React, { useState, useEffect } from 'react';
import { WhiteboardModule } from './generated/whiteboard_module';

const WhiteboardApp: React.FC = () => {
    const [client] = useState(new WhiteboardModule.Client('ws://localhost:3000'));
    const [drawings, setDrawings] = useState<Drawing[]>([]);
    const [cursors, setCursors] = useState<Cursor[]>([]);
    
    useEffect(() => {
        // 连接数据库
        client.connect();
        
        // 订阅绘图对象
        client.subscriptionBuilder()
            .sql('SELECT * FROM drawings WHERE board_id = 1')
            .on('drawings', (drawings) => {
                setDrawings(drawings);
            })
            .subscribe();
        
        // 订阅光标位置
        client.subscriptionBuilder()
            .on('cursors', (cursors) => {
                setCursors(cursors);
            })
            .subscribe();
    }, []);
    
    // 绘制时调用 Reducer
    const handleDraw = (points: Point[]) => {
        await client.reducers.draw(1n, 'line', points, '#000000', 2.0);
    };
    
    // 鼠标移动时更新光标
    const handleMouseMove = (x: number, y: number) => {
        await client.reducers.updateCursor(1n, x, y);
    };
    
    return (
        <canvas
            onMouseMove={(e) => handleMouseMove(e.clientX, e.clientY)}
            onMouseUp={(e) => handleDraw(...)}
        >
            {/* 渲染绘图对象 */}
            {drawings.map(d => <DrawingObject key={d.id} {...d} />)}
            
            {/* 渲染其他用户的光标 */}
            {cursors.map(c => <CursorMarker key={c.userIdentity} {...c} />)}
        </canvas>
    );
};

第八章：深入理解——SpacetimeDB 的技术内幕

8.1 存储引擎

SpacetimeDB 使用 内存优先 的存储引擎：

• 热数据在内存
• 冷数据可配置刷盘（类似 Redis AOF）
• 支持快照（Snapshot）和恢复

优势：

• 读写延迟极低（微秒级）
• 适合实时应用

劣势：

• 内存成本较高
• 数据量受内存限制

8.2 事务实现

SpacetimeDB 使用 乐观并发控制（OCC）：

1. Reducer 开始时，获取数据库快照
2. 执行逻辑，修改数据（在私有工作区）
3. 提交时，检查是否有冲突
4. 无冲突 → 提交；有冲突 → 重试

这意味着：

• 读操作不需要加锁（快照隔离）
• 写冲突时自动重试（客户端无感知）

8.3 网络协议

SpacetimeDB 使用 WebSocket 作为客户端通信协议：

• 双向实时通信
• 自动重连
• 协议缓冲区（Protobuf）序列化

推送机制：

1. 客户端订阅 Query
2. 数据库维护订阅表
3. 数据变更时，计算受影响的订阅
4. 生成增量更新，推送给客户端

第九章：未来展望与生态发展

9.1 Roadmap（2026-2027）

根据官方 Roadmap：

1. 集群模式：多节点部署，自动分片
2. SQL 支持增强：更复杂的查询（JOIN、子查询）
3. 更多语言支持：Python、Ruby 模块
4. 云托管服务：类似 Supabase 的 SaaS 产品

9.2 社区与生态

官方资源：

• GitHub: https://github.com/clockworklabs/SpacetimeDB
• Discord: 活跃社区（~10k 成员）
• 文档: https://spacetimedb.com/docs

第三方工具（开发中）：

• ORM 适配器
• 管理 UI
• 备份工具

9.3 与传统架构的融合

SpacetimeDB 不一定完全替代传统架构，而是互补：

混合架构示例：

[传统 Web 服务]  ← 处理 CRUD、报表、管理后台
       ↓
[SpacetimeDB]   ← 处理实时功能（聊天、协作、游戏）
       ↓
[PostgreSQL]    ← 持久化存储（从 SpacetimeDB 定期归档）

第十章：总结与思考

10.1 核心要点回顾

1. 范式创新：数据库即服务器，消除中间层
2. 实时优先：原生支持实时数据同步
3. 开发效率：自动生成 SDK，类型安全
4. 性能卓越：内存数据库 + 零网络开销
5. 适用场景：实时多人应用、IoT、交易系统

10.2 什么时候该用 SpacetimeDB？

✅ 用：

• 需要实时数据同步
• 延迟要求 <50ms
• 团队熟悉 Rust（或愿意学）
• 希望简化运维

❌ 不用：

• 纯 CRUD 应用
• 超大规模数据分析
• 团队只有 JavaScript 经验（等 TypeScript 模块支持成熟）

10.3 个人感悟

使用 SpacetimeDB 开发的过程中，我最大的感受是："原来还可以这样！"

它让我意识到，我们习以为常的"服务器 + 数据库"架构，并不是唯一解。当技术和需求发展到一定阶段，必然会出现新的范式。

SpacetimeDB 不是银弹，但它指明了一个方向：更简单的架构、更快的开发、更好的实时体验。

如果你正在做实时应用，强烈建议试一试 SpacetimeDB。它可能会改变你对"后端开发"的认知。

附录 A：完整代码示例

GitHub 仓库：本文完整代码已开源

• Rust 模块：https://github.com/example/spacetimedb-chat
• TypeScript 客户端：https://github.com/example/spacetimedb-chat-client
• 部署脚本：https://github.com/example/spacetimedb-deploy

附录 B：常见问题 FAQ

Q: SpacetimeDB 稳定吗？能用于生产吗？
A: 目前（2026 年中）版本是 0.9.x，建议用于 side project 或内部系统。生产部署需做好监控和备份。

Q: 如何处理数据持久化？
A: SpacetimeDB 支持配置 WAL（Write-Ahead Log），数据会定期刷盘。也可以写脚本定期导出到 PostgreSQL。

Q: 支持哪些客户端语言？
A: 官方支持 TypeScript、C#、C++。社区在开发 Rust、Python、Swift SDK。

Q: 如何调试 Reducer？
A: 使用 log::info! 打印日志，或用 spacetime module logs 查看。IDE 调试支持在路线图中。

参考资源

1. SpacetimeDB 官方文档: https://spacetimedb.com/docs
2. GitHub 仓库: https://github.com/clockworklabs/SpacetimeDB
3. 社区 Discord: https://discord.gg/spacetimedb
4. 性能基准测试: https://spacetimedb.com/benchmarks
5. 实战教程: https://spacetimedb.com/tutorials

完

作者：程序员茄子
日期：2026-06-11
字数：约 12,000 字

小编后记：写这篇文章的过程中，我一边学一边写，一边写一边感叹：技术的发展真是太快了。几年前我们还在争论"该用 Monolith 还是 Microservices"，现在已经开始思考"还需要服务器吗？"这个问题。

SpacetimeDB 可能不是终极解，但它提出的问题值得每个开发者思考：我们的架构，是不是太复杂了？能不能更简单？

与诸君共勉。