边缘计算Skill edge-computing

本技能提供边缘计算架构设计的全面指南,涵盖边缘函数、计算放置决策、云边缘服务如Cloudflare Workers和Lambda@Edge,以及边缘原生模式。适用于低延迟应用、全球分布式系统和服务器less计算,优化性能并减少延迟。关键词:边缘计算、服务器less、低延迟、分布式计算、Cloudflare Workers、Lambda@Edge。

Serverless 0 次安装 0 次浏览 更新于 3/11/2026

name: edge-computing description: 用于设计边缘计算架构、边缘服务器less或分布式计算策略时使用。涵盖边缘函数、计算放置决策、Cloudflare Workers、Lambda@Edge和边缘原生模式。 allowed-tools: Read, Glob, Grep

边缘计算

边缘计算架构的全面指南 - 运行计算更靠近用户以降低延迟并提升性能。

何时使用此技能

  • 设计边缘函数架构
  • 决定计算放置位置(边缘 vs 源站)
  • 实现边缘服务器less
  • 理解边缘平台能力
  • 优化对延迟敏感的应用
  • 构建全球分布式应用

边缘计算基础

什么是边缘计算?

计算放置频谱:

┌─────────────────────────────────────────────────────────────┐
│                                                             │
│  用户设备    边缘      区域      中心      源站         │
│  (客户端)    (CDN)    (云)      (云)      (云)         │
│                                                             │
│     ◄──────────────────────────────────────────────────►   │
│                                                             │
│  最低         ┌─────────────────────────────┐  最高       │
│  延迟         │      边缘计算               │  延迟       │
│               │  (本技能的重点)             │            │
│               └─────────────────────────────┘            │
│                                                             │
│  有限         ◄─────────────────────────────►  完全       │
│  资源                                          资源        │
│                                                             │
└─────────────────────────────────────────────────────────────┘

边缘 = 在CDN/网络边缘服务器上运行代码(100多个位置)
vs 区域 = 在少数云区域运行(10-20个位置)
vs 源站 = 在一个主要位置运行(1-3个位置)

边缘 vs 服务器less vs 传统

对比:

                    边缘函数       云函数       容器/虚拟机
────────────────────────────────────────────────────────────────────────
位置            100-300+         10-20         1-10
冷启动          <50毫秒          100毫秒-秒    N/A (始终热)
执行限制        10-30秒          15分钟        无限
内存            128MB-1GB        256MB-10GB    无限
CPU             有限             标准          完全控制
状态             无状态           无状态         有状态可
成本模型         按请求           按请求         按实例
最适合          低延迟、         通用计算       复杂应用、
                简单逻辑                        长时间运行

按类型用例:
边缘:认证、路由、个性化、A/B测试、重定向
云函数:API、webhooks、后台处理
容器:完整应用、数据库、ML推理

边缘平台架构

边缘平台组件:

┌─────────────────────────────────────────────────────────────┐
│                    控制平面                                  │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐   │
│  │ 部署     │  │ 配置     │  │ 密钥     │  │ 指标     │   │
│  │ API      │  │ 存储     │  │ 管理     │  │ 和日志   │   │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘   │
└───────┼─────────────┼─────────────┼─────────────┼──────────┘
        │             │             │             │
        └─────────────┼─────────────┼─────────────┘
                      │             │
        ╔═════════════╧═════════════╧═════════════╗
        ║           全局分布                      ║
        ╚═════════════════════════════════════════╝
                      │
    ┌─────────────────┼─────────────────┐
    │                 │                 │
┌───▼───┐        ┌───▼───┐        ┌───▼───┐
│ 边缘  │        │ 边缘  │        │ 边缘  │
│ POP 1 │        │ POP 2 │        │ POP N │
│┌─────┐│        │┌─────┐│        │┌─────┐│
││ V8  ││        ││ V8  ││        ││ V8  ││
││隔离 ││        ││隔离 ││        ││隔离 ││
│└─────┘│        │└─────┘│        │└─────┘│
└───────┘        └───────┘        └───────┘

执行模型:
- V8 隔离:轻量级隔离(非容器)
- 即时冷启动(低于50毫秒)
- 按请求执行
- 每个POP自动扩展

边缘函数模式

请求拦截

请求/响应生命周期:

用户请求 ──► 边缘函数 ──► 源站(可选)
                      │
              ┌───────┴───────┐
              │               │
         修改请求       短路
         (继续到       (从边缘返回
          源站)         响应)

用例:

1. URL重写
   /旧页面 → /新页面
   /api/v1/* → /api/v2/*

2. 头部操作
   添加安全头部
   添加请求ID
   标准化Accept-Language

3. 认证
   在边缘验证JWT
   检查API密钥
   重定向到登录

4. A/B测试
   分配群组
   重写到变体URL

5. 机器人保护
   挑战机器人
   阻止已知恶意行为者

6. 地理位置路由
   路由到区域源站
   应用区域规则

响应转换

响应转换模式:

1. HTML注入
   ┌─────────────────────────────────────────┐
   │ 注入分析、A/B测试脚本                 │
   │ 添加个性化内容                         │
   │ 按区域插入GDPR横幅                     │
   └─────────────────────────────────────────┘

2. 内容优化
   ┌─────────────────────────────────────────┐
   │ 压缩响应                               │
   │ 图像优化/调整大小                      │
   │ 最小化                                 │
   └─────────────────────────────────────────┘

3. 响应缓存
   ┌─────────────────────────────────────────┐
   │ 在边缘缓存API响应                      │
   │ 从缓存片段组装                         │
   │ 重新验证时提供陈旧响应                 │
   └─────────────────────────────────────────┘

4. 错误处理
   ┌─────────────────────────────────────────┐
   │ 源站错误时的备用页面                   │
   │ 按区域自定义错误页面                   │
   │ 带退避的重试逻辑                       │
   └─────────────────────────────────────────┘

边缘存储模式

边缘存储选项:

1. 键值存储 (KV)
   ├── 读密集型工作负载
   ├── 最终一致性
   ├── 低延迟读取
   └── 有限写入吞吐量

   用例:功能标志、配置、用户会话

2. 持久对象 (Cloudflare)
   ├── 强一致性
   ├── 有状态边缘计算
   ├── 每个ID单实例
   └── WebSocket支持

   用例:实时协作、聊天、游戏状态

3. 边缘数据库
   ├── 分布式SQL (PlanetScale, Turso)
   ├── 边缘读取副本
   ├── 低延迟读取
   └── 写入主区域

   用例:用户数据、产品目录、CMS

4. R2/S3兼容存储
   ├── 边缘对象存储
   ├── 无出口费用(部分提供商)
   └── 大文件存储

   用例:静态资产、用户上传、备份

计算放置决策

决策框架

应在哪里运行?

问题1:延迟要求
├── 需要<50毫秒? → 边缘
├── 可接受<200毫秒? → 区域云
└── 延迟不关键? → 中心源站

问题2:计算复杂性
├── 简单转换? → 边缘
├── 中等逻辑? → 边缘或区域
└── 复杂处理? → 区域或中心

问题3:数据依赖
├── 无需数据? → 边缘
├── 读密集型、可缓存? → 带缓存的边缘
├── 需要强一致性? → 区域
└── 写密集型? → 中心

问题4:状态要求
├── 无状态? → 边缘
├── 会话状态? → 带KV/持久对象的边缘
└── 复杂状态? → 区域或中心

问题5:成本敏感性
├── 高请求量、简单? → 边缘(高效)
├── CPU密集型? → 区域(更便宜)
└── 长时间运行? → 中心

混合架构

混合边缘 + 源站架构:

┌─────────────────────────────────────────────────────────────┐
│                        边缘层                                │
│  ┌─────────────────────────────────────────────────────┐    │
│  │  • 认证/授权                                         │    │
│  │  • 速率限制                                          │    │
│  │  • 请求路由                                          │    │
│  │  • 静态内容                                          │    │
│  │  • 简单个性化                                        │    │
│  │  • 缓存逻辑                                          │    │
│  └─────────────────────────────────────────────────────┘    │
└────────────────────────────┬────────────────────────────────┘
                             │
                  仅复杂请求通过
                             │
┌────────────────────────────▼────────────────────────────────┐
│                       源站层                                │
│  ┌─────────────────────────────────────────────────────┐    │
│  │  • 业务逻辑                                          │    │
│  │  • 数据库操作                                        │
│  │  • 第三方集成                                        │
│  │  • ML推理                                            │
│  │  • 复杂计算                                          │
│  └─────────────────────────────────────────────────────┘    │
└─────────────────────────────────────────────────────────────┘

优势:
- 减轻源站工作负载
- 简单请求的更快响应
- 源站受保护免受攻击流量
- 独立扩展每层

边缘平台

Cloudflare Workers

Cloudflare Workers:

执行:
- V8 隔离(非容器)
- <5毫秒冷启动
- 200+边缘位置
- 10毫秒CPU时间(免费)/ 30秒(付费)

特性:
├── Workers KV(键值存储)
├── 持久对象(有状态)
├── R2(对象存储)
├── D1(边缘SQLite)
├── 队列(异步处理)
└── Hyperdrive(数据库连接池)

示例:
export default {
  async fetch(request, env, ctx) {
    const url = new URL(request.url);

    // 简单路由
    if (url.pathname.startsWith('/api/')) {
      return handleAPI(request, env);
    }

    // 提供静态内容
    return env.ASSETS.fetch(request);
  }
}

AWS Lambda@Edge / CloudFront Functions

AWS 边缘选项:

CloudFront Functions:
├── 仅JavaScript
├── 亚毫秒启动
├── 2MB内存
├── 仅请求/响应操作
├── 不能进行网络调用
└── 规模化时非常便宜

Lambda@Edge:
├── Node.js, Python
├── 128-3008MB内存
├── 最多30秒执行(源站响应)
├── 可以进行网络调用
├── 访问AWS服务
└── 比CF Functions延迟高

用例映射:
CloudFront Functions:头部、重定向、URL重写
Lambda@Edge:认证、A/B测试、动态响应
Lambda(区域):完整API逻辑、数据库访问

Fastly Compute@Edge

Fastly Compute@Edge:

执行:
- WebAssembly基于(Wasm)
- 多语言(Rust, JS, Go等)
- 无冷启动(预编译)
- 50毫秒-120秒执行时间

特性:
├── 地理位置数据
├── 设备检测
├── 实时日志记录
├── 边缘字典
└── 源站获取与缓存

优势:
- 最适合动态内容
- 实时清除
- 高级缓存控制
- 强VCL迁移路径

示例(Rust):
use fastly::{Request, Response};

#[fastly::main]
fn main(req: Request) -> Result<Response, Error> {
    match req.get_path() {
        "/api" => handle_api(req),
        _ => Ok(req.send("origin")?)
    }
}

最佳实践

边缘计算最佳实践:

1. 保持简单
   □ 边缘 = 简单、快速操作
   □ 复杂逻辑 → 源站
   □ 最小化依赖
   □ 快速优雅失败

2. 优化冷启动
   □ 最小化代码大小
   □ 可能时惰性加载
   □ 使用全局范围初始化
   □ 避免重依赖

3. 处理故障
   □ 源站不可用处理
   □ 超时处理
   □ 备用响应
   □ 错误跟踪

4. 监控一切
   □ 延迟百分位数
   □ 错误率
   □ 冷启动频率
   □ 源站穿透率

5. 安全
   □ 在边缘验证输入
   □ 早期速率限制
   □ 净化数据
   □ 使用密钥管理

6. 成本优化
   □ 积极缓存
   □ 合理调整执行时间
   □ 使用适当层级
   □ 监控使用模式

反模式

边缘计算反模式:

1. "一切都放边缘"
   ❌ 将所有逻辑移到边缘
   ✓ 基于要求战略放置

2. "边缘数据库"
   ❌ 在边缘进行复杂数据库操作
   ✓ 边缘读取副本或缓存数据

3. "忽略冷启动"
   ❌ 大包、重初始化
   ✓ 优化包大小、惰性加载

4. "源站耦合"
   ❌ 边缘函数与源站紧密耦合
   ✓ 边缘函数尽可能独立工作

5. "无备用方案"
   ❌ 边缘函数失败 = 用户看到错误
   ✓ 优雅降级、缓存响应

6. "同步一切"
   ❌ 在边缘等待慢操作
   ✓ 异步处理、发射即忘日志

相关技能

  • cdn-architecture - CDN和缓存模式
  • serverless-patterns - 服务器less架构
  • latency-optimization - 端到端延迟减少
  • multi-region-deployment - 全球基础设施