阿毛
It's me !
想你所想

企业内部云监控与云客制化自动运维平台

一套以「云产品 API 编排」为核心的自动化运维平台——统一纳管阿里云 SAE / ECS / ESS / RDS / OSS / Flink、腾讯云 TKE、自建 K8s、APISIX 网关与 Apollo 配置中心,实现云资源弹性伸缩、故障一键迁移(SAE ⇄ K8s 双向互迁)、成本监控与立体化告警。

同时贴合业务的胶水脚本,覆盖了公司数据/业务保障闭环

云监控与云客制化运维平台(Java / Spring Boot / K8s / APISIX / Apollo / xxl-job / 阿里云 / 腾讯云)

我的角色

  • 主导建设公司统一云运维平台,通过编排阿里云 SAE / ESS / ECS / CMS / RDS / Flink、腾讯云 TKE、自建 K8s、APISIX 与 Apollo 的 OpenAPI,实现弹性伸缩、故障迁移与立体化告警的全自动化;
  • 设计并实现 SAE ⇄ 自建 K8s 双向一键迁移方案:镜像与 Deployment 骨架常态预置 + ESS 按量节点池(污点隔离)+ K8s 副本 JSON-Patch 扩缩 + APISIX 60s 秒级灰度切流(1%→100%)+ Apollo RPC 地址切换;基于 Redis 状态集合实现幂等可重入、断点续跑;并通过定期「轮回切换」演练保障灾备通道随时可用;
  • 实现面向 SAE / TKE / Flink 的时段化自动扩缩容:时间窗 + 策略快照回滚模型,解决混合伸缩策略参数互斥、只扩不缩保护、实例数二次校验等问题,活动扩容从人工数小时降至零人工;
  • 建设 CPU / 成本巡检、OSS 容量监控等告警体系,钉钉 + 电话分级触达。
  • 完成业务支撑类任务开发

开发量与开发周期

提交记录

指标数据
总提交数401 次,其中我 365 次(91%)
累计代码变更+13,206 行新增 / -2,513 行删除(合计约 1.57 万行变更)
其他同事合计约 +1,455 行

时间投入

指标数据
开发周期2023-12 → 2025-07,约 19 个月
有提交的月份15 个月(持续迭代型项目,非一次性交付)
有提交的天数80 天+

开发节奏(可看出项目阶段):

  • 2024.03–04(密集开发期):151 次提交 —— 项目主体从 0 到 1 搭建
  • 2024.08–12(迭代期):70 次提交 —— 功能扩展
  • 2025.01–07(持续运营期):126 次提交 —— 电话告警、扩容推送等能力持续演进 当前代码规模
  • 117 个 Java 文件,约 10,600 行 Java 代码
  • 附带运维脚本(Zeppelin 日志备份、Superset 备份)、K8s/SAE 部署模板等配套资产
https://file.blog.humh.cn/wp-content/uploads/2026/11/20261118003312555-1024x554.png
部分自动化任务

1. 项目背景与价值

公司绝大部分在线服务部署在阿里云 SAE(Serverless 应用引擎)上,由此带来三个现实问题:

  1. 云厂商故障时无路可退:SAE 大面积故障或严重波动时,业务只能干等恢复;
  2. 活动/比赛高峰需人工扩容:每逢大促、赛事,需运维手动逐个调整几十个服务的弹性策略,易漏、易错、易忘记回滚;
  3. 云资源使用缺乏监督:低 CPU 利用率的应用、异常增长的数据 bucket、来源不明的慢 SQL 等成本与稳定性问题无人闭环。

本平台将其全部任务化、自动化、可编排:

能力说明
SAE ⇄ K8s 一键互迁SAE 故障时,将任意一批服务在分钟级迁移至自建 K8s(含节点购买、副本扩容、流量灰度切换),恢复后再一键回迁并释放资源
轮回切换演练定期执行「SAE→K8s→SAE」全链路演练,保证迁移通道随时可用,真正故障时敢切、能切
多平台定时弹性扩缩容面向 SAE / 腾讯 TKE / 阿里云 Flink 的时段化自动扩容与自动回滚(活动前扩、活动后缩,全程钉钉播报)
云资源监控告警SAE CPU 利用率、beta 环境资源超标、OSS 桶容量异常增长、RDS 慢 SQL 来源定位等,钉钉文本 + 电话告警分级触达

2. 总体架构

2.1 架构图

flowchart TB
    subgraph trigger["触发层"]
        XXL["xxl-job调度中心
(定时轮询/手动传参)"] REST["REST接口
(外部系统调用)"] end subgraph core["cv-cloud-monitor(本服务,SpringBoot)"] JOBS["定时任务Job层
迁移/扩缩容/监控/备份"] SVC["Service层
云产品API封装+
状态机编排"] state["Redis
迁移状态·策略快照·
资源统计·IP
→应用映射"] end subgraph aliyun["阿里云"] SAE["SAE OpenAPI
应用/实例/弹性策略"] CMS["云监控CMS
指标查询·
自定义事件(电话告警)"] ESS["ESS 弹性伸缩
按量ECS节点池"] ECS["ECS OpenAPI"] RDS["RDS 慢日志"] OSS["OSS 备份/容量"] FLINK["实时计算 Flink
工作空间/队列资源"] end subgraph infra["自建基础设施"] K8S["自建K8s集群
kubernetes client-java"] TKE["腾讯云TKE(EKS)
公网按需开关"] APISIX["APISIX 网关
Admin API 切流"] APOLLO["Apollo配置中心
OpenAPI改配置+发布"] MYSQL[("MySQL(数仓/明细库)")] end subgraph notify["告警触达"] DING["钉钉机器人
文本/Markdown/@手机号"] PHONE["电话告警
CMS 自定义事件升级"] SENTRY["Sentry异常归集"] end XXL --> JOBS REST --> SVC JOBS --> SVC SVC <--> state SVC --> SAE & CMS & ESS & ECS & RDS & OSS & FLINK SVC --> K8S & TKE & APISIX & APOLLO SVC --> MYSQL SVC --> DING & PHONE & SENTRY

2.2 组件职责

组件在方案中的角色
xxl-job全部任务的调度入口(轮询开关/配置触发迁移,也可手动传参指定应用列表单次执行)
Redis幂等与状态的载体:迁移成功/进行中应用集合、弹性策略变更前快照、每小时 SAE 资源用量统计、SAE 实例 IP→应用名映射、APISIX 路由缓存
APISIX外部南北向流量入口;通过 Admin API 修改路由 upstream 节点与权重,实现秒级灰度切流
Apollo配置中心;内部 RPC 调用地址配置在其上,通过 Open API 修改值并发布,实现东西向流量切换
ESS + ECS自建 K8s 的按量付费节点池;迁移时扩容购买、回迁后释放(按分钟计费)
自建 K8sSAE 的灾备承接环境;所有可迁移应用预先以 0/1 副本常驻部署,迁移时只调副本数
钉钉 / 电话每个阶段成功/失败的通知出口;关键异常(如连续无指标)升级为电话告警

2.3 一次 SAE→K8s 迁移的调用时序

sequenceDiagram
    participant X as xxl-job
    participant M as cv-cloud-monitor
    participant R as Redis
    participant E as ESS/ECS
    participant K as 自建K8s
    participant S as SAE
    participant G as APISIX
    participant A as Apollo

    X->>M: 触发迁移(或轮询到开关+应用列表)
    M->>R: 读取 已完成/进行中 集合,过滤出本轮待迁移应用(幂等)
    M->>R: 异步缓存 APISIX 全量路由 → host:port 反查表
    M->>M: 阶段1 资源测算:取昨日同时段(±2h)各应用
最大实例数/CPU/内存,兜底当前 SAE 实时值 M->>E: 阶段2 调整 ESS 伸缩组 MinSize=DesiredCapacity=⌈总CPU×1.6/32⌉ M->>M: 3×60s 轮询 check 节点数达标 M->>K: 阶段3 JSON-Patch 各应用 Deployment replicas = SAE 实例数 M->>M: 线程池并发 3×50s check 可用副本达标 M->>S: 阶段4 设置弹性策略「禁止缩容」 M->>G: 阶段5 60s 内灰度切流 1%→10%→30%→60%→80%→100% M->>G: 全量路由复查,未切干净则中断告警 M->>A: 阶段6 遍历 appId/namespace/key,替换值中的 SAE 地址为 K8s 地址并发布 M->>A: 复查无残留 SAE 地址 M->>R: 成功应用写入 success 集合(5 天过期) M-->>X: 钉钉播报 成功/失败 应用清单

3. 技术栈

分类选型
语言/框架Java 8、Spring Boot(公司自研 boot-parent + web/redis/mybatis-plus/xxl-job starter)
任务调度xxl-job 2.2.0(全部核心逻辑以 @XxlJob handler 暴露)
云厂商 SDK阿里云 SAE sae20190506、云监控 CMS cms20190101 + aliyun-cms、ESS ess20220222、ECS ecs20140526、RDS rds20140815、OSS SDK、Flink foasconsole + ververica;腾讯云 TKE SDK
容器编排io.kubernetes:client-java(okhttp),直连自建集群与 TKE 的 ApiServer
网关/配置APISIX Admin API(HTTP + X-API-KEY)、Apollo OpenAPI(ApolloOpenApiClient)
中间件Redis(状态/快照/统计)、MySQL + MyBatis-Plus(明细落库)、Sentry(异常归集)
工具库fastjson2 + JSONPath(YAML 模板改写)、snakeyaml(YAML dump)、hutool(CSV/HTTP/日期)
告警钉钉机器人(文本/Markdown/@人)、阿里云 CMS 自定义事件 → 电话告警
其他抖店/千川 SDK(直播带货数据)、Docker 部署(自建 K8s/ECS)

代码规模约 1 万行 Java,包结构清晰:

com.xxx.cv.monitor
├── job/            # xxl-job 任务入口(迁移、扩缩容、监控、备份、业务巡检)
├── service/
│   ├── k8s/        # Deployment/Node/Pod 操作(client-java 封装)
│   ├── serverless/ # SAE 应用、实例、弹性策略、CPU 监控
│   ├── tke/        # 腾讯 EKS 集群凭证、公网开关、扩缩容
│   ├── flink/      # Flink 工作空间/队列资源
│   ├── apisix/     # 路由查询与 upstream 更新
│   ├── oss/ rds/   # 备份上传、慢日志采集
│   ├── ApolloService / EssService / EcsService / CmsService
├── controller/rest # 对外 REST(SAE 信息查询、手动扩容、电话告警上报)
├── dto/ po/ repository/  # 云 API 响应模型 与 数仓表映射
└── config/ enums/ util/ constant/

4. 核心模块一:SAE ⇄ K8s 一键互迁(重点)

入口:job/SaeAndK8sSwitchJob.java(saeSwitchToK8s / k8sSwitchToSae / saeAndK8sCycleSwitch / checkSaeInApisixConfig)

整体流程图:

https://file.blog.humh.cn/wp-content/uploads/2026/11/20261117184112909-1024x926.png

4.1 前置设计(让「迁移」退化为「调副本数 + 切流量」)

互迁之所以能做到分钟级,关键在于把所有重活都前置成了常态化的便宜动作:

  1. 镜像互通:SAE 与自建 K8s 使用同一套镜像仓库(同一镜像打两份部署),数据库、Redis 等中间件本就互通,应用配置统一放 Apollo——迁移不涉及打包和数据搬迁;
  2. Deployment 预建:每个可能迁移的应用,提前在 K8s 以极小副本数常驻(pod 规格 ≥ SAE 规格),ConfigMap/探针/env 全部提前就位——迁移时只调 replicas;
  3. Deployment 模板自动生成:手写几十个 YAML 不现实,SaeService#configTransToK8sYaml 直接读取 SAE 的 DescribeApplicationConfig,用 fastjson2 JSONPath 按路径覆写 K8s YAML 模板(sae_2_k8s_template.yaml)中的应用名、镜像、启动命令、资源规格(SAE 毫核/MB → K8s 核/Gi)、就绪/存活探针、ConfigMap 挂载、env(模板已有则覆写值、没有则追加),无健康检测的应用连 Service 都自动省略,最后 snakeyaml dump 出 Deployment + NodePort Service;
  4. 节点隔离:迁移专用 ESS 伸缩组购买的 ECS 通过脚本自动装 K8s 环境并 add node,节点打上 sae=true 污点(NoSchedule)+ deployment 侧配 nodeAffinity——新节点只跑迁移应用,不干扰集群其他业务;
  5. 地址映射表:sae_k8s_host_port.csv(app_name, sae_host, sae_port, k8s_host, k8s_port)维护每个应用在两套环境的访问坐标,是切流的唯一事实源。
https://file.blog.humh.cn/wp-content/uploads/2026/11/20261117185028921-819x1024.png
SAE应用配置自动转化K8s YAML模板(部分代码)

4.2 幂等与状态机(可重复执行、断点续跑)

迁移是长流程,必须可重入。以 Redis Set 维护三个集合:

  • sae_to_k8s:success_app:已成功迁到 K8s 的应用(5 天过期);
  • sae_to_k8s:doing_app / k8s_to_sae:doing_app:两个方向「正在进行中」的应用;

每轮触发时:入参(或 Apollo 配置)指定的应用列表,先剔除已完成、任一方向进行中的应用,剩下的才进入本轮;任务结束(无论成败)从 doing 集合移除。效果:

  • 任务失败重跑 → 已成功的应用自动跳过,只补失败的应用;
  • 同一批应用不会在两个方向同时被操作;
  • 回迁任务只处理 success_app 里记录的应用——即只回迁「本脚本迁出去的」,不会碰人工部署在 K8s 的服务。
// saeSwitchToK8s 的过滤逻辑(节选)
Set<String> nowSwitchApps = parseParamsOrDefault();           // 手动传参 或 Apollo 配置
nowSwitchApps.removeAll(members(SAE_SWITCH_K8S_SUCCESS_SET_K)); // 跳过已完成
nowSwitchApps.removeAll(members(SAE_SWITCH_K8S_DOING_SET_K));   // 跳过迁移中
nowSwitchApps.removeAll(members(K8S_SWITCH_SAE_DOING_SET_K));   // 跳过回迁中

4.3 阶段 1:资源测算——「买多少台 ECS、扩多少副本」

每小时执行的 saeUsedResourceStat 任务把 SAE 全部应用的 (实例数, CPU 核, 内存 Gi) 明细和总量写入 Redis Hash(按 日期→小时 存储,7 天过期)。迁移时:

  • 取昨日同时段前后 2 小时(now-26h ~ now-22h)窗口内每个应用的最大实例数——用历史峰值而不是瞬时值,避免迁过去容量不足;
  • 查不到统计的应用,兜底用 SAE 当前实时配置(并钉钉提示);
  • 需要购买的 ECS 台数:⌈Σ(CPU核×实例数) × 1.6 ÷ 32⌉(伸缩组节点固定 32C64G;1.6 为经验冗余系数;内存一般为 CPU 两倍故不再单独计算)。
// [阶段1] 资源测算(节选)
double switchNeedCpuSum = saeCpuSum * 1.6;
int needInstanceCnt = new BigDecimal(switchNeedCpuSum)
        .divide(new BigDecimal(32), 0, RoundingMode.CEILING).intValue();

4.4 阶段 2:ESS 扩容节点——「改 + 查」分离

所有云资源操作都遵循 check → modify → loop check 三段式:先查当前状态是否已满足(幂等),不满足才修改,改完循环校验(3 轮、每轮 60s),超限即钉钉告警并中断任务。

ESS 的坑:只有开启了「预期实例数(DesiredCapacity)」的伸缩组才能直接改数量,因此代码里同时设置 MinSize = DesiredCapacity = N 并前置校验:

// EssService.modifyEcsInstanceCnt(节选)
if (!scalingGroup.getEnableDesiredCapacity()) {
    throw new RuntimeException("only support modify already enabled desiredCapacity");
}
ModifyScalingGroupRequest req = new ModifyScalingGroupRequest()
        .setScalingGroupId(scalingGroupId)   // <迁移专用伸缩组ID,已脱敏>
        .setMinSize(instanceCnt)
        .setDesiredCapacity(instanceCnt);
essClient.modifyScalingGroupWithOptions(req, runtime);  // SDK 级自动重试 2 次

4.5 阶段 3:K8s 副本扩容——client-java 的调用学问 ⭐

这是整个项目里「K8s 调用最有学问」的部分,几个设计点:

① 多集群客户端枚举化,支持凭证热加载。 自建集群用打包进 jar 的 kubeconfig 初始化;腾讯 TKE 的 kubeconfig 每次操作前实时拉取并反射替换枚举持有的 CoreV1Api/AppsV1Api(见 K8sEnum#reloadK8sConfig)——因为 TKE 出于安全默认关闭公网访问,凭证是临时开具的(详见模块三)。

import cn.hutool.core.util.StrUtil;
import io.kubernetes.client.openapi.ApiClient;
import io.kubernetes.client.openapi.apis.AppsV1Api;
import io.kubernetes.client.openapi.apis.CoreV1Api;
import io.kubernetes.client.util.ClientBuilder;
import io.kubernetes.client.util.KubeConfig;
import io.sentry.Sentry;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;

import java.io.*;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Path;

@Slf4j
@Getter
public enum K8sEnum {

    /**
     * 阿里云自建k8s
     */
    COLORV("k8s_config.yaml"),
    /**
     * 腾讯云TKE
     */
    TKE("");

    final String configFileName;
    final CoreV1Api coreV1Api;
    final AppsV1Api appsV1Api;

    K8sEnum(String configFileName) {
        this.configFileName = configFileName;
        CoreV1Api tmpCoreV1Api = null;
        AppsV1Api tmpAppsV1Api = null;
        if (StrUtil.isNotEmpty(configFileName)) {
            try {
                ApiClient apiClient = buildK8sClient(configFileName);
                tmpCoreV1Api = new CoreV1Api(apiClient);
                tmpAppsV1Api = new AppsV1Api(apiClient);
            } catch (IOException e) {
                Sentry.captureException(e);
            }
        }
        coreV1Api = tmpCoreV1Api;
        appsV1Api = tmpAppsV1Api;
    }

    private static ApiClient buildK8sClient(InputStream inputStream) throws IOException {
        InputStreamReader streamReader = new InputStreamReader(inputStream);
        ApiClient apiClient = ClientBuilder.kubeconfig(KubeConfig.loadKubeConfig(streamReader)).build();
        streamReader.close();
        return apiClient;
    }

    private static ApiClient buildK8sClient(String resourceConfigFileName) throws IOException {
        InputStream resourceInputStream = K8sEnum.class.getClassLoader().getResourceAsStream(resourceConfigFileName);
        return buildK8sClient(resourceInputStream);
    }

    private static ApiClient buildK8sClient(File configFile) throws IOException {
        return buildK8sClient(new FileInputStream(configFile));
    }

    public void reloadK8sConfig(String k8sConfigContent) throws IOException, NoSuchFieldException, IllegalAccessException {
        log.info("reload {} k8s config, content -> {}", this, k8sConfigContent);
        Path tempFile = null;
        try {
            tempFile = Files.createTempFile("k8s_config_" + System.currentTimeMillis(), ".yaml");
            Files.write(tempFile, k8sConfigContent.getBytes());
            ApiClient newApiClient = K8sEnum.buildK8sClient(tempFile.toFile());
            Field coreV1ApiField = K8sEnum.class.getDeclaredField("coreV1Api");
            Field appsV1ApiField = K8sEnum.class.getDeclaredField("appsV1Api");

            coreV1ApiField.setAccessible(true);
            appsV1ApiField.setAccessible(true);

            coreV1ApiField.set(this, new CoreV1Api(newApiClient));
            appsV1ApiField.set(this, new AppsV1Api(newApiClient));
        } finally {
            if (tempFile != null) {
                Files.delete(tempFile);
            }
        }
   }

}

② 副本数用 JSON Patch 而不是整对象替换。 只改一个字段就只 PATCH 一个字段,避免读-改-写竞态覆盖掉其他字段的并发变更:

// DeploymentService.modifyMinReplicas(节选)
String patchJson = "[{\"op\":\"replace\",\"path\":\"/spec/replicas\",\"value\":" + replicas + "}]";
V1Deployment newDeployment = PatchUtils.patch(
        V1Deployment.class,
        () -> appsV1Api.patchNamespacedDeployment(name, ns, new V1Patch(patchJson))
                        .buildCall(null),
        V1Patch.PATCH_FORMAT_JSON_PATCH,
        appsV1Api.getApiClient());

③ 「副本数达标」要同时看四个字段。 只看 spec.replicas 是不够的——那是”期望”,不是”就绪”:

// DeploymentService.checkMinReplicas(节选,语义上为"至少/至多达到 N")
Integer specReplicas     = deployment.getSpec().getReplicas();       // 期望副本
Integer statusReplicas   = deployment.getStatus().getReplicas();     // 已调度副本
Integer availableReplicas = deployment.getStatus().getAvailableReplicas(); // 可用副本
Integer readyReplicas    = deployment.getStatus().getReadyReplicas();       // Ready 副本
// 期望值已满足 && (可用副本达标 || 可用+Ready 达标——Ready 计入"在路上")

扩缩方向用 TargetNumCompareEnum(LEAST / MOST / EQUALS)统一表达:扩容校验「至少 N」,缩容校验「至多 N」,同一套代码服务正反两个流程。

public enum TargetNumCompareEnum {

    /**
     * 至少,最小值
     */
    LEAST,
    /**
     * 相等,恒等值
     */
    EQUALS,
    /**
     * 至多,最大值
     */
    MOST;

    public boolean assertTrue(int expectedNum, int actualNum) {
        switch (this) {
            case LEAST:
                return expectedNum <= actualNum;
            case MOST:
                return expectedNum >= actualNum;
            case EQUALS:
                return expectedNum == actualNum;
            default:
                return false;
        }
    }

}
https://file.blog.humh.cn/wp-content/uploads/2026/11/20261117232335155-1024x469.png
TargetNumCompareEnum 部分应用示意

通过枚举的封装就能完成同一套通用代码对不同数据关系的处理。

④ 每个应用一个检查线程,整体限时。 不同 deployment 的 pod 从创建到 Ready 耗时不同(实测 90~120s),检查用 Executors.newFixedThreadPool(appCount) 并发进行(3 轮 × 50s),awaitTermination(5, MINUTES) 兜底防悬挂。

⑤ 404 是业务分支不是异常崩溃。 deployment 未创建时 client-java 抛 ApiException,被捕获记入 errorApps(钉钉播报该应用失败),不影响其余应用继续迁移——单应用失败不阻断整体流程,失败应用下轮重跑。

4.6 阶段 4:SAE「禁止缩容」

切流期间若 SAE 弹性策略因流量下降触发缩容,回迁时就无实例可切。因此在切流前把每个应用弹性策略的缩容开关 ScaleDownRules.Disabled 置为 true(对应 SAE 控制台的「缩容保护/观察」开关),回迁时再关闭。该项改的是策略布尔位、无状态延迟,故不做二次 check。

4.7 阶段 5:APISIX 灰度切流(外部流量)

背景:外部域名流量统一从 APISIX 进来,路由 upstream 的 nodes 即后端节点列表(host/port/weight)。

路由反查缓存:切流前异步执行 recordApisixRoute()——拉取 APISIX 全量路由,写入两个 Redis Hash:routeId → nodes 和 host:port → routeIds(一个后端可能被多条路由引用,必须全部切)。这样切流时可以 O(1) 定位「动哪些路由」,而不用反复全量拉取。

秒级灰度:避免 100% 流量瞬间打到冷启动的 K8s pod 造成过载,60 秒内按时间表阶梯切权重:

// 秒 → K8s 目标权重的灰度曲线(首切 1%,前慢后快)
Map<Integer, Integer> ROUTE_SECOND_WEIGHT_CONFIG = ImmutableMap.of(
        0, 1, 15, 10, 30, 30, 40, 60, 50, 80, 60, 100);

实现为一个按秒推进的 while 循环:根据已流逝秒数算出当前应切权重 w,与上一轮不同才发起更新;若某次更新因 API 慢导致「时刻已过」,直接跳到当前时刻对应的更高权重(不回补)。最终支持通过配置 to_k8s_weight 只切部分流量(如 20%)做验证。

https://file.blog.humh.cn/wp-content/uploads/2026/11/20261118000153202-1024x442.png
apisix灰度切换

权重更新的坑:APISIX 的 PATCH 无法用 weight: null 删除节点(报 object matches none of the required),必须提交裁剪后的完整节点列表——旧节点降权(100 - w)、新节点加权,非本次切换的节点原样带回。所有路由的更新通过线程池并发执行(CompletableFuture.allOf 汇聚)。

终态语义:中间某次灰度更新失败可以容忍(下次循环会重试),只有最终权重(100%)的更新成功才算该路由成功;之后全量拉取一遍路由做复查,存在「未切干净」的路由则任务失败中断。

4.8 阶段 6:Apollo 切流(内部 RPC 流量)

内部服务间 RPC 的目标地址配置在 Apollo(值形如 {"cv-video": "http://<app>.colorv.xxx:xxxx"})。切流逻辑:

  1. 遍历配置指定的 appId → namespace → keys(每个 appId 在 Apollo 开放平台各有一个 token,预注册在管理员后台);
  2. 读出 key 的 JSON 值,逐项解析出 host:port,命中 switchMap(SAE 坐标 → K8s 坐标)的才替换,其余地址原样保留;
  3. 有变更才 updateItem + publishNamespace(发布后客户端秒级生效,因此 APISIX 切流期间服务已预热,此处无需再灰度);
  4. 复查:所有 key 的值中不允许再出现任何 SAE 源地址,有残留即失败中断。

4.9 回迁(K8s → SAE):严格镜像逆序

APISIX 切 100% 至 SAE → Apollo 切回 → 关闭 SAE 禁止缩容
→ K8s 副本数调至 0(保留 deployment 骨架热备)
→ 检查 sae=true 标签节点上无残留应用 pod → ESS 缩容至 0 释放节点 → 钉钉播报

两个保护性细节:

  • 释放前 pod 残留检查:ECS/node/pod 三者对应关系未知,无法精准下线单台;因此先 listNode(labelSelector="sae=true") 再逐 node 列 pod,若仍有应用 pod 在跑就放弃释放并钉钉告警——宁可多花钱,不可误杀;
  • 回迁范围收敛:只回迁 success_app 集合中记录的应用(即本脚本迁出的),防止误伤原生的 K8s 服务。

4.10 轮回演练(saeAndK8sCycleSwitch)

saeSwitchToK8s(app);                 // SAE → K8s
// 等待 5 分钟(期间持续校验开关状态)观察链路
k8sSwitchToSae(app);                 // K8s → SAE

定期(xxl-job 调度)对指定应用执行完整往返,验证「节点购买 → 加入集群 → 副本扩容 → 双向切流 → 资源释放」全链路随时可用——灾备通道不演练,等于没有灾备。

另有 checkSaeInApisixConfig 巡检任务:扫描 APISIX 全量路由,发现「权重为 0 的废弃节点」或「疑似直接用 SAE 内网 IP 配置的节点」(通过 10.x.x.x 网段 + 端口反查映射表识别)即钉钉告警,防止切流映射失配。


5. 核心模块二:SAE 时段化动态扩缩容

入口:job/ServerlessJob#saeScalingRuleChange + service/serverless/ScalingRuleService
场景:比赛/活动前按时间窗自动抬高一批服务的最小实例数(或 CPU 目标值),结束后自动回滚原策略。

5.1 配置模型

配置存于 Apollo,由本地工具类 SaeScalingRuleJsonGen 生成(含注释校验说明):

[{
  "begin_time": "2024-03-30 12:00:00",
  "end_time":   "2024-03-30 14:00:00",
  "reduce_begin_time": "11:00",        // 可选:窗口内的缩容小时段(如夜间低峰)
  "reduce_end_time":   "13:00",
  "app_config": [
    {"app_name": "<app-a>", "cpu": "60", "min_replicas": "4", "scale_reduce_disabled": "false"},
    {"app_name": "<app-b>", "min_replicas": "4"}
  ]
}]

cpu / min_replicas / scale_reduce_disabled 三项任意组合;全空则默认按 cpu=60 扩。

5.2 执行状态机

flowchart LR
    A["xxl-job触发"] --> B{"当前时间在
begin-60min之后?"} B -- 否 --> Z1["跳过
(提前1小时开始扩)"] B -- 是 --> C{"在end+60min之后?"} C -- 是 --> D["回滚:策略恢复为快照
并删除快照"] C -- 否 --> E{"在配置的
reduce时段内?"} E -- 是 --> F["回滚至快照
并标记rollback"] E -- 否 --> G["扩容:首次先存快照
再改写策略"] G --> H{"check:
规则值+运行实例数
均已达标?"} H -- 是 --> I["跳过
(已扩成功)"] H -- 否 --> J["再次扩容+钉钉告警
(二次扩容提示)"]

关键设计:

  • 快照先行:首次扩容前把当前弹性策略完整存入 Redis Hash(sae:scaling_rule_snapshot,过期时间 = 结束时间 + 5 天),回滚 = 按快照全量恢复——无论扩容过程改了多少字段,原状都可精确还原;
  • 只扩不缩:配置的最小实例数小于当前值时直接拒绝并告警(禁止缩容),防止把线上 HA 打低;
  • check 双保险:不仅校验策略里的 MinReplicas 已改成功,还校验运行实例数已实际扩上去(防止「改了规则但实例还没拉起」被误判成功,也防止扩容前流量突峰又缩回去的窗口期);
  • 防重复回滚误报:reduce 时段回滚后打 rollback 标记(23h 过期),该窗口内再次触发回滚不算「二次扩容失败」。

5.3 SAE 弹性策略 API 的坑(前车之鉴)

这是与 SAE OpenAPI 搏斗后沉淀的规则,全部写进了 updateAppScalingRule 的注释里:

  1. MetricsStatus 字段勿传(只读状态字段);
  2. 混合伸缩(mix = 监控伸缩 + 定时伸缩)下,无论改哪一侧,两侧全部指标必须按原值完整回传,传空会清掉另一侧配置。所以改最小实例数时必须同步遍历 Timer.Schedules 把每个时刻的 MinReplicas 一并覆盖——否则到了定时点实例数会被「弹」回去;
  3. 监控伸缩类型下时间伸缩参数可传空字符串(非 null);
  4. 伸缩类型不可修改,只能删除重建(因此脚本显式拒绝 timing 类型应用);
  5. 时间伸缩的时间段是半闭半开区间,要衔接时段需配置 16:40-17:00 + 17:00-22:00 这样的相邻对。

对应 SAE 控制台上的策略形态(截图):

https://file.blog.humh.cn/wp-content/uploads/2026/11/20261118001409624-1024x81.png

5.4 配套支撑任务(同为 xxl-job)

任务作用
saeUsedResourceStat每小时统计全 SAE 应用资源用量入 Redis(同时服务模块一的迁移测算)
saeAppNameAndOtherRecord应用名↔AppId、SLS 日志配置缓存入 Redis(7 天)
mapInstanceIpToAppNameJobSAE 实例容器 IP → 应用名映射(pipeline 批量写入,7 天过期)——慢 SQL 来源归因的数据底座
saeLimitMonitor低 CPU 利用率(可白名单豁免)与 beta 环境资源超标巡检,钉钉表格告警
saeAppStartForDuration低价值应用时段停启:夜间 CPU 均值 < 8% 才允许停用;停用前保存其弹性策略启用状态,启用时精确恢复(支持跨零点时段、begin 前 30 分钟预热)

6. 核心模块三:腾讯云 TKE 定时扩容(安全设计)

入口:job/TkeJob + service/tke/*

与 SAE 模块同构(时间窗 + 快照回滚),但操作对象换成 TKE EKS 集群的 Deployment 副本数(应用名支持 namespace.deployment 形式)。独到的安全设计:

https://file.blog.humh.cn/wp-content/uploads/2026/11/20261117234227199-1024x268.png
  • TKE 集群的 ApiServer 公网访问默认关闭(暴露面最小化)。每次扩容任务开始时:实时调用 DescribeEKSClusterCredential 检查公网 LB 状态 → 未开则先 UpdateEKSCluster 打开(绑安全组)→ 等 90s 生效 → 用最新 kubeconfig 热加载 K8sEnum.TKE 客户端 → 执行扩缩;
  • 所有应用回滚完成后,自动关闭公网访问;关闭失败钉钉告警。

即「用完即关的动态通道」:平时攻击面为零,操作窗口内通过 SDK 自动开门/关门。

7. 核心模块四:Flink 工作空间资源扩缩

入口:job/FlinkJob + service/flink/*

面向阿里云实时计算 Flink 版(VVR):按时间窗调整工作空间 → 项目空间 → 队列的资源规格(CPU,内存按 cpu × 4 联动)。同样采用快照回滚模型;额外注意点:三级资源逐级生效有依赖,调整本级前需等待上级调整生效(代码中固化 8s 间隔),否则修改会被拒绝。

8. 监控与告警体系

8.1 分层告警通道

级别通道触发场景
常规钉钉文本/Markdown(含 @手机号)各任务成功播报、失败告警、巡检异常
升级电话告警(阿里云 CMS 自定义事件 → 事件告警规则 → 电话)连续 3 次无 CPU 指标、或 2 小时内 ≥10 次异常(应用疑似宕机);早安打卡等 C 端功能不可用

电话告警同时暴露为 REST 接口 /cv_cloud_monitor/cms/phone_alert,供其他系统复用;节流逻辑(计数 + 时间窗)防止电话轰炸。

8.2 典型监控项

  • SAE CPU 利用率:低于阈值且实例数 > 下限且非白名单 → 资源浪费告警(表格逐应用列出实例数/CPU/利用率);
  • beta 环境资源限制:beta 应用 CPU 规格或实例数超限告警(测试环境成本控制);
  • OSS 桶容量:对比 7 日均值,增幅超阈值(如迁移任务异常产出)告警;
  • RDS 慢 SQL 来源定位(RdsJob + DBLogService):拉取 RDS DescribeSlowLogRecords 慢日志明细,从 HostAddress 解析来源 IP,反查 sae_instance_ip_to_name 映射还原为应用名,连同 SQL 文本、锁耗时、执行耗时、返回行数批量落库——把「哪个应用拖慢了数据库」从猜测变成可查询的数据;增量拉取以上次落库的最大执行时间为起点,避免重复。

8.3 对外 REST 接口(供公司内部其他系统调用)

接口作用
GET /cv_cloud_monitor/sae/sls_config?app_name=查应用 SLS 日志的 project/logstore(供日志平台跳转)
GET /cv_cloud_monitor/sae/all_app_name全量 SAE 应用名(带 Redis 缓存)
POST /cv_cloud_monitor/sae/scale_sae_app单应用手动扩容(只允许扩不允许缩,防误操作)
POST /cv_cloud_monitor/cms/phone_alert电话告警上报(通用)

9. 业务支撑类任务

以下任务属「贴合业务的胶水脚本」,技术含量低但覆盖了公司数据/业务保障闭环,在此仅列明做了什么:

  • 抖音直播带货数据拉取(ToutiaoJob):千川 token 刷新 → 遍历店铺/代理商/纵横组织三种主体下的广告主 → 拉取带货商品销量数据 → 同步数仓报表(配套抖店 SDK);
  • Superset 备份(SupersetJob):自建 Superset 为 docker 部署,每日执行备份脚本(ossutil)将关键数据上传 OSS 数仓路径;Zeppelin 备份同思路;
  • 青少年模式可用性检查(TeenagerJob):模拟开启/关闭青少年模式,并分别验证两种状态下直播功能正常,异常钉钉/电话告警;
  • 早安打卡可用性检查(VideoClockJob):消费 Python 侧维护的任务队列,验证打卡视频产出进度在时限内完成,超时升级电话告警。
https://file.blog.humh.cn/wp-content/uploads/2026/11/20261118002644762-1024x177.png

10. 可复用的设计要点与踩坑总结

10.1 方案层面

  1. 把灾难恢复做成「调参」而不是「部署」:镜像、配置、Deployment 骨架全部常态预置,故障时只做「扩副本 + 切流量」两个动作,才可能分钟级完成迁移;
  2. 南北向(网关权重)与东西向(配置中心地址)分离切换,且都要有「切后复查」——任何一侧残留都会造成流量黑洞;
  3. 灰度曲线可配置(权重时间表 + 最终权重上限),同一套代码支持全量迁移和小比例验证;
  4. 灾备通道要常态化演练(轮回切换),不演练的预案等于没有;
  5. 状态全部外置到 Redis 并设 TTL,进程无状态、任务天然可重入、可断点续跑;
  6. 按量资源「用完即释放」+ 释放前残留检查,成本与安全兼得。

10.2 工程层面(真实踩过的坑)

坑对策
APISIX PATCH 无法以 weight:null 删节点提交裁剪后的完整节点列表
SAE 混合伸缩改一侧会清空另一侧更新时全量回传两侧参数
K8s 副本「期望值」≠「可用值」四字段联合校验(spec/status/available/ready),Ready 计入在途
client-java 的 ApiException(如 404)会中断批处理单应用异常降级为 errorApps,不阻断其他应用
TKE 公网凭证会过期/关闭每次操作前实时拉取并热加载客户端
云 API 改完≠生效统一 check → modify → loop check 三段式 + 总超时兜底
切流中逢单次失败造成假失败终态语义:只认最终权重的更新结果
Flink 三级资源有生效依赖逐级调整并固定等待间隔

humh

文章作者

站长本人,一个憨批!

发表评论

textsms
account_circle
email

想你所想

企业内部云监控与云客制化自动运维平台
一套以「云产品 API 编排」为核心的自动化运维平台——统一纳管阿里云 SAE / ECS / ESS / RDS / OSS / Flink、腾讯云 TKE、自建 K8s、A…
扫描二维码继续阅读
2026-11-18