注册奶昔,结交更多奶友,可做任务快速升级,解锁更多权益。
您需要 登录 才可以下载或查看,没有账号?注册
×
前言
本文是在 https://bbs.biliup.rs/t/topic/46 这篇原始教程的基础上,结合个人实际部署经验总结优化而成。原始教程的镜像部署方式比较繁琐且分区不合理(最后可用分区不到200M),本文已替换为更优方案。如有不理解之处,建议参考原始教程原文。
核心要点速览
镜像:使用 alpine-cloud-build 项目的 alpine-custom.qcow2(99.3MB),系统盘最小1G,可用分区充裕
登录用户:alpine,禁止 root 直接 SSH;登录后
切 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 登录
使用绑定密钥对时下载的私钥文件登录:
- ssh -i <你的私钥文件路径> alpine@<ECS公网IP>
复制代码
2. 切换到 root 权限
切换。

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

六、部署 Cloudflare Workers 保活脚本
说明: 原始教程使用另一台服务器运行 Python 脚本 + crontab 来保活,需要额外付费。本教程使用免费的 Cloudflare Workers 来执行定时保活任务,无需额外服务器,零成本。
1. 创建 Cloudflare Worker
- 登录 Cloudflare Dashboard
- 进入 Workers & Pages → 创建 Worker
- 给 Worker 起个名字(如 ecs-keepalive)
2. 粘贴 Worker 脚本
将以下代码粘贴到 Worker 的编辑器中,覆盖默认代码:
- // ============================================================
- // Aliyun ECS Keep-Alive - Pure Cloudflare Worker (Production-Ready)
- // 功能:根据 CDT 流量阈值自动启停 ECS 实例
- // 特性:参数校验、指数退避重试、状态轮询超时保护、结构化日志
- // 部署:粘贴到 CF Worker 编辑器,配置 Cron 触发器即可
- // ============================================================
- export default {
- async fetch(request, env, ctx) {
- if (request.method === 'GET' || request.method === 'POST') {
- return handleKeepAlive(env);
- }
- return new Response('Method not allowed', { status: 405 });
- },
- async scheduled(event, env, ctx) {
- // Cron 定时触发
- ctx.waitUntil(handleKeepAlive(env));
- }
- };
- // ==================== 配置(可在 env 中覆盖)====================
- const DEFAULTS = {
- REGION_ID: 'cn-hongkong',
- TRAFFIC_THRESHOLD_GB: 180,
- STOPPED_MODE: 'StopCharging',
- };
- // ==================== STOPPED_MODE 别名映射 ====================
- const STOPPED_MODE_MAP = {
- // 中文
- '节省停机': 'StopCharging',
- '节省': 'StopCharging',
- '普通停机': 'KeepCharging',
- '普通': 'KeepCharging',
- // 英文
- 'economy': 'StopCharging',
- 'saving': 'StopCharging',
- 'normal': 'KeepCharging',
- 'standard': 'KeepCharging',
- // 原值(小写)
- 'stopcharging': 'StopCharging',
- 'keepcharging': 'KeepCharging',
- };
- function resolveStoppedMode(raw) {
- const key = String(raw).trim().toLowerCase();
- return STOPPED_MODE_MAP[key] || raw;
- }
- // ==================== 结构化日志 ====================
- class Logger {
- constructor() {
- this.entries = [];
- }
- _log(level, message, data = null) {
- const entry = {
- timestamp: new Date().toISOString(),
- level,
- message,
- };
- if (data !== null) entry.data = data;
- this.entries.push(entry);
- // 同时输出到 console(CF Workers 日志可查看)
- if (level === 'ERROR') {
- console.error(JSON.stringify(entry));
- } else if (level === 'WARNING') {
- console.warn(JSON.stringify(entry));
- } else {
- console.log(JSON.stringify(entry));
- }
- }
- info(message, data) { this._log('INFO', message, data); }
- warning(message, data) { this._log('WARNING', message, data); }
- error(message, data) { this._log('ERROR', message, data); }
- toResponse(status = 200) {
- const lines = this.entries.map(e => {
- const prefix = e.level === 'ERROR' ? '[ERROR]' : e.level === 'WARNING' ? '[WARN]' : '[INFO]';
- const dataStr = e.data ? ' | ' + JSON.stringify(e.data) : '';
- return `[${e.timestamp}] ${prefix} ${e.message}${dataStr}`;
- });
- return new Response(lines.join('\n'), {
- status,
- headers: { 'Content-Type': 'text/plain; charset=utf-8' },
- });
- }
- }
- // ==================== 参数校验 ====================
- function validateParams(env) {
- const errors = [];
- const warnings = [];
- // 必填项检查
- const ACCESS_KEY_ID = env.ACCESS_KEY_ID;
- const ACCESS_KEY_SECRET = env.ACCESS_KEY_SECRET;
- const ECS_INSTANCE_ID = env.ECS_INSTANCE_ID;
- if (!ACCESS_KEY_ID) errors.push('ACCESS_KEY_ID 未配置');
- if (!ACCESS_KEY_SECRET) errors.push('ACCESS_KEY_SECRET 未配置');
- if (!ECS_INSTANCE_ID) errors.push('ECS_INSTANCE_ID 未配置');
- // ECS_INSTANCE_ID 格式校验(i- 开头)
- if (ECS_INSTANCE_ID && !/^i-[a-z0-9]{10,30}$/.test(ECS_INSTANCE_ID)) {
- warnings.push(`ECS_INSTANCE_ID 格式可能不正确: "${ECS_INSTANCE_ID}"(预期 i-xxxxxxxxxx 格式)`);
- }
- // REGION_ID 校验
- const regionId = env.REGION_ID || DEFAULTS.REGION_ID;
- const validRegionPrefixes = [
- 'cn-', 'ap-', 'us-', 'eu-', 'me-', 'us-east-', 'us-west-',
- 'ap-northeast-', 'ap-southeast-', 'ap-south-',
- ];
- const regionValid = validRegionPrefixes.some(p => regionId.startsWith(p));
- if (!regionValid) {
- warnings.push(`REGION_ID "${regionId}" 可能不是有效的阿里云地域`);
- }
- // TRAFFIC_THRESHOLD_GB 校验
- let trafficThresholdGB;
- const rawThreshold = env.TRAFFIC_THRESHOLD_GB;
- if (rawThreshold !== undefined && rawThreshold !== '') {
- trafficThresholdGB = parseFloat(rawThreshold);
- if (isNaN(trafficThresholdGB)) {
- errors.push(`TRAFFIC_THRESHOLD_GB 不是有效数字: "${rawThreshold}"`);
- trafficThresholdGB = DEFAULTS.TRAFFIC_THRESHOLD_GB;
- } else if (trafficThresholdGB <= 0) {
- errors.push(`TRAFFIC_THRESHOLD_GB 必须为正数,当前值: ${trafficThresholdGB}`);
- trafficThresholdGB = DEFAULTS.TRAFFIC_THRESHOLD_GB;
- }
- } else {
- trafficThresholdGB = DEFAULTS.TRAFFIC_THRESHOLD_GB;
- }
- // STOPPED_MODE 校验
- const stoppedMode = resolveStoppedMode(env.STOPPED_MODE || DEFAULTS.STOPPED_MODE);
- if (stoppedMode !== 'StopCharging' && stoppedMode !== 'KeepCharging') {
- warnings.push(`STOPPED_MODE "${stoppedMode}" 不是标准值,将原样传递给 API`);
- }
- return {
- errors,
- warnings,
- params: {
- ACCESS_KEY_ID,
- ACCESS_KEY_SECRET,
- ECS_INSTANCE_ID,
- regionId,
- trafficThresholdGB,
- stoppedMode,
- }
- };
- }
- // ==================== 指数退避重试 ====================
- async function retryWithBackoff(fn, options = {}) {
- const {
- maxRetries = 3,
- baseDelayMs = 1000,
- maxDelayMs = 8000,
- operationName = 'API call',
- logger = null,
- } = options;
- let lastError;
- for (let attempt = 1; attempt <= maxRetries; attempt++) {
- try {
- return await fn();
- } catch (err) {
- lastError = err;
- if (attempt < maxRetries) {
- // 指数退避:1s, 2s, 4s, 8s...
- const delay = Math.min(baseDelayMs * Math.pow(2, attempt - 1), maxDelayMs);
- if (logger) {
- logger.warning(`${operationName} 第 ${attempt} 次失败,${delay}ms 后重试`, {
- error: err.message,
- });
- }
- await new Promise(resolve => setTimeout(resolve, delay));
- }
- }
- }
- throw lastError;
- }
- // ==================== 阿里云 API 签名 ====================
- function percentEncode(str) {
- return encodeURIComponent(String(str))
- .replace(/\+/g, '%20')
- .replace(/\*/g, '%2A')
- .replace(/%7E/g, '~');
- }
- async function hmacSha1(key, message) {
- const encoder = new TextEncoder();
- const cryptoKey = await crypto.subtle.importKey(
- 'raw',
- encoder.encode(key),
- { name: 'HMAC', hash: 'SHA-1' },
- false,
- ['sign']
- );
- const signature = await crypto.subtle.sign('HMAC', cryptoKey, encoder.encode(message));
- return btoa(String.fromCharCode(...new Uint8Array(signature)));
- }
- function getUtcTimestamp() {
- return new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
- }
- function generateNonce() {
- const arr = new Uint8Array(16);
- crypto.getRandomValues(arr);
- return Array.from(arr, b => b.toString(16).padStart(2, '0')).join('');
- }
- async function signRequest(params, accessKeySecret) {
- // 按参数名排序
- const sortedKeys = Object.keys(params).sort();
- const canonicalized = sortedKeys
- .map(k => `${percentEncode(k)}=${percentEncode(params[k])}`)
- .join('&');
- const stringToSign = `GET&${percentEncode('/')}&${percentEncode(canonicalized)}`;
- const signature = await hmacSha1(accessKeySecret + '&', stringToSign);
- return signature;
- }
- async function callAliyunApi(endpoint, version, action, accessKeyId, accessKeySecret, extraParams = {}) {
- const params = {
- Format: 'JSON',
- Version: version,
- AccessKeyId: accessKeyId,
- SignatureMethod: 'HMAC-SHA1',
- Timestamp: getUtcTimestamp(),
- SignatureVersion: '1.0',
- SignatureNonce: generateNonce(),
- Action: action,
- ...extraParams,
- };
- params.Signature = await signRequest(params, accessKeySecret);
- const queryString = Object.entries(params)
- .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
- .join('&');
- const url = `https://${endpoint}/?${queryString}`;
- const response = await fetch(url, {
- method: 'GET',
- headers: { 'Accept': 'application/json' },
- });
- const result = await response.json();
- if (result.Code && result.Code !== '200') {
- const err = new Error(`阿里云 API 错误 [${action}]: ${result.Code} - ${result.Message || JSON.stringify(result)}`);
- err.apiCode = result.Code;
- err.apiMessage = result.Message;
- throw err;
- }
- return result;
- }
- // ==================== CDT 流量查询 ====================
- async function queryCdtTraffic(accessKeyId, accessKeySecret, logger) {
- const result = await retryWithBackoff(
- () => callAliyunApi(
- 'cdt.aliyuncs.com',
- '2021-08-13',
- 'ListCdtInternetTraffic',
- accessKeyId,
- accessKeySecret,
- {}
- ),
- { operationName: 'CDT流量查询', logger }
- );
- const trafficDetails = result.TrafficDetails || [];
- const totalBytes = trafficDetails.reduce((sum, d) => sum + (d.Traffic || 0), 0);
- const totalGB = totalBytes / (1024 ** 3);
- return { totalGB, raw: result };
- }
- // ==================== ECS 实例操作 ====================
- async function describeInstance(regionId, instanceId, accessKeyId, accessKeySecret, logger) {
- const result = await retryWithBackoff(
- () => callAliyunApi(
- `ecs.${regionId}.aliyuncs.com`,
- '2014-05-26',
- 'DescribeInstances',
- accessKeyId,
- accessKeySecret,
- {
- RegionId: regionId,
- InstanceIds: JSON.stringify([instanceId]),
- }
- ),
- { operationName: 'ECS实例查询', logger }
- );
- const instances = result.Instances?.Instance || [];
- if (instances.length === 0) {
- throw new Error(`未找到实例 ${instanceId}`);
- }
- return instances[0];
- }
- async function startInstance(regionId, instanceId, accessKeyId, accessKeySecret, logger) {
- return retryWithBackoff(
- () => callAliyunApi(
- `ecs.${regionId}.aliyuncs.com`,
- '2014-05-26',
- 'StartInstance',
- accessKeyId,
- accessKeySecret,
- {
- InstanceId: instanceId,
- }
- ),
- { operationName: '启动实例', logger }
- );
- }
- async function stopInstance(regionId, instanceId, accessKeyId, accessKeySecret, stoppedMode, logger) {
- return retryWithBackoff(
- () => callAliyunApi(
- `ecs.${regionId}.aliyuncs.com`,
- '2014-05-26',
- 'StopInstance',
- accessKeyId,
- accessKeySecret,
- {
- InstanceId: instanceId,
- StoppedMode: stoppedMode,
- ForceStop: 'true',
- }
- ),
- { operationName: '停止实例', logger }
- );
- }
- // ==================== 状态轮询(带超时保护)====================
- async function waitForStatus(regionId, instanceId, accessKeyId, accessKeySecret, targetStatus, logger) {
- const MAX_POLL_COUNT = 3; // 最多轮询 3 次(Worker 环境限制)
- const POLL_INTERVAL_MS = 5000; // 每 5 秒查一次
- const POLL_TIMEOUT_MS = 20000; // 总超时 20 秒
- const startTime = Date.now();
- for (let i = 1; i <= MAX_POLL_COUNT; i++) {
- // 超时保护
- if (Date.now() - startTime > POLL_TIMEOUT_MS) {
- logger.warning(`状态轮询超时 (${POLL_TIMEOUT_MS}ms),不再等待`);
- return { success: false, status: 'timeout', message: '轮询超时' };
- }
- // 等待
- await new Promise(resolve => setTimeout(resolve, POLL_INTERVAL_MS));
- // 查询当前状态
- const instance = await describeInstance(regionId, instanceId, accessKeyId, accessKeySecret, logger);
- const currentStatus = instance.Status;
- logger.info(`轮询 ${i}/${MAX_POLL_COUNT}: 当前状态 ${currentStatus}`);
- if (currentStatus === targetStatus) {
- return { success: true, status: currentStatus, message: `已达到目标状态 ${targetStatus}` };
- }
- }
- return { success: false, status: 'pending', message: `轮询 ${MAX_POLL_COUNT} 次后仍未达到 ${targetStatus}` };
- }
- // ==================== 主逻辑 ====================
- async function handleKeepAlive(env) {
- const logger = new Logger();
- logger.info('ECS Keep-Alive 开始执行');
- // 1. 参数校验
- const validation = validateParams(env);
- // 报告警告
- for (const w of validation.warnings) {
- logger.warning(w);
- }
- // 如果有致命错误,直接返回
- if (validation.errors.length > 0) {
- for (const e of validation.errors) {
- logger.error(e);
- }
- logger.error('参数校验失败,终止执行');
- return logger.toResponse(500);
- }
- const {
- ACCESS_KEY_ID,
- ACCESS_KEY_SECRET,
- ECS_INSTANCE_ID,
- regionId,
- trafficThresholdGB,
- stoppedMode,
- } = validation.params;
- logger.info('配置信息', {
- instance: ECS_INSTANCE_ID,
- region: regionId,
- thresholdGB: trafficThresholdGB,
- stoppedMode,
- });
- try {
- // 2. 查询 CDT 互联网总流量
- let totalGB = 0;
- try {
- const cdtResult = await queryCdtTraffic(ACCESS_KEY_ID, ACCESS_KEY_SECRET, logger);
- totalGB = cdtResult.totalGB;
- logger.info('CDT流量查询完成', { totalGB: totalGB.toFixed(4) });
- } catch (cdtErr) {
- logger.warning('CDT流量查询失败,视为 0 GB', { error: cdtErr.message });
- totalGB = 0;
- }
- // 3. 查询 ECS 实例当前状态
- let instance;
- try {
- instance = await describeInstance(regionId, ECS_INSTANCE_ID, ACCESS_KEY_ID, ACCESS_KEY_SECRET, logger);
- } catch (descErr) {
- logger.error('查询实例状态失败', { error: descErr.message });
- return logger.toResponse(500);
- }
- const status = instance.Status;
- logger.info('当前实例状态', { status });
- // 4. 决策逻辑
- const shouldKeepRunning = totalGB < trafficThresholdGB;
- logger.info('决策', {
- totalGB: totalGB.toFixed(2),
- thresholdGB: trafficThresholdGB,
- shouldKeepRunning,
- reason: shouldKeepRunning
- ? `流量 ${totalGB.toFixed(2)} GB < 阈值 ${trafficThresholdGB} GB → 应保持运行`
- : `流量 ${totalGB.toFixed(2)} GB >= 阈值 ${trafficThresholdGB} GB → 应停止`,
- });
- if (shouldKeepRunning) {
- // 应保持运行
- if (status === 'Running') {
- logger.info('实例已在运行,保活成功');
- } else if (status === 'Stopped') {
- logger.info('实例已停止,发送启动请求...');
- const startResult = await startInstance(regionId, ECS_INSTANCE_ID, ACCESS_KEY_ID, ACCESS_KEY_SECRET, logger);
- logger.info('启动请求已发送', { RequestId: startResult.RequestId });
- // 轮询等待 Running
- const pollResult = await waitForStatus(regionId, ECS_INSTANCE_ID, ACCESS_KEY_ID, ACCESS_KEY_SECRET, 'Running', logger);
- if (pollResult.success) {
- logger.info('实例已成功启动');
- } else {
- logger.warning('实例启动中,下次 Cron 将再次检查', { pollResult });
- }
- } else if (status === 'Starting') {
- logger.info('实例正在启动中,等待完成');
- const pollResult = await waitForStatus(regionId, ECS_INSTANCE_ID, ACCESS_KEY_ID, ACCESS_KEY_SECRET, 'Running', logger);
- if (pollResult.success) {
- logger.info('实例已进入运行状态');
- } else {
- logger.warning('实例仍在启动中,下次 Cron 将再次检查');
- }
- } else {
- logger.warning(`实例处于 ${status} 状态,暂不操作`);
- }
- } else {
- // 应停止
- if (status === 'Stopped') {
- logger.info('实例已停止,无需操作');
- } else if (status === 'Running') {
- logger.info('流量超限,发送停止请求...', { stoppedMode });
- const stopResult = await stopInstance(regionId, ECS_INSTANCE_ID, ACCESS_KEY_ID, ACCESS_KEY_SECRET, stoppedMode, logger);
- logger.info('停止请求已发送', { RequestId: stopResult.RequestId });
- // 轮询等待 Stopped
- const pollResult = await waitForStatus(regionId, ECS_INSTANCE_ID, ACCESS_KEY_ID, ACCESS_KEY_SECRET, 'Stopped', logger);
- if (pollResult.success) {
- logger.info('实例已成功停止');
- } else {
- logger.warning('实例停止中,下次 Cron 将再次检查', { pollResult });
- }
- } else if (status === 'Stopping') {
- logger.info('实例正在停止中,等待完成');
- const pollResult = await waitForStatus(regionId, ECS_INSTANCE_ID, ACCESS_KEY_ID, ACCESS_KEY_SECRET, 'Stopped', logger);
- if (pollResult.success) {
- logger.info('实例已进入停止状态');
- } else {
- logger.warning('实例仍在停止中,下次 Cron 将再次检查');
- }
- } else {
- logger.warning(`实例处于 ${status} 状态,暂不操作`);
- }
- }
- logger.info('执行完毕');
- return logger.toResponse(200);
- } catch (err) {
- logger.error('执行异常', { error: err.message, stack: err.stack });
- return logger.toResponse(500);
- }
- }
复制代码
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. 设置定时策略
填入以下表达式:
定时策略说明: 建议填写 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 |