☁️ 托管方案：VPS / Container / Serverless / Edge

概述：四种托管范式

托管方案的选择本质上是控制权 vs 便利性的权衡。你掌控越多，运维负担越重；你交给平台越多，灵活性越受限。

VPS / 云服务器

是什么

虚拟专用服务器——你获得一台（虚拟的）Linux 机器，拥有 root 权限，可以安装任何软件、运行任何进程。这是最传统也最灵活的托管方式。

主流提供商与定价

实际部署示例：Hetzner Cloud + Docker

# 1. 安装 hcloud CLI
brew install hcloud  # 或: curl ... | bash

# 2. 创建服务器 (最便宜的 CX22)
hcloud server create \
  --name my-saas \
  --type cx22 \
  --image ubuntu-24.04 \
  --location fsn1

# 3. SSH 登录并安装 Docker
ssh root@<IP>
curl -fsSL https://get.docker.com | sh
docker swarm init  # 单节点 Swarm，后续可扩展

# 4. 部署应用
docker compose up -d

# 5. 配置防火墙 (hcloud CLI)
hcloud firewall create --name my-firewall --rules-file firewall.json
hcloud firewall apply-to-server my-firewall my-saas

自动化 Provisioning：用 Terraform 管理

# main.tf - Hetzner Cloud
terraform {
  required_providers {
    hcloud = { source = "hetznercloud/hcloud" }
  }
}

variable "hcloud_token" { sensitive = true }

provider "hcloud" { token = var.hcloud_token }

resource "hcloud_server" "web" {
  name        = "saas-prod"
  server_type = "cx22"           # €3.29/月
  image       = "ubuntu-24.04"
  location    = "fsn1"
  ssh_keys    = [hcloud_ssh_key.default.id]

  # 启动后自动安装 Docker
  user_data = file("cloud-init.yaml")
}

resource "hcloud_ssh_key" "default" {
  name       = "admin"
  public_key = file("~/.ssh/id_ed25519.pub")
}

output "ip" { value = hcloud_server.web.ipv4_address }

# cloud-init.yaml
#cloud-config
packages:
  - docker.io
  - docker-compose-plugin
  - nginx
  - certbot
  - python3-certbot-nginx

runcmd:
  - systemctl enable docker
  - usermod -aG docker ubuntu
  - ufw allow 22/tcp
  - ufw allow 80/tcp
  - ufw allow 443/tcp
  - ufw --force enable

优劣对比

VPS 安全加固清单

#!/bin/bash
# vps-harden.sh — 新 VPS 必做安全加固

# 1. 更新系统
apt update && apt upgrade -y

# 2. 创建非 root 用户
adduser deploy
usermod -aG sudo deploy

# 3. SSH 加固
sed -i 's/#PermitRootLogin yes/PermitRootLogin no/' /etc/ssh/sshd_config
sed -i 's/#PasswordAuthentication yes/PasswordAuthentication no/' /etc/ssh/sshd_config
systemctl restart sshd

# 4. 防火墙
ufw default deny incoming
ufw default allow outgoing
ufw allow 22/tcp
ufw allow 80/tcp
ufw allow 443/tcp
ufw --force enable

# 5. 自动安全更新
apt install -y unattended-upgrades
dpkg-reconfigure -plow unattended-upgrades

# 6. Fail2ban 防暴力破解
apt install -y fail2ban
systemctl enable fail2ban

# 7. 安装 Docker
curl -fsSL https://get.docker.com | sh
usermod -aG docker deploy

容器托管 (Container-as-a-Service)

是什么

你只需提供 Docker 镜像（或 Dockerfile），平台负责构建、部署、扩缩、负载均衡。你仍然控制容器内的环境，但不再管理底层服务器。

主流平台

实战：Fly.io 部署 Next.js + Postgres

# 1. 安装 Fly CLI
curl -L https://fly.io/install.sh | sh

# 2. 登录
fly auth login

# 3. 初始化项目
fly launch  # 自动检测 Next.js，生成 fly.toml + Dockerfile

# 4. 创建 Postgres 数据库
fly postgres create
fly postgres attach <db-name>

# 5. 设置环境变量
fly secrets set NEXTAUTH_SECRET=$(openssl rand -hex 32)
fly secrets set DATABASE_URL=<auto-from-attach>

# 6. 部署！
fly deploy

# 7. 扩展到多区域
fly regions add nrt  # 东京
fly regions add sin  # 新加坡

# fly.toml — Fly.io 配置文件
app = "my-saas"
primary_region = "sjc"

[build]
  dockerfile = "Dockerfile"

[env]
  PORT = "3000"

[http_service]
  internal_port = 3000
  force_https = true
  auto_stop_machines = "stop"
  auto_start_machines = true
  min_machines_running = 1    # 保持 1 台热启动

[checks]
  [checks.alive]
    type = "http"
    port = 3000
    path = "/api/health"
    interval = "10s"
    timeout = "5s"

实战：Coolify 自托管 PaaS (VPS 上跑)

# 在 Hetzner VPS (€3.29/月) 上安装 Coolify
# 这给你一个 Heroku 级别的 PaaS，但只花 VPS 的钱

curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash

# 安装后访问 http://<IP>:8000
# 然后通过 Web 界面：
# 1. 连接 GitHub 仓库
# 2. 自动检测 Dockerfile / nixpacks
# 3. 一键部署
# 4. 自动 SSL (Let's Encrypt)
# 5. 数据库一键创建 (PostgreSQL/MySQL/Redis/MongoDB)
# 6. 支持多个项目/服务

# Coolify 优势：
# - 完全开源 (Apache 2.0)
# - 无厂商锁定 (标准 Docker)
# - 成本 = VPS 价格
# - 支持多台服务器
# - 自动备份

优劣对比

Serverless / FaaS (Function-as-a-Service)

是什么

你只写函数，平台负责一切：从 HTTP 请求到函数执行的完整链路。函数只在请求到来时运行，按实际执行时间计费。没有服务器要管理，没有进程要守护。

主流平台

实战：Cloudflare Workers + Hono (API 服务)

// src/index.ts — Cloudflare Worker API
import { Hono } from 'hono'
import { cors } from 'hono/cors'
import { jwt } from 'hono/jwt'

type Bindings = {
  DB: D1Database
  JWT_SECRET: string
}

const app = new Hono<{ Bindings: Bindings }>()

// 全局中间件
app.use('/*', cors())

// 公开路由
app.get('/api/health', (c) => c.json({ status: 'ok' }))

app.post('/api/auth/login', async (c) => {
  const { email, password } = await c.req.json()
  const user = await c.env.DB.prepare(
    'SELECT * FROM users WHERE email = ?'
  ).bind(email).first()

  if (!user) return c.json({ error: 'Not found' }, 404)

  // 验证密码...
  return c.json({ token: 'jwt-token-here' })
})

// 受保护路由
app.use('/api/*', jwt({ secret: 'JWT_SECRET' }))

app.get('/api/projects', async (c) => {
  const { results } = await c.env.DB.prepare(
    'SELECT * FROM projects WHERE user_id = ?'
  ).bind(c.get('jwtPayload').sub).all()

  return c.json(results)
})

export default app

# wrangler.toml — Cloudflare Workers 配置
name = "my-saas-api"
main = "src/index.ts"
compatibility_date = "2024-12-01"

[[d1_databases]]
binding = "DB"
database_name = "my-saas-db"
database_id = "xxx-xxx-xxx"

[vars]
JWT_SECRET = "change-me-in-secrets"

# 部署
# wrangler d1 create my-saas-db
# wrangler d1 migrations apply my-saas-db
# wrangler deploy

实战：Vercel Serverless + Next.js App Router

// app/api/webhooks/stripe/route.ts
import { headers } from 'next/headers'
import Stripe from 'stripe'

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!)

export async function POST(req: Request) {
  const body = await req.text()
  const sig = headers().get('stripe-signature')!

  try {
    const event = stripe.webhooks.constructEvent(
      body, sig, process.env.STRIPE_WEBHOOK_SECRET!
    )

    switch (event.type) {
      case 'checkout.session.completed':
        // 处理支付成功
        const session = event.data.object
        await handleCheckoutComplete(session)
        break
      case 'customer.subscription.updated':
        // 处理订阅变更
        await handleSubscriptionUpdate(event.data.object)
        break
    }

    return Response.json({ received: true })
  } catch {
    return Response.json({ error: 'Invalid signature' }, { status: 400 })
  }
}

Serverless 冷启动深度解析

冷启动优化策略

// 1. 保持函数精简 — 减小 bundle size
// next.config.js
module.exports = {
  experimental: {
    serverComponentsExternalPackages: ['sharp'],  // 排除大依赖
  },
}

// 2. 全局缓存 — 在函数初始化时预加载
let dbClient: PrismaClient | null = null

function getDb() {
  if (!dbClient) {
    dbClient = new PrismaClient({
      datasourceUrl: process.env.DATABASE_URL_POOL, // 用 pooler URL
    })
  }
  return dbClient
}

// 3. Provisioned Concurrency (AWS Lambda) — 保持实例热
// serverless.yml
functions:
  api:
    handler: handler.main
    provisionedConcurrency: 2  # 始终保持 2 个热实例，$14/月额外

// 4. Vercel Edge Runtime — 消除冷启动
// app/api/fast/route.ts
export const runtime = 'edge'  // V8 isolate，<5ms 冷启动
export async function GET() {
  return Response.json({ hello: 'world' })
}

优劣对比

Edge / 边缘计算

是什么

把代码部署到全球数百个节点（Point of Presence），用户的请求被路由到最近的节点执行。不是"发到美国处理再返回"，而是"在用户旁边处理"。延迟从 200ms+ 降到 10ms。

主流平台

实战：Cloudflare Workers 全栈 SaaS

// 完整的边缘 SaaS 架构
// 
// 架构:
//   用户 → Cloudflare CDN (最近的 PoP) 
//        → Worker (处理请求)
//        → D1 (SQL 数据库，只读副本就近)
//        → R2 (对象存储，兼容 S3)
//        → KV (全局键值，配置/特征开关)

// wrangler.toml
name = "edge-saas"
main = "src/index.ts"

[[d1_databases]]
binding = "DB"
database_name = "edge-saas"
database_id = "xxx"

[[r2_buckets]]
binding = "STORAGE"
bucket_name = "user-uploads"

[[kv_namespaces]]
binding = "CONFIG"
id = "xxx"

[vars]
ENVIRONMENT = "production"

// src/index.ts — 边缘 API
import { Hono } from 'hono'

type Env = {
  DB: D1Database
  STORAGE: R2Bucket
  CONFIG: KVNamespace
  STRIPE_KEY: string
}

const app = new Hono<{ Bindings: Env }>()

// A/B 测试 — 用 KV 在边缘做分流
app.get('/', async (c) => {
  const variant = Math.random() > 0.5 ? 'A' : 'B'
  const config = await c.env.CONFIG.get(`landing:${variant}`, 'json')

  return c.html(renderLanding(config))
})

// 就近读取 — D1 自动路由到最近副本
app.get('/api/products', async (c) => {
  const cacheKey = new Request(c.req.url, c.req)
  const cache = caches.default

  // 先查 CDN 缓存
  let response = await cache.match(cacheKey)
  if (response) return response

  // 缓存未命中，查 D1
  const { results } = await c.env.DB.prepare(
    'SELECT * FROM products WHERE active = 1 ORDER BY created_at DESC LIMIT 50'
  ).all()

  response = Response.json(results, {
    headers: { 'Cache-Control': 'public, max-age=60' },
  })

  // 写入边缘缓存
  c.executionCtx.waitUntil(cache.put(cacheKey, response.clone()))

  return response
})

// 文件上传 — 直接到 R2
app.post('/api/upload', async (c) => {
  const formData = await c.req.formData()
  const file = formData.get('file') as File

  const key = `uploads/${crypto.randomUUID()}/${file.name}`
  await c.env.STORAGE.put(key, file.stream())

  return c.json({ key, url: `/api/files/${key}` })
})

export default app

Edge 的限制与应对

优劣对比

成本深度对比

场景 1：MVP 阶段 (0-1K 用户)

场景 2：增长阶段 (1K-50K 用户)

场景 3：规模化阶段 (50K+ 用户)

成本可视化：$100/月你能跑什么

决策框架：何时选什么

你需要什么？
│
├─ "我只想让我的应用跑起来" ─→ VPS + Coolify (€3.29/月)
│
├─ "我要最少的运维" ─→ Vercel / Railway ($5-20/月)
│
├─ "我的用户在全球各地" ─→ Fly.io 或 Cloudflare Workers
│
├─ "我需要跑重型后台任务" ─→ VPS (Hetzner/腾讯云)
│
├─ "我要最便宜" ─→ Oracle Free Tier ($0) 或 Hetzner (€3.29)
│
├─ "我要中国市场" ─→ 腾讯云/阿里云 (必须备案)
│
└─ "我已经有用户在增长" ─→ 混合架构 (见下文)
  

按项目阶段的推荐

按技术栈的推荐

混合架构实战

现实中的 SaaS 不是纯 VPS 或纯 Serverless——而是组合使用，每种工作负载用最适合的托管方式。

推荐混合架构 (2025-2026)

实战配置

# 混合架构实现 — 以 SaaS 订阅产品为例

# ━━━━━━ 层 1: Cloudflare (DNS + CDN + Edge) ━━━━━━
# Cloudflare Dashboard:
# 1. DNS 指向 Vercel (前端) 和 VPS (API)
# 2. Workers 处理:
#    - 认证检查 (JWT 验证在边缘)
#    - A/B 测试 (KV 存储变体)
#    - 速率限制
#    - 缓存 API 响应

# ━━━━━━ 层 2: Vercel (Next.js 前端) ━━━━━━
# vercel.json
{
  "rewrites": [
    { "source": "/api/(.*)", "destination": "https://api.mysaas.com/$1" }
  ]
}
# 前端 + SSR + ISR 在 Vercel
# API 调用代理到 VPS

# ━━━━━━ 层 3: VPS (API + 后台任务) ━━━━━━
# docker-compose.yml on Hetzner VPS
services:
  api:
    build: .
    ports: ["3001:3001"]
    environment:
      - DATABASE_URL=${DATABASE_URL}
      - REDIS_URL=redis://redis:6379
    deploy:
      resources:
        limits:
          memory: 1G

  worker:
    build: .
    command: node dist/worker.js
    environment:
      - DATABASE_URL=${DATABASE_URL}
      - REDIS_URL=redis://redis:6379
    deploy:
      resources:
        limits:
          memory: 512M

  redis:
    image: redis:7-alpine
    volumes: ["redis-data:/data"]

  # Stripe Webhook 接收
  stripe-wh:
    build: .
    command: node dist/stripe-webhook.js
    ports: ["3002:3002"]

volumes:
  redis-data:

# ━━━━━━ 层 4: 数据 ━━━━━━
# Supabase (托管的 Postgres + Auth + Storage)
# 或者自建 Postgres 在 VPS 上

每月成本估算

迁移策略

随着 SaaS 增长，托管方案必然需要升级。以下是常见的迁移路径和注意事项。

常见迁移路径

迁移时的数据迁移

# 从 SQLite → PostgreSQL 迁移示例
# (常见于从 VPS 单机 → 托管数据库)

# 1. 用 pgloader 一键迁移
# 安装
apt install pgloader

# 执行迁移
pgloader sqlite:///path/to/app.db \
  postgresql://user:pass@host:5432/mydb

# 2. 或者用 Prisma 迁移
npx prisma migrate diff \
  --from-schema-datasource prisma/schema.prisma \
  --to-schema-datamodel prisma/schema.prisma \
  --script > migration.sql

# 3. 零停机迁移策略
# a) 双写：新代码同时写旧 DB 和新 DB
# b) 验证：对比两边数据一致性
# c) 切换：读取切到新 DB
# d) 清理：停止写旧 DB

# 4. 回滚方案
# 保留旧 DB 7 天，只读模式
# 发现问题立即切回

迁移 Checklist

关联：Agent 系统的托管考量

如果你在构建 AI Agent 产品（参考 Agent 架构研究），托管方案有特殊要求：

# Agent Worker 部署方案
# docker-compose.yml
services:
  agent-worker:
    build: .
    command: node dist/agent-worker.js
    environment:
      - REDIS_URL=redis://redis:6379
      - LLM_API_KEY=${LLM_API_KEY}
    # 无时间限制，直到任务完成
    # 用 BullMQ/Inngest 管理任务队列

// Next.js Route Handler — 流式 Agent 响应
export async function POST(req: Request) {
  const encoder = new TextEncoder()
  const stream = new ReadableStream({
    async start(controller) {
      // 调用 Agent，逐 token 输出
      for await (const chunk of agent.run(prompt)) {
        controller.enqueue(
          encoder.encode(`data: ${JSON.stringify({ text: chunk })}\n\n`)
        )
      }
      controller.enqueue(encoder.encode('data: [DONE]\n\n'))
      controller.close()
    }
  })

  return new Response(stream, {
    headers: {
      'Content-Type': 'text/event-stream',
      'Cache-Control': 'no-cache',
    }
  })
}

# AI Agent 产品推荐托管架构
#
# ┌─────────────┐     ┌──────────────┐     ┌──────────────┐
# │   Vercel    │     │  Hetzner VPS │     │  Cloudflare  │
# │  (前端 SSR) │────▶│  (API +      │────▶│  Workers     │
# │             │     │   Agent 工人) │     │  (认证/路由)  │
# └─────────────┘     └──────┬───────┘     └──────────────┘
#                            │
#                     ┌──────▼───────┐
#                     │  Supabase    │
#                     │  (Postgres + │
#                     │   Auth)      │
#                     └──────────────┘

替代方案速查

关键链接