Cloudflare Workers: 边缘计算平台¶

                     ┌─────────────────────────┐
                     │    Cloudflare Workers    │
                     │   (V8 Isolate 运行时)    │
                     └───────┬─────────────────┘
            ┌────────────────┼────────────────────┐
            │                │                    │
    ┌───────▼───────┐ ┌──────▼──────┐ ┌──────────▼─────────┐
    │   KV Storage  │ │     R2      │ │       D1           │
    │   键值存储     │ │  对象存储   │ │   SQLite 数据库     │
    └───────────────┘ └─────────────┘ └────────────────────┘
            │                │                    │
    ┌───────▼───────┐ ┌──────▼──────┐ ┌──────────▼─────────┐
    │ Durable Obj.  │ │  AI Gateway │ │    Queues          │
    │ 有状态对象     │ │  AI 网关    │ │    消息队列         │
    └───────────────┘ └─────────────┘ └────────────────────┘

# 使用 npm
npm install -g wrangler

# 使用 pnpm
pnpm add -g wrangler

# 验证
wrangler --version

wrangler login
# 浏览器打开授权页面，点击允许

# 交互式创建
wrangler init my-worker
# 选择 TypeScript + "Hello World" 模板

# 或者使用模板
npm create cloudflare@latest my-worker

my-worker/
├── src/
│   └── index.ts          # Worker 入口
├── wrangler.toml         # Wrangler 配置
├── package.json
└── tsconfig.json

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

# 环境变量
[vars]
API_VERSION = "v1"
ENVIRONMENT = "production"

# 密钥（通过 wrangler secret 设置）
# wrangler secret put API_KEY

# KV 命名空间绑定
[[kv_namespaces]]
binding = "MY_KV"
id = "xxx"

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

# D1 数据库绑定
[[d1_databases]]
binding = "DB"
database_name = "my-database"
database_id = "xxx"

# 自定义域名路由
[routes]
pattern = "api.example.com/*"
zone_name = "example.com"

// src/index.ts
export default {
  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
    return new Response('Hello World!');
  },
};

# 本地开发
wrangler dev

# 部署
wrangler deploy

// src/index.ts
export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const url = new URL(request.url);

    switch (url.pathname) {
      case '/':
        return new Response('Home');

      case '/api/hello':
        return Response.json({ message: 'Hello!' });

      case '/api/users':
        if (request.method === 'GET') {
          return handleGetUsers(env);
        } else if (request.method === 'POST') {
          return handleCreateUser(request, env);
        }
        return new Response('Method not allowed', { status: 405 });

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

async function handleGetUsers(env: Env): Promise<Response> {
  // 从 KV 获取数据
  const users = await env.MY_KV.get('users', 'json');
  return Response.json(users || []);
}

async function handleCreateUser(request: Request, env: Env): Promise<Response> {
  const body = await request.json();
  // 存储到 KV
  await env.MY_KV.put('users', JSON.stringify(body));
  return Response.json(body, { status: 201 });
}

npm install hono

// src/index.ts
import { Hono } from 'hono';
import { cors } from 'hono/cors';

type Bindings = {
  MY_KV: KVNamespace;
  DB: D1Database;
  API_KEY: string;
};

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

app.use('*', cors());

app.get('/', (c) => c.text('Hello Hono!'));

app.get('/api/users', async (c) => {
  const { results } = await c.env.DB.prepare(
    'SELECT * FROM users LIMIT 100'
  ).all();
  return c.json(results);
});

app.post('/api/users', async (c) => {
  const { name, email } = await c.req.json();
  await c.env.DB.prepare(
    'INSERT INTO users (name, email) VALUES (?, ?)'
  ).bind(name, email).run();
  return c.json({ success: true }, 201);
});

export default app;

// 写入
await env.MY_KV.put('key', 'value');
await env.MY_KV.put('user:123', JSON.stringify({ name: 'Alice' }));
await env.MY_KV.put('session:abc', 'data', { expirationTtl: 3600 }); // 1小时过期

// 读取
const value = await env.MY_KV.get('key');
const user = await env.MY_KV.get('user:123', 'json');

// 列出键
const keys = await env.MY_KV.list({ prefix: 'user:' });

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

# 创建数据库
wrangler d1 create my-database

# 创建表（通过迁移）
wrangler d1 execute my-database --command "CREATE TABLE users (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, email TEXT UNIQUE, created_at DATETIME DEFAULT CURRENT_TIMESTAMP)"

// 查询
const { results } = await env.DB.prepare(
  'SELECT * FROM users WHERE email = ?'
).bind(email).all();

// 插入
const info = await env.DB.prepare(
  'INSERT INTO users (name, email) VALUES (?, ?)'
).bind(name, email).run();

// 批量操作
const batch = await env.DB.batch([
  env.DB.prepare('INSERT INTO users (name) VALUES (?)').bind('Alice'),
  env.DB.prepare('INSERT INTO users (name) VALUES (?)').bind('Bob'),
]);

// 上传文件
app.post('/upload', async (c) => {
  const formData = await c.req.formData();
  const file = formData.get('file') as File;

  await c.env.MY_BUCKET.put(file.name, file.stream(), {
    httpMetadata: { contentType: file.type },
  });

  return c.json({ key: file.name });
});

// 下载文件
app.get('/files/:key', async (c) => {
  const object = await c.env.MY_BUCKET.get(c.req.param('key'));
  if (!object) return c.text('Not Found', 404);

  return new Response(object.body, {
    headers: { 'Content-Type': object.httpMetadata?.contentType || '' },
  });
});

// 列出文件
app.get('/files', async (c) => {
  const objects = await c.env.MY_BUCKET.list();
  return c.json(objects.objects.map(o => ({ key: o.key, size: o.size })));
});

// 通过 Workers AI 调用模型
app.post('/ai/chat', async (c) => {
  const { message } = await c.req.json();

  const response = await c.env.AI.run('@cf/meta/llama-3-8b-instruct', {
    messages: [{ role: 'user', content: message }],
  });

  return c.json(response);
});

// 或代理到外部 AI API（通过 AI Gateway 获得缓存和监控）
app.post('/ai/proxy', async (c) => {
  const response = await fetch(
    'https://gateway.ai.cloudflare.com/v1/ACCOUNT_ID/GATEWAY_NAME/openai/chat/completions',
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${c.env.OPENAI_API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(await c.req.json()),
    }
  );

  return new Response(response.body, response);
});

# wrangler.toml
[triggers]
crons = ["0 * * * *"]  # 每小时运行

export default {
  async scheduled(event: ScheduledEvent, env: Env, ctx: ExecutionContext) {
    // 定时任务逻辑
    console.log(`Cron trigger: ${event.cron}`);

    // 清理过期数据、发送报告等
    const keys = await env.MY_KV.list({ prefix: 'temp:' });
    for (const key of keys.keys) {
      await env.MY_KV.delete(key.name);
    }
  },

  async fetch(request: Request, env: Env): Promise<Response> {
    return new Response('OK');
  },
};

# wrangler dev 支持本地开发
wrangler dev --local

# 支持断点调试
wrangler dev --inspect

# 打开 chrome://inspect 进行调试

const corsHeaders = {
  'Access-Control-Allow-Origin': '*',
  'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE',
  'Access-Control-Allow-Headers': 'Content-Type',
};