⚡ Cloudflare Workers

Cloudflare Workers 是一个无服务器平台，允许你在 Cloudflare 全球网络的边缘节点运行 JavaScript/TypeScript/Python 代码，无需管理基础设施。

产品简介

Workers 在距离用户最近的数据中心执行代码，提供超低延迟响应。支持多种编程语言和框架，适合构建 API、全栈应用、中间件等。

⚡ 极速响应

在全球 330+ 城市边缘节点运行

🌍 全球分布

代码自动部署到所有边缘节点

💰 经济实惠

按请求计费，免费计划每天 100,000 请求

🔧 多语言支持

JavaScript、TypeScript、Python、Rust 等

核心优势

  • 0ms 冷启动：不像传统 Serverless，Workers 几乎无冷启动延迟
  • 自动扩展：自动处理流量峰值，无需配置
  • 丰富生态：与 D1、R2、KV 等服务无缝集成
  • 标准 Web API：使用熟悉的 Fetch、Request、Response 等 API

快速开始

1. 创建第一个 Worker

# 使用 C3 创建新项目
npm create cloudflare@latest my-worker

# 选择 "Hello World" Worker 模板
# 然后进入项目目录
cd my-worker

2. Worker 代码示例

src/index.js
// src/index.js
export default {
  async fetch(request, env, ctx) {
    return new Response('Hello from Cloudflare Workers!', {
      headers: {
        'Content-Type': 'text/plain',
      },
    });
  },
};

3. 本地开发

npm run dev

访问 http://localhost:8787 查看效果

4. 部署到生产

npm run deploy

实用示例

示例 1：JSON API

JSON API 响应
export default {
  async fetch(request) {
    const data = {
      message: 'Hello from API',
      timestamp: new Date().toISOString(),
      location: request.cf?.city || 'Unknown',
      country: request.cf?.country || 'Unknown',
    };

    return Response.json(data);
  },
};

示例 2：路由处理

路由处理
export default {
  async fetch(request) {
    const url = new URL(request.url);

    // 路由匹配
    if (url.pathname === '/') {
      return new Response('Home Page');
    }

    if (url.pathname === '/api/status') {
      return Response.json({ status: 'OK' });
    }

    if (url.pathname.startsWith('/api/users/')) {
      const userId = url.pathname.split('/')[3];
      return Response.json({ userId, name: `User ${userId}` });
    }

    // 404
    return new Response('Not Found', { status: 404 });
  },
};

示例 3：请求代理和修改

请求代理
export default {
  async fetch(request) {
    // 修改请求头
    const modifiedRequest = new Request(request, {
      headers: {
        ...Object.fromEntries(request.headers),
        'X-Custom-Header': 'Added by Worker',
      },
    });

    // 转发请求到后端
    const response = await fetch('https://api.example.com', modifiedRequest);

    // 修改响应
    const modifiedResponse = new Response(response.body, response);
    modifiedResponse.headers.set('X-Powered-By', 'Cloudflare Workers');

    return modifiedResponse;
  },
};

示例 4：CORS 处理

CORS 处理
function handleCORS(request) {
  const corsHeaders = {
    'Access-Control-Allow-Origin': '*',
    'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
    'Access-Control-Allow-Headers': 'Content-Type',
  };

  if (request.method === 'OPTIONS') {
    return new Response(null, { headers: corsHeaders });
  }

  return corsHeaders;
}

export default {
  async fetch(request) {
    const corsHeaders = handleCORS(request);

    if (request.method === 'OPTIONS') {
      return corsHeaders;
    }

    const response = Response.json({ message: 'Success' });

    // 添加 CORS 头
    Object.entries(corsHeaders).forEach(([key, value]) => {
      response.headers.set(key, value);
    });

    return response;
  },
};

与其他服务集成

连接 KV 存储

KV 存储操作
export default {
  async fetch(request, env) {
    // 读取
    const value = await env.MY_KV.get('key');

    // 写入
    await env.MY_KV.put('key', 'value', {
      expirationTtl: 60, // 60秒后过期
    });

    // 删除
    await env.MY_KV.delete('key');

    return Response.json({ value });
  },
};

连接 D1 数据库

D1 数据库操作
export default {
  async fetch(request, env) {
    // 查询数据
    const { results } = await env.DB.prepare(
      'SELECT * FROM users WHERE id = ?'
    ).bind(1).all();

    // 插入数据
    await env.DB.prepare(
      'INSERT INTO users (name, email) VALUES (?, ?)'
    ).bind('John', 'john@example.com').run();

    return Response.json(results);
  },
};

连接 R2 对象存储

R2 对象存储操作
export default {
  async fetch(request, env) {
    // 上传文件
    await env.BUCKET.put('file.txt', 'Hello, R2!');

    // 读取文件
    const object = await env.BUCKET.get('file.txt');
    const text = await object.text();

    // 删除文件
    await env.BUCKET.delete('file.txt');

    return new Response(text);
  },
};

Wrangler 配置

wrangler.toml
name = "my-worker"
main = "src/index.js"
compatibility_date = "2024-01-01"

# KV 绑定
[[kv_namespaces]]
binding = "MY_KV"
id = "your-kv-namespace-id"

# D1 绑定
[[d1_databases]]
binding = "DB"
database_name = "my-database"
database_id = "your-database-id"

# R2 绑定
[[r2_buckets]]
binding = "BUCKET"
bucket_name = "my-bucket"

# 环境变量
[vars]
API_KEY = "your-api-key"
ENVIRONMENT = "production"

# 路由配置
[triggers]
crons = ["0 0 * * *"]  # 每天午夜运行

# 兼容性标志
[compatibility_flags]
nodejs_compat = true

常用 CLI 命令

Wrangler Workers 命令
# 创建新 Worker
npm create cloudflare@latest

# 本地开发（热重载）
wrangler dev

# 本地开发（指定端口）
wrangler dev --port 3000

# 部署到生产环境
wrangler deploy

# 部署到特定环境
wrangler deploy --env production

# 查看日志（实时）
wrangler tail

# 查看日志（指定 Worker）
wrangler tail my-worker

# 查看所有 Workers
wrangler deployments list

# 删除 Worker
wrangler delete my-worker

# 运行 Worker 秘密管理
wrangler secret put SECRET_KEY

# 查看所有秘密
wrangler secret list

# 发布特定版本
wrangler versions deploy --version-id {version-id}

高级特性

1. Cron 触发器（定时任务）

export default {
  async scheduled(event, env, ctx) {
    // 每天执行的任务
    console.log('Cron job executed at:', new Date().toISOString());

    // 清理过期数据
    await env.DB.prepare('DELETE FROM sessions WHERE expires < ?')
      .bind(Date.now())
      .run();
  },
};

2. Durable Objects（有状态对象）

Durable Objects
// 计数器 Durable Object
export class Counter {
  constructor(state, env) {
    this.state = state;
  }

  async fetch(request) {
    let count = (await this.state.storage.get('count')) || 0;
    count++;
    await this.state.storage.put('count', count);

    return Response.json({ count });
  }
}

export default {
  async fetch(request, env) {
    const id = env.COUNTER.idFromName('global');
    const obj = env.COUNTER.get(id);
    return obj.fetch(request);
  },
};

3. WebSocket 支持

WebSocket 示例
export default {
  async fetch(request) {
    const upgradeHeader = request.headers.get('Upgrade');

    if (upgradeHeader !== 'websocket') {
      return new Response('Expected WebSocket', { status: 400 });
    }

    const [client, server] = Object.values(new WebSocketPair());

    server.accept();

    server.addEventListener('message', (event) => {
      server.send(`Echo: ${event.data}`);
    });

    return new Response(null, {
      status: 101,
      webSocket: client,
    });
  },
};

性能优化建议

  • 缓存策略：使用 Cache API 缓存响应，减少源服务器请求
  • 并行请求：使用 Promise.all() 并行处理多个请求
  • 流式响应：对于大响应，使用 Stream API 提高性能
  • 最小化依赖：减少第三方库，降低启动时间

限制与定价

项目 免费计划 付费计划（$5/月）
请求数 100,000 次/天 10M 请求包含，超出 $0.50/M
CPU 时间 10ms/请求 50ms/请求
内存 128MB 128MB
脚本大小 1MB 压缩后 10MB 压缩后

相关资源