签到奶昔访达
返回列表 发布新帖

【阿里云CDT】每月4元享受200G高速流量 - 完整教程(含Cloudflare Workers保活)

8394 6
发表于 2026-10-9 17:32:14 | 查看全部 阅读模式

注册奶昔,结交更多奶友,可做任务快速升级,解锁更多权益。

您需要 登录 才可以下载或查看,没有账号?注册

×
前言
本文是在 https://bbs.biliup.rs/t/topic/46 这篇原始教程的基础上,结合个人实际部署经验总结优化而成。原始教程的镜像部署方式比较繁琐且分区不合理(最后可用分区不到200M),本文已替换为更优方案。如有不理解之处,建议参考原始教程原文。

核心要点速览
镜像:使用 alpine-cloud-build 项目的 alpine-custom.qcow2(99.3MB),系统盘最小1G,可用分区充裕
登录用户:alpine,禁止 root 直接 SSH;登录后
  1. sudo -i
复制代码

切 root
密钥对:创建实例时必须绑定密钥对,不绑定无法 SSH 登录;私钥丢失只能重建实例
启动模式:导入镜像时必须选 UEFI,不要选 BIOS (SeaBIOS),否则启动失败
实例规格:购买时搜 ecs.e-c4m1.large,最便宜的规格
流量说明:国外服务器 200G / 国内服务器 20G
保活方式:使用免费的 Cloudflare Workers 定时执行,不需要另外开服务器

一、开通阿里云 OSS 并上传 Alpine 镜像
1. 开通 OSS 服务
登录阿里云控制台,在搜索栏搜索 “OSS“ 并开通对象存储服务。
2. 创建 Bucket
进入 OSS 管理控制台,点击创建 Bucket,地域切记选择“中国香港“。
3. 下载 Alpine 镜像
本教程使用 alpine-cloud-build 项目提供的预构建镜像,无需手动安装系统:
- 镜像文件:alpine-custom.qcow2
- 文件大小:99.3MB
- 下载地址:前往该项目 Releases 页面 下载最新版
4. 上传镜像到 OSS
进入刚才创建的 Bucket,点击“上传文件“,上传下载好的 alpine-custom.qcow2 镜像文件。上传完成后,保存好镜像的 OSS 链接,下一步导入镜像时需要用到。

二、导入自定义镜像
1. 进入镜像导入页面
访问 阿里云镜像导入页面(香港地域)。
2. 配置导入参数
- 镜像来源:选择“OSS文件“
- 镜像格式:选择 qcow2
- 启动模式:务必选择 UEFI(不要选 BIOS/SeaBIOS,否则实例启动失败!)
- Paste 镜像地址:填入上一步保存的 OSS 镜像链接
3. 等待导入完成
点击下一步,耐心等待镜像导入完成(通常需要几分钟)。导入完成后即可在镜像列表中看到新镜像。
注意: 此处不需要上传官方 Alpine ISO,直接使用 alpine-cloud-build 项目的 qcow2 镜像即可,省去手动安装系统的繁琐步骤。

三、创建抢占式 ECS 实例
1. 进入实例创建页面
前往 阿里云 ECS 控制台,点击“创建实例“。
2. 配置实例参数
- 地域:选择 “中国香港“
- 镜像:选择上一步导入的自定义镜像
- 实例规格:在搜索框输入 ecs.e-c4m1.large,选择最便宜的规格
- 系统盘:选择 1G(该镜像非常轻量,1G 完全够用)
- 网络:暂不分配公网 IP(后面单独创建)
- SSH 密钥对:必须在此处绑定密钥对! 如果没有密钥对,请先创建一对并下载保存私钥文件。不绑定密钥对则无法通过 SSH 登录,实例将无法正常管理!
3. 确认下单
确认所有配置无误后,点击“创建“。实例状态变为“运行中“即可进入下一步。
重要提醒: 创建实例时如果没有绑定密钥对,后续将无法 SSH 登录。如忘记绑定,只能重建实例重新绑定。

四、创建弹性公网 IP
1. 创建 EIP
在 ECS 控制台左侧菜单找到“弹性公网 IP“,点击创建。
2. 确认配置并购买
选择按使用流量计费,确认配置后点击购买。
3. 绑定实例
创建完成后,将 EIP 绑定到刚才创建的 ECS 实例上。绑定地址:ECS实例管理页面。
4. 创建共享带宽
返回弹性公网 IP 列表,找到刚创建的 EIP,点击“加入共享带宽“。
重要提醒: 选择带宽大小时,不要选 1000M 及以上,会触发风控提示并阻止下单。建议选择 999M 或更小的值即可正常下单。
加入共享带宽后,服务器就拥有 999M 带宽了。

五、登录服务器
本教程使用的 alpine-cloud-build 项目镜像已预配置好所有基础环境,无需像原始教程那样通过 VNC 手动安装系统。镜像已内置以下配置:
- cloud-init(支持云端初始化)
- growpart / resize_rootfs(首启自动扩容到系统盘大小)
- 预装常用基础组件:cloud-init、chrony、sudo 等
- SSH 安全配置:禁用密码登录,仅密钥登录
- 默认软件源已切换为阿里云镜像源
1. SSH 登录
使用绑定密钥对时下载的私钥文件登录:
  1. ssh -i <你的私钥文件路径> alpine@<ECS公网IP>
复制代码

2. 切换到 root 权限
  1. sudo -i
复制代码

切换。

五、创建阿里云RAM用户并获取AccessKey
注意:RAM 是阿里云的全局服务,不需要切换地域,直接在首页搜索即可操作。
1. 登录阿里云控制台,搜索 RAM 访问控制,进入 RAM 控制台。
2. 点击左侧“用户“ -> “创建用户“,创建一个新的 RAM 用户,勾选“OpenAPI 调用访问“。
3. 系统会自动生成 AccessKey ID 和 AccessKey Secret,务必立即保存这两项,关闭页面后将无法再次查看 Secret。
4. 为刚创建的 RAM 用户添加权限策略:
方式一(推荐,最小权限原则): 只授予 ECS 和 CDT 相关权限
选择“自定义策略“,点击“创建权限策略“,粘贴以下 JSON:
  1. {
  2.     "Version": "1",
  3.     "Statement": [
  4.         {
  5.             "Effect": "Allow",
  6.             "Action": [
  7.                 "ecs:StartInstances",
  8.                 "ecs:StopInstances",
  9.                 "ecs:DescribeInstances"
  10.             ],
  11.             "Resource": "*"
  12.         },
  13.         {
  14.             "Effect": "Allow",
  15.             "Action": "cdt:ListCdtInternetTraffic",
  16.             "Resource": "*"
  17.         }
  18.     ]
  19. }
复制代码

方式二(快速授权): 直接搜索ECS并勾选 AliyunECSFullAccess 和搜索CDT并勾选 AliyunCDTFullAccess 权限策略。

六、部署 Cloudflare Workers 保活脚本
说明: 原始教程使用另一台服务器运行 Python 脚本 + crontab 来保活,需要额外付费。本教程使用免费的 Cloudflare Workers 来执行定时保活任务,无需额外服务器,零成本。
1. 创建 Cloudflare Worker
- 登录 Cloudflare Dashboard
- 进入 Workers & Pages → 创建 Worker
- 给 Worker 起个名字(如 ecs-keepalive)
2. 粘贴 Worker 脚本
将以下代码粘贴到 Worker 的编辑器中,覆盖默认代码:
  1. // ============================================================
  2. // Aliyun ECS Keep-Alive - Pure Cloudflare Worker (Production-Ready)
  3. // 功能:根据 CDT 流量阈值自动启停 ECS 实例
  4. // 特性:参数校验、指数退避重试、状态轮询超时保护、结构化日志
  5. // 部署:粘贴到 CF Worker 编辑器,配置 Cron 触发器即可
  6. // ============================================================

  7. export default {
  8.   async fetch(request, env, ctx) {
  9.     if (request.method === 'GET' || request.method === 'POST') {
  10.       return handleKeepAlive(env);
  11.     }
  12.     return new Response('Method not allowed', { status: 405 });
  13.   },
  14.   async scheduled(event, env, ctx) {
  15.     // Cron 定时触发
  16.     ctx.waitUntil(handleKeepAlive(env));
  17.   }
  18. };

  19. // ==================== 配置(可在 env 中覆盖)====================
  20. const DEFAULTS = {
  21.   REGION_ID: 'cn-hongkong',
  22.   TRAFFIC_THRESHOLD_GB: 180,
  23.   STOPPED_MODE: 'StopCharging',
  24. };

  25. // ==================== STOPPED_MODE 别名映射 ====================
  26. const STOPPED_MODE_MAP = {
  27.   // 中文
  28.   '节省停机': 'StopCharging',
  29.   '节省': 'StopCharging',
  30.   '普通停机': 'KeepCharging',
  31.   '普通': 'KeepCharging',
  32.   // 英文
  33.   'economy': 'StopCharging',
  34.   'saving': 'StopCharging',
  35.   'normal': 'KeepCharging',
  36.   'standard': 'KeepCharging',
  37.   // 原值(小写)
  38.   'stopcharging': 'StopCharging',
  39.   'keepcharging': 'KeepCharging',
  40. };

  41. function resolveStoppedMode(raw) {
  42.   const key = String(raw).trim().toLowerCase();
  43.   return STOPPED_MODE_MAP[key] || raw;
  44. }

  45. // ==================== 结构化日志 ====================
  46. class Logger {
  47.   constructor() {
  48.     this.entries = [];
  49.   }

  50.   _log(level, message, data = null) {
  51.     const entry = {
  52.       timestamp: new Date().toISOString(),
  53.       level,
  54.       message,
  55.     };
  56.     if (data !== null) entry.data = data;
  57.     this.entries.push(entry);
  58.     // 同时输出到 console(CF Workers 日志可查看)
  59.     if (level === 'ERROR') {
  60.       console.error(JSON.stringify(entry));
  61.     } else if (level === 'WARNING') {
  62.       console.warn(JSON.stringify(entry));
  63.     } else {
  64.       console.log(JSON.stringify(entry));
  65.     }
  66.   }

  67.   info(message, data) { this._log('INFO', message, data); }
  68.   warning(message, data) { this._log('WARNING', message, data); }
  69.   error(message, data) { this._log('ERROR', message, data); }

  70.   toResponse(status = 200) {
  71.     const lines = this.entries.map(e => {
  72.       const prefix = e.level === 'ERROR' ? '[ERROR]' : e.level === 'WARNING' ? '[WARN]' : '[INFO]';
  73.       const dataStr = e.data ? ' | ' + JSON.stringify(e.data) : '';
  74.       return `[${e.timestamp}] ${prefix} ${e.message}${dataStr}`;
  75.     });
  76.     return new Response(lines.join('\n'), {
  77.       status,
  78.       headers: { 'Content-Type': 'text/plain; charset=utf-8' },
  79.     });
  80.   }
  81. }

  82. // ==================== 参数校验 ====================
  83. function validateParams(env) {
  84.   const errors = [];
  85.   const warnings = [];

  86.   // 必填项检查
  87.   const ACCESS_KEY_ID = env.ACCESS_KEY_ID;
  88.   const ACCESS_KEY_SECRET = env.ACCESS_KEY_SECRET;
  89.   const ECS_INSTANCE_ID = env.ECS_INSTANCE_ID;

  90.   if (!ACCESS_KEY_ID) errors.push('ACCESS_KEY_ID 未配置');
  91.   if (!ACCESS_KEY_SECRET) errors.push('ACCESS_KEY_SECRET 未配置');
  92.   if (!ECS_INSTANCE_ID) errors.push('ECS_INSTANCE_ID 未配置');

  93.   // ECS_INSTANCE_ID 格式校验(i- 开头)
  94.   if (ECS_INSTANCE_ID && !/^i-[a-z0-9]{10,30}$/.test(ECS_INSTANCE_ID)) {
  95.     warnings.push(`ECS_INSTANCE_ID 格式可能不正确: "${ECS_INSTANCE_ID}"(预期 i-xxxxxxxxxx 格式)`);
  96.   }

  97.   // REGION_ID 校验
  98.   const regionId = env.REGION_ID || DEFAULTS.REGION_ID;
  99.   const validRegionPrefixes = [
  100.     'cn-', 'ap-', 'us-', 'eu-', 'me-', 'us-east-', 'us-west-',
  101.     'ap-northeast-', 'ap-southeast-', 'ap-south-',
  102.   ];
  103.   const regionValid = validRegionPrefixes.some(p => regionId.startsWith(p));
  104.   if (!regionValid) {
  105.     warnings.push(`REGION_ID "${regionId}" 可能不是有效的阿里云地域`);
  106.   }

  107.   // TRAFFIC_THRESHOLD_GB 校验
  108.   let trafficThresholdGB;
  109.   const rawThreshold = env.TRAFFIC_THRESHOLD_GB;
  110.   if (rawThreshold !== undefined && rawThreshold !== '') {
  111.     trafficThresholdGB = parseFloat(rawThreshold);
  112.     if (isNaN(trafficThresholdGB)) {
  113.       errors.push(`TRAFFIC_THRESHOLD_GB 不是有效数字: "${rawThreshold}"`);
  114.       trafficThresholdGB = DEFAULTS.TRAFFIC_THRESHOLD_GB;
  115.     } else if (trafficThresholdGB <= 0) {
  116.       errors.push(`TRAFFIC_THRESHOLD_GB 必须为正数,当前值: ${trafficThresholdGB}`);
  117.       trafficThresholdGB = DEFAULTS.TRAFFIC_THRESHOLD_GB;
  118.     }
  119.   } else {
  120.     trafficThresholdGB = DEFAULTS.TRAFFIC_THRESHOLD_GB;
  121.   }

  122.   // STOPPED_MODE 校验
  123.   const stoppedMode = resolveStoppedMode(env.STOPPED_MODE || DEFAULTS.STOPPED_MODE);
  124.   if (stoppedMode !== 'StopCharging' && stoppedMode !== 'KeepCharging') {
  125.     warnings.push(`STOPPED_MODE "${stoppedMode}" 不是标准值,将原样传递给 API`);
  126.   }

  127.   return {
  128.     errors,
  129.     warnings,
  130.     params: {
  131.       ACCESS_KEY_ID,
  132.       ACCESS_KEY_SECRET,
  133.       ECS_INSTANCE_ID,
  134.       regionId,
  135.       trafficThresholdGB,
  136.       stoppedMode,
  137.     }
  138.   };
  139. }

  140. // ==================== 指数退避重试 ====================
  141. async function retryWithBackoff(fn, options = {}) {
  142.   const {
  143.     maxRetries = 3,
  144.     baseDelayMs = 1000,
  145.     maxDelayMs = 8000,
  146.     operationName = 'API call',
  147.     logger = null,
  148.   } = options;

  149.   let lastError;
  150.   for (let attempt = 1; attempt <= maxRetries; attempt++) {
  151.     try {
  152.       return await fn();
  153.     } catch (err) {
  154.       lastError = err;
  155.       if (attempt < maxRetries) {
  156.         // 指数退避:1s, 2s, 4s, 8s...
  157.         const delay = Math.min(baseDelayMs * Math.pow(2, attempt - 1), maxDelayMs);
  158.         if (logger) {
  159.           logger.warning(`${operationName} 第 ${attempt} 次失败,${delay}ms 后重试`, {
  160.             error: err.message,
  161.           });
  162.         }
  163.         await new Promise(resolve => setTimeout(resolve, delay));
  164.       }
  165.     }
  166.   }
  167.   throw lastError;
  168. }

  169. // ==================== 阿里云 API 签名 ====================
  170. function percentEncode(str) {
  171.   return encodeURIComponent(String(str))
  172.     .replace(/\+/g, '%20')
  173.     .replace(/\*/g, '%2A')
  174.     .replace(/%7E/g, '~');
  175. }

  176. async function hmacSha1(key, message) {
  177.   const encoder = new TextEncoder();
  178.   const cryptoKey = await crypto.subtle.importKey(
  179.     'raw',
  180.     encoder.encode(key),
  181.     { name: 'HMAC', hash: 'SHA-1' },
  182.     false,
  183.     ['sign']
  184.   );
  185.   const signature = await crypto.subtle.sign('HMAC', cryptoKey, encoder.encode(message));
  186.   return btoa(String.fromCharCode(...new Uint8Array(signature)));
  187. }

  188. function getUtcTimestamp() {
  189.   return new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
  190. }

  191. function generateNonce() {
  192.   const arr = new Uint8Array(16);
  193.   crypto.getRandomValues(arr);
  194.   return Array.from(arr, b => b.toString(16).padStart(2, '0')).join('');
  195. }

  196. async function signRequest(params, accessKeySecret) {
  197.   // 按参数名排序
  198.   const sortedKeys = Object.keys(params).sort();
  199.   const canonicalized = sortedKeys
  200.     .map(k => `${percentEncode(k)}=${percentEncode(params[k])}`)
  201.     .join('&');
  202.   const stringToSign = `GET&${percentEncode('/')}&${percentEncode(canonicalized)}`;
  203.   const signature = await hmacSha1(accessKeySecret + '&', stringToSign);
  204.   return signature;
  205. }

  206. async function callAliyunApi(endpoint, version, action, accessKeyId, accessKeySecret, extraParams = {}) {
  207.   const params = {
  208.     Format: 'JSON',
  209.     Version: version,
  210.     AccessKeyId: accessKeyId,
  211.     SignatureMethod: 'HMAC-SHA1',
  212.     Timestamp: getUtcTimestamp(),
  213.     SignatureVersion: '1.0',
  214.     SignatureNonce: generateNonce(),
  215.     Action: action,
  216.     ...extraParams,
  217.   };

  218.   params.Signature = await signRequest(params, accessKeySecret);

  219.   const queryString = Object.entries(params)
  220.     .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
  221.     .join('&');

  222.   const url = `https://${endpoint}/?${queryString}`;
  223.   const response = await fetch(url, {
  224.     method: 'GET',
  225.     headers: { 'Accept': 'application/json' },
  226.   });

  227.   const result = await response.json();
  228.   if (result.Code && result.Code !== '200') {
  229.     const err = new Error(`阿里云 API 错误 [${action}]: ${result.Code} - ${result.Message || JSON.stringify(result)}`);
  230.     err.apiCode = result.Code;
  231.     err.apiMessage = result.Message;
  232.     throw err;
  233.   }
  234.   return result;
  235. }

  236. // ==================== CDT 流量查询 ====================
  237. async function queryCdtTraffic(accessKeyId, accessKeySecret, logger) {
  238.   const result = await retryWithBackoff(
  239.     () => callAliyunApi(
  240.       'cdt.aliyuncs.com',
  241.       '2021-08-13',
  242.       'ListCdtInternetTraffic',
  243.       accessKeyId,
  244.       accessKeySecret,
  245.       {}
  246.     ),
  247.     { operationName: 'CDT流量查询', logger }
  248.   );

  249.   const trafficDetails = result.TrafficDetails || [];
  250.   const totalBytes = trafficDetails.reduce((sum, d) => sum + (d.Traffic || 0), 0);
  251.   const totalGB = totalBytes / (1024 ** 3);
  252.   return { totalGB, raw: result };
  253. }

  254. // ==================== ECS 实例操作 ====================
  255. async function describeInstance(regionId, instanceId, accessKeyId, accessKeySecret, logger) {
  256.   const result = await retryWithBackoff(
  257.     () => callAliyunApi(
  258.       `ecs.${regionId}.aliyuncs.com`,
  259.       '2014-05-26',
  260.       'DescribeInstances',
  261.       accessKeyId,
  262.       accessKeySecret,
  263.       {
  264.         RegionId: regionId,
  265.         InstanceIds: JSON.stringify([instanceId]),
  266.       }
  267.     ),
  268.     { operationName: 'ECS实例查询', logger }
  269.   );

  270.   const instances = result.Instances?.Instance || [];
  271.   if (instances.length === 0) {
  272.     throw new Error(`未找到实例 ${instanceId}`);
  273.   }
  274.   return instances[0];
  275. }

  276. async function startInstance(regionId, instanceId, accessKeyId, accessKeySecret, logger) {
  277.   return retryWithBackoff(
  278.     () => callAliyunApi(
  279.       `ecs.${regionId}.aliyuncs.com`,
  280.       '2014-05-26',
  281.       'StartInstance',
  282.       accessKeyId,
  283.       accessKeySecret,
  284.       {
  285.         InstanceId: instanceId,
  286.       }
  287.     ),
  288.     { operationName: '启动实例', logger }
  289.   );
  290. }

  291. async function stopInstance(regionId, instanceId, accessKeyId, accessKeySecret, stoppedMode, logger) {
  292.   return retryWithBackoff(
  293.     () => callAliyunApi(
  294.       `ecs.${regionId}.aliyuncs.com`,
  295.       '2014-05-26',
  296.       'StopInstance',
  297.       accessKeyId,
  298.       accessKeySecret,
  299.       {
  300.         InstanceId: instanceId,
  301.         StoppedMode: stoppedMode,
  302.         ForceStop: 'true',
  303.       }
  304.     ),
  305.     { operationName: '停止实例', logger }
  306.   );
  307. }

  308. // ==================== 状态轮询(带超时保护)====================
  309. async function waitForStatus(regionId, instanceId, accessKeyId, accessKeySecret, targetStatus, logger) {
  310.   const MAX_POLL_COUNT = 3;       // 最多轮询 3 次(Worker 环境限制)
  311.   const POLL_INTERVAL_MS = 5000;  // 每 5 秒查一次
  312.   const POLL_TIMEOUT_MS = 20000;  // 总超时 20 秒
  313.   const startTime = Date.now();

  314.   for (let i = 1; i <= MAX_POLL_COUNT; i++) {
  315.     // 超时保护
  316.     if (Date.now() - startTime > POLL_TIMEOUT_MS) {
  317.       logger.warning(`状态轮询超时 (${POLL_TIMEOUT_MS}ms),不再等待`);
  318.       return { success: false, status: 'timeout', message: '轮询超时' };
  319.     }

  320.     // 等待
  321.     await new Promise(resolve => setTimeout(resolve, POLL_INTERVAL_MS));

  322.     // 查询当前状态
  323.     const instance = await describeInstance(regionId, instanceId, accessKeyId, accessKeySecret, logger);
  324.     const currentStatus = instance.Status;
  325.     logger.info(`轮询 ${i}/${MAX_POLL_COUNT}: 当前状态 ${currentStatus}`);

  326.     if (currentStatus === targetStatus) {
  327.       return { success: true, status: currentStatus, message: `已达到目标状态 ${targetStatus}` };
  328.     }
  329.   }

  330.   return { success: false, status: 'pending', message: `轮询 ${MAX_POLL_COUNT} 次后仍未达到 ${targetStatus}` };
  331. }

  332. // ==================== 主逻辑 ====================
  333. async function handleKeepAlive(env) {
  334.   const logger = new Logger();
  335.   logger.info('ECS Keep-Alive 开始执行');

  336.   // 1. 参数校验
  337.   const validation = validateParams(env);

  338.   // 报告警告
  339.   for (const w of validation.warnings) {
  340.     logger.warning(w);
  341.   }

  342.   // 如果有致命错误,直接返回
  343.   if (validation.errors.length > 0) {
  344.     for (const e of validation.errors) {
  345.       logger.error(e);
  346.     }
  347.     logger.error('参数校验失败,终止执行');
  348.     return logger.toResponse(500);
  349.   }

  350.   const {
  351.     ACCESS_KEY_ID,
  352.     ACCESS_KEY_SECRET,
  353.     ECS_INSTANCE_ID,
  354.     regionId,
  355.     trafficThresholdGB,
  356.     stoppedMode,
  357.   } = validation.params;

  358.   logger.info('配置信息', {
  359.     instance: ECS_INSTANCE_ID,
  360.     region: regionId,
  361.     thresholdGB: trafficThresholdGB,
  362.     stoppedMode,
  363.   });

  364.   try {
  365.     // 2. 查询 CDT 互联网总流量
  366.     let totalGB = 0;
  367.     try {
  368.       const cdtResult = await queryCdtTraffic(ACCESS_KEY_ID, ACCESS_KEY_SECRET, logger);
  369.       totalGB = cdtResult.totalGB;
  370.       logger.info('CDT流量查询完成', { totalGB: totalGB.toFixed(4) });
  371.     } catch (cdtErr) {
  372.       logger.warning('CDT流量查询失败,视为 0 GB', { error: cdtErr.message });
  373.       totalGB = 0;
  374.     }

  375.     // 3. 查询 ECS 实例当前状态
  376.     let instance;
  377.     try {
  378.       instance = await describeInstance(regionId, ECS_INSTANCE_ID, ACCESS_KEY_ID, ACCESS_KEY_SECRET, logger);
  379.     } catch (descErr) {
  380.       logger.error('查询实例状态失败', { error: descErr.message });
  381.       return logger.toResponse(500);
  382.     }

  383.     const status = instance.Status;
  384.     logger.info('当前实例状态', { status });

  385.     // 4. 决策逻辑
  386.     const shouldKeepRunning = totalGB < trafficThresholdGB;
  387.     logger.info('决策', {
  388.       totalGB: totalGB.toFixed(2),
  389.       thresholdGB: trafficThresholdGB,
  390.       shouldKeepRunning,
  391.       reason: shouldKeepRunning
  392.         ? `流量 ${totalGB.toFixed(2)} GB < 阈值 ${trafficThresholdGB} GB → 应保持运行`
  393.         : `流量 ${totalGB.toFixed(2)} GB >= 阈值 ${trafficThresholdGB} GB → 应停止`,
  394.     });

  395.     if (shouldKeepRunning) {
  396.       // 应保持运行
  397.       if (status === 'Running') {
  398.         logger.info('实例已在运行,保活成功');
  399.       } else if (status === 'Stopped') {
  400.         logger.info('实例已停止,发送启动请求...');
  401.         const startResult = await startInstance(regionId, ECS_INSTANCE_ID, ACCESS_KEY_ID, ACCESS_KEY_SECRET, logger);
  402.         logger.info('启动请求已发送', { RequestId: startResult.RequestId });

  403.         // 轮询等待 Running
  404.         const pollResult = await waitForStatus(regionId, ECS_INSTANCE_ID, ACCESS_KEY_ID, ACCESS_KEY_SECRET, 'Running', logger);
  405.         if (pollResult.success) {
  406.           logger.info('实例已成功启动');
  407.         } else {
  408.           logger.warning('实例启动中,下次 Cron 将再次检查', { pollResult });
  409.         }
  410.       } else if (status === 'Starting') {
  411.         logger.info('实例正在启动中,等待完成');
  412.         const pollResult = await waitForStatus(regionId, ECS_INSTANCE_ID, ACCESS_KEY_ID, ACCESS_KEY_SECRET, 'Running', logger);
  413.         if (pollResult.success) {
  414.           logger.info('实例已进入运行状态');
  415.         } else {
  416.           logger.warning('实例仍在启动中,下次 Cron 将再次检查');
  417.         }
  418.       } else {
  419.         logger.warning(`实例处于 ${status} 状态,暂不操作`);
  420.       }
  421.     } else {
  422.       // 应停止
  423.       if (status === 'Stopped') {
  424.         logger.info('实例已停止,无需操作');
  425.       } else if (status === 'Running') {
  426.         logger.info('流量超限,发送停止请求...', { stoppedMode });
  427.         const stopResult = await stopInstance(regionId, ECS_INSTANCE_ID, ACCESS_KEY_ID, ACCESS_KEY_SECRET, stoppedMode, logger);
  428.         logger.info('停止请求已发送', { RequestId: stopResult.RequestId });

  429.         // 轮询等待 Stopped
  430.         const pollResult = await waitForStatus(regionId, ECS_INSTANCE_ID, ACCESS_KEY_ID, ACCESS_KEY_SECRET, 'Stopped', logger);
  431.         if (pollResult.success) {
  432.           logger.info('实例已成功停止');
  433.         } else {
  434.           logger.warning('实例停止中,下次 Cron 将再次检查', { pollResult });
  435.         }
  436.       } else if (status === 'Stopping') {
  437.         logger.info('实例正在停止中,等待完成');
  438.         const pollResult = await waitForStatus(regionId, ECS_INSTANCE_ID, ACCESS_KEY_ID, ACCESS_KEY_SECRET, 'Stopped', logger);
  439.         if (pollResult.success) {
  440.           logger.info('实例已进入停止状态');
  441.         } else {
  442.           logger.warning('实例仍在停止中,下次 Cron 将再次检查');
  443.         }
  444.       } else {
  445.         logger.warning(`实例处于 ${status} 状态,暂不操作`);
  446.       }
  447.     }

  448.     logger.info('执行完毕');
  449.     return logger.toResponse(200);

  450.   } catch (err) {
  451.     logger.error('执行异常', { error: err.message, stack: err.stack });
  452.     return logger.toResponse(500);
  453.   }
  454. }
复制代码

3. 配置环境变量
在 Cloudflare Worker 的“运行时设置“ → “环境变量“中,配置以下变量(也可在代码顶部 DEFAULTS 对象中直接修改):
- ACCESS_KEY_ID:阿里云 AccessKey ID
- ACCESS_KEY_SECRET:阿里云 AccessKey Secret
- REGION_ID:区域ID(如香港填 cn-hongkong)
- ECS_INSTANCE_ID:ECS 实例ID(格式 i-xxxxxxxxx)
- TRAFFIC_THRESHOLD_GB:180流量阈值(GB),超过则停止
- STOPPED_MODE:停机模式(节省停机 或 普通停机)
变量填写注意事项:
- ACCESS_KEY_ID / ACCESS_KEY_SECRET:在阿里云 RAM 用户管理页面创建并获取,请妥善保管,不要泄露
- REGION_ID:填写你的 ECS 实例所在区域,如香港填 cn-hongkong
- ECS_INSTANCE_ID:在 ECS 控制台实例详情页面获取,格式为 i-xxxxxxxxx
- TRAFFIC_THRESHOLD_GB:正常使用时建议设为 180GB(留 20GB 安全余量,国外服务器总额度 200G)。前期部署测试时建议先填写 1GB 或几 GB,在Cloudflare Worker 的Observability观察日志确认开关机逻辑正确后再改回 180
- STOPPED_MODE:普通停机或 节省停机
4. 部署
点击“部署“按钮,等待部署完成。
5. 关闭 HTTP 访问路由(重要!)
部署完成后,务必在 Worker 设置中关闭默认的 HTTP 访问路由,否则任何人访问该 Worker 地址都能看到执行日志和流量信息,存在安全隐患。

七、配置 Cron 触发器
1. 进入触发器设置
在 Worker 详情页面上方点击“触发器“选项卡,找到“Cron 触发器“部分。
2. 设置定时策略
填入以下表达式:
  1. */2 * * * *
复制代码

定时策略说明: 建议填写 2~5 分钟 执行一次,不要小于 1 分钟。原因是:Cloudflare Worker 初始化构件需要几十秒,脚本执行本身也需要十几秒,如果间隔设为 1 分钟,可能出现上一个脚本还没跑完,下一个定时任务就开始了,导致并发执行异常。

八、脚本逻辑原理说明
1. 整体架构
本脚本采用事件驱动 + 状态机设计,运行在 Cloudflare Workers 边缘节点上,无需自备服务器。
2. 执行流程
- 触发:Cron 触发器按设定间隔自动调用,也可通过 HTTP 请求手动触发
- 参数校验:启动时检查 ACCESS_KEY_ID 和 ECS_INSTANCE_ID 是否已正确配置,未配置则直接返回 500 错误
- 流量查询:通过阿里云 CDT API(ListCdtInternetTraffic)查询当前累计互联网流量
- 状态查询:通过 ECS API(DescribeInstances)查询实例当前运行状态
- 决策:
- 流量 < 阈值 → 调用StartInstance启动实例
- 流量 >= 阈值 → 调用StopInstance停止实例
- 操作:根据决策结果执行启动或停止,并记录操作结果
- 日志:所有关键步骤均输出结构化日志,可在 Cloudflare Worker 的日志 Observability 页面查看
3. 安全机制
- HMAC-SHA256 签名:所有阿里云 API 请求均使用 HMAC-SHA256 签名,确保请求完整性
- 凭据保护:AccessKey 等敏感信息通过环境变量注入,不硬编码在代码中
- 参数校验:启动时校验必要参数,防止因配置错误导致空操作
- HTTP 路由关闭:部署后关闭外部 HTTP 访问,防止脚本被未授权调用
4. 重试与容错
- 指数退避重试:API 调用失败时自动重试,重试间隔指数增长
- 状态轮询超时保护:查询实例状态时设置超时,防止长时间挂起
- 结构化日志:每次执行输出完整的 JSON 格式日志,便于排查问题

九、测试验证
1. 手动触发测试
部署完成后,在 Worker 页面点击“访问“按钮手动触发一次执行,观察日志输出:
- 检查 CDT 流量查询是否正常返回
- 检查实例状态查询是否正常
- 检查启停决策是否符合预期
2. 前期测试建议
首次部署时,建议将 TRAFFIC_THRESHOLD_GB 设为 1GB 或几 GB,这样能很快触发开关机逻辑,验证脚本是否正常工作。确认无误后,再将阈值改回 180GB 用于日常保活。

十、费用预估
- ECS 抢占式实例(ecs.e-c4m1.large):约 0.1元/天
- CDT 流量包:免费200G 单向高速流量
- Cloudflare Workers:免费(每天 10 万次请求)
- 公网 IP + 共享带宽:弹性公网 IP 绑定至 ECS 实例后不再单独计费,共享带宽池内的流量费用已包含在实例费用中,无需额外付费
合计:每月约 4 元,即可享受 200G 单向高速流量。


附:参考链接
- 原始教程:https://bbs.biliup.rs/t/topic/46(本文基于此教程优化)
- Alpine 镜像项目:https://github.com/xixi-zhao/alpine-cloud-build
- Cloudflare Workers:Cloudflare Dashboard

十一、收尾工作(重要!)
务必执行以下操作,避免额外扣费!
1. 删除自定义镜像: 进入 ECS 控制台 -> 镜像 -> 找到你导入的 alpine 自定义镜像 -> 删除。
2. 删除OSS存储: 进入 OSS 控制台 -> 找到你创建的 Bucket -> 删除上传的 alpine 镜像文件 -> 最后删除整个 Bucket。
注意事项:
- 本教程中的阿里云 RAM 用户 AccessKey 请妥善保管,不要分享给他人
- 建议定期查看阿里云费用中心,确认费用在预期范围内
- 镜像导入时务必选择 UEFI 启动模式,选 BIOS 会导致实例无法启动
- 创建实例时务必绑定密钥对,否则无法 SSH 登录
- 部署后务必关闭 Worker 的 HTTP 访问路由,防止日志泄露

如有问题,请参考原始教程原文https://bbs.biliup.rs/t/topic/46
爱生活,爱奶昔~

评论6

qixiaomoLv.2 发表于 2026-10-9 17:39:40 | 查看全部
大佬好牛,想弄好久没找到教程
爱生活,爱奶昔~
maxfongLv.2 发表于 2026-10-9 17:40:40 | 查看全部
有点厉害,看着有点复杂
爱生活,爱奶昔~
lushu346Lv.3 发表于 2026-10-9 18:24:13 | 查看全部
每月为每个阿里云账号提供 220 GB 的免费公网出向流量额度(其中 20 GB/月 适用于中国内地地域,200 GB/月 适用于非中国内地地域)
爱生活,爱奶昔~
shun26Lv.2 发表于 2026-10-9 21:11:08 | 查看全部
这个是自己做鸡场吗
爱生活,爱奶昔~
mrjiangLv.4 发表于 2026-10-9 21:22:57 | 查看全部
这个拿来当落地挺香
爱生活,爱奶昔~
xuiLv.4 发表于 2026-10-10 03:25:25 来自手机 | 查看全部
不如用谷歌云,把CDN的流量禁掉
爱生活,爱奶昔~

回复

您需要登录后才可以回帖 登录 | 注册

本版积分规则

© 2026 Naixi Networks. 沪ICP备13020230号-1|沪公网安备 31010702007642号手机版小黑屋RSS
返回顶部 关灯 在本版发帖
快速回复 返回顶部 返回列表