核心提要

边缘-云协同运维架构的核心目标是将算力与运维能力下沉至边缘节点，就近处理终端设备数据，减少数据回传云端的带宽消耗与传输延迟，同时通过云端统一管控边缘节点，实现“边缘自治 + 云端协同”的高效运维模式。

本实战以 AI 推理边缘服务（如工业质检、智能摄像头推理）为典型场景，基于 K3s（轻量级 K8s）+ KubeEdge + Prometheus + Grafana 技术栈，完整覆盖“边缘节点部署→边缘-云通信搭建→运维能力下沉→数据本地化处理→延迟优化”全流程，最终实现边缘数据处理延迟降低 80%+、云端带宽占用减少 70%+ 的目标，同时保障边缘节点的统一运维与监控。

一、场景与需求分析

1. 典型业务场景

• 终端设备：工业产线摄像头、智能传感器（产生实时图像/传感数据，要求毫秒级推理响应）；

• 边缘节点：部署在工厂/园区的小型服务器（算力有限，网络带宽低）；

• 云端：中心化数据中心（算力充足，负责全局管控、模型训练、日志聚合）；

• 核心痛点：终端数据全量回传云端处理，导致传输延迟高（＞200ms）、带宽成本高、断网时边缘服务不可用。

2. 核心需求

需求类型	具体要求
延迟优化	边缘数据本地化处理，推理延迟 ≤ 50ms，数据传输延迟降低 80%
运维协同	云端统一管理边缘节点（部署、监控、升级），边缘节点支持断网自治
带宽节省	仅回传边缘处理后的结果数据（而非原始数据），降低云端带宽占用
高可用	边缘节点故障时自动切换，云端实时监控边缘状态并告警

3. 技术栈选型

层级	工具选型	核心作用
边缘容器编排	K3s（轻量级 K8s）	边缘节点的容器化部署，资源占用低（仅需 512MB 内存）
边缘-云协同框架	KubeEdge	实现边缘与云端的双向通信、资源同步、部署协同，支持边缘自治
运维监控	Prometheus + Grafana + node-exporter	边缘节点本地监控 + 云端监控数据聚合，可视化展示延迟/负载指标
数据传输优化	NATS（边缘-云消息总线）+ 数据过滤规则	仅回传关键数据，压缩传输内容
AI 推理服务	ONNX Runtime + 轻量化模型	边缘节点本地化推理，降低数据传输需求

二、架构设计

1. 整体架构图

终端层（摄像头/传感器）→ 边缘层（K3s + KubeEdge EdgeCore + 推理服务 + 本地监控）→ 传输层（NATS + 数据过滤）→ 云端层（KubeEdge CloudCore + 全局管控 + 模型训练）

2. 核心分层职责

层级	核心职责
终端层	采集实时数据（图像/传感数据），推送至边缘节点
边缘层	1. 运行 AI 推理服务，本地化处理终端数据；2. 本地监控节点资源与服务状态；3. 断网时自治运行，缓存数据；4. 仅回传推理结果与异常数据
传输层	1. 基于 KubeEdge 隧道实现边缘-云双向通信；2. 按规则过滤数据，压缩传输内容；3. 断网后自动重连，同步缓存数据
云端层	1. 统一管控所有边缘节点（部署、升级、配置下发）；2. 聚合边缘监控数据，可视化展示；3. 训练 AI 模型，推送至边缘节点更新；4. 存储边缘回传的结果数据

三、环境准备

1. 节点规划

节点类型	配置	数量	操作系统	核心组件
云端节点	4C8G，公网 IP	1	Ubuntu 22.04	Docker、KubeEdge CloudCore、K3s Server、Prometheus、Grafana
边缘节点	2C4G，内网 IP	2	Ubuntu 22.04	Docker、KubeEdge EdgeCore、K3s Agent、推理服务、node-exporter

2. 基础环境配置（所有节点）

# 1. 关闭防火墙与 SELinux
sudo systemctl stop ufw && sudo systemctl disable ufw
sudo setenforce 0 && sudo sed -i 's/^SELINUX=.*/SELINUX=disabled/' /etc/selinux/config

# 2. 关闭 Swap
sudo swapoff -a && sudo sed -i '/swap/s/^/#/' /etc/fstab

# 3. 配置内核参数（开启 IP 转发）
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF
sudo sysctl --system

# 4. 安装 Docker
sudo apt-get update && sudo apt-get install -y docker.io
sudo systemctl start docker && sudo systemctl enable docker
sudo usermod -aG docker $USER && newgrp docker

四、操作步骤

步骤 1：部署云端管控平台

1. 安装 K3s Server（云端轻量级 K8s）

K3s 是轻量化 K8s，适合云端管控边缘节点，资源占用远低于原生 K8s：

# 安装 K3s Server，禁用内置 Traefik（避免端口冲突）
curl -sfL https://get.k3s.io | sh -s - --disable traefik --write-kubeconfig-mode 644

# 验证 K3s 状态
sudo kubectl get nodes
# 预期输出：节点状态为 Ready

2. 安装 KubeEdge CloudCore（边缘-云协同核心）

KubeEdge 是专为边缘计算设计的协同框架，CloudCore 部署在云端，负责管理边缘节点：

# 1. 安装 keadm（KubeEdge 部署工具）
curl -sfL https://raw.githubusercontent.com/kubeedge/kubeedge/master/scripts/install_keadm.sh | bash -

# 2. 初始化 CloudCore
keadm init --advertise-address="云端公网IP" --kube-config=/etc/rancher/k3s/k3s.yaml

# 3. 生成边缘节点接入令牌（保存，用于边缘节点接入）
TOKEN=$(keadm gettoken)
echo "边缘接入令牌：$TOKEN"

# 4. 验证 CloudCore 状态
kubectl get pods -n kubeedge
# 预期输出：cloudcore-xxx 状态为 Running

3. 部署云端监控与可视化

云端部署 Prometheus + Grafana，聚合所有边缘节点的监控数据：

# 1. 安装 Prometheus（使用 Helm 快速部署）
sudo snap install helm --classic
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm install prometheus prometheus-community/prometheus -n monitoring --create-namespace

# 2. 安装 Grafana
helm install grafana grafana/grafana -n monitoring

# 3. 暴露 Grafana 端口（测试环境，生产环境用 Ingress）
sudo kubectl port-forward svc/grafana 3000:80 -n monitoring --address 0.0.0.0

• 访问 Grafana：http://云端公网IP:3000，默认用户名 admin，密码通过以下命令获取：

  sudo kubectl get secret --namespace monitoring grafana -o jsonpath="{.data.admin-password}" | base64 --decode ; echo

步骤 2：部署边缘节点与边缘自治能力

1. 边缘节点安装 K3s Agent 与 EdgeCore

边缘节点接入云端，同时部署 K3s Agent 实现容器编排，EdgeCore 实现边缘-云协同：

# 1. 安装 K3s Agent（接入云端 K3s Server）
curl -sfL https://get.k3s.io | K3S_URL=https://云端公网IP:6443 K3S_TOKEN=云端K3s令牌 sh -

# 2. 安装 KubeEdge EdgeCore（使用云端生成的令牌接入）
keadm join --cloudcore-ipport="云端公网IP:10000" --token="$TOKEN"

# 3. 验证边缘节点状态（云端执行）
kubectl get nodes
# 预期输出：边缘节点状态为 Ready，标签包含 node-role.kubernetes.io/edge=true

2. 配置边缘自治能力

KubeEdge 支持边缘离线自治，断网时边缘节点仍能运行服务，缓存数据：

# 1. 在云端编辑边缘节点配置，启用离线自治
kubectl edit node 边缘节点名称

# 2. 添加以下注解（yaml 格式）
annotations:
  node.kubeedge.io/autonomy: "true"  # 启用边缘自治
  node.kubeedge.io/cached-core-images: "nginx:alpine,onruntime:1.15"  # 缓存核心镜像

# 3. 配置数据缓存目录（边缘节点执行）
sudo mkdir -p /var/lib/kubeedge/edge_cached_data
sudo chmod 777 /var/lib/kubeedge/edge_cached_data

• 核心作用：断网时，边缘服务不中断；数据缓存至本地目录，联网后自动同步至云端。

3. 部署边缘本地监控

边缘节点部署 node-exporter，采集本地资源指标（CPU、内存、网络延迟），优先本地存储，减少回传：

# 边缘节点部署 node-exporter（容器化方式）
docker run -d --name node-exporter \
  --net="host" \
  --pid="host" \
  -v "/:/host:ro,rslave" \
  quay.io/prometheus/node-exporter:latest \
  --path.rootfs=/host

# 配置 Prometheus 边缘采集规则（云端配置）
# 编辑 Prometheus ConfigMap，添加边缘节点采集任务，设置“本地存储 5 分钟数据，仅回传异常指标”

步骤 3：部署边缘 AI 推理服务，实现数据本地化处理

1. 边缘推理服务容器化（以 MNIST 推理为例）

编写推理服务 Dockerfile 与部署 YAML，实现边缘本地化推理：

（1）推理服务代码（edge-infer.py）

from flask import Flask, request, jsonify
import onnxruntime as ort
import numpy as np
import base64
from io import BytesIO
from PIL import Image
import os

app = Flask(__name__)
# 加载本地模型（避免每次请求下载）
MODEL_PATH = "/model/advanced_mnist_model.onnx"
ort_session = ort.InferenceSession(MODEL_PATH, providers=["CPUExecutionProvider"])

# 数据预处理
def preprocess(image_base64):
    img = Image.open(BytesIO(base64.b64decode(image_base64))).convert('L')
    img = img.resize((28,28))
    return np.expand_dims(np.expand_dims(np.array(img)/255.0, axis=0), axis=0).astype(np.float32)

# 推理接口（本地处理，不回传原始图像）
@app.route("/infer", methods=["POST"])
def infer():
    try:
        data = request.json
        img_base64 = data.get("image_base64")
        if not img_base64:
            return jsonify({"code":400, "msg":"缺少参数"})
        
        # 本地推理
        input_data = preprocess(img_base64)
        output = ort_session.run(None, {"input": input_data})
        pred = int(np.argmax(output[0]))
        
        # 仅回传推理结果（非原始图像）
        result = {"code":200, "pred":pred, "node_id":"edge-node-01", "timestamp":os.time()}
        
        # 断网时缓存结果
        if not check_cloud_connectivity():
            with open("/var/lib/kubeedge/edge_cached_data/result.json", "a") as f:
                f.write(f"{result}\n")
        
        return jsonify(result)
    except Exception as e:
        return jsonify({"code":500, "msg":str(e)})

# 检查云端连通性
def check_cloud_connectivity():
    try:
        import requests
        requests.get("https://云端公网IP:10000", timeout=2)
        return True
    except:
        return False

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

（2）Dockerfile

FROM python:3.9-slim
WORKDIR /app
COPY edge-infer.py .
COPY advanced_mnist_model.onnx /model/
RUN pip install flask onnxruntime pillow numpy requests -i https://pypi.tuna.tsinghua.edu.cn/simple
EXPOSE 5000
CMD ["python", "edge-infer.py"]

（3）边缘部署 YAML（edge-infer-deploy.yaml）

apiVersion: apps/v1
kind: Deployment
metadata:
  name: edge-infer-service
  namespace: edge
spec:
  replicas: 1
  selector:
    matchLabels:
      app: edge-infer
  template:
    metadata:
      labels:
        app: edge-infer
    spec:
      nodeSelector:
        node-role.kubernetes.io/edge: "true"  # 仅部署在边缘节点
      containers:
      - name: edge-infer
        image: 你的镜像仓库/edge-infer:v1.0
        ports:
        - containerPort: 5000
        volumeMounts:
        - name: edge-cache
          mountPath: /var/lib/kubeedge/edge_cached_data
      volumes:
      - name: edge-cache
        hostPath:
          path: /var/lib/kubeedge/edge_cached_data
---
apiVersion: v1
kind: Service
metadata:
  name: edge-infer-service
  namespace: edge
spec:
  type: NodePort
  selector:
    app: edge-infer
  ports:
  - port: 5000
    targetPort: 5000
    nodePort: 30001

2. 部署推理服务到边缘节点

# 1. 构建并推送镜像
docker build -t 你的镜像仓库/edge-infer:v1.0 .
docker push 你的镜像仓库/edge-infer:v1.0

# 2. 云端创建边缘命名空间
kubectl create namespace edge

# 3. 部署服务（云端执行，自动同步至边缘）
kubectl apply -f edge-infer-deploy.yaml

# 4. 验证部署状态（边缘节点执行）
docker ps | grep edge-infer
# 预期输出：edge-infer 容器运行中

3. 测试边缘推理延迟

终端设备向边缘节点发送请求，测试本地化推理延迟：

# 终端设备执行 curl 请求
time curl -X POST http://边缘节点IP:30001/infer \
  -H "Content-Type: application/json" \
  -d '{"image_base64": "你的测试图像base64编码"}'

• 预期结果：推理响应时间 ≤ 50ms，对比全量回传云端的 200ms+，延迟降低 75% 以上。

步骤 4：边缘-云数据传输优化，降低延迟

1. 数据过滤与压缩

核心原则：仅回传关键数据，压缩传输内容，避免原始数据全量回传：

• 过滤规则：只回传推理异常结果（如识别失败、异常数据）和统计指标（如推理成功率、延迟均值），正常结果本地存储；

• 压缩方式：使用 Gzip 压缩回传数据，降低传输体积；

• 实现方式：在边缘推理服务中添加数据过滤与压缩逻辑，示例代码片段：

  import gzip
  import json
  
  # 数据过滤：仅回传异常结果
  def filter_data(result):
      if result["code"] != 200:  # 异常结果
          return result
      # 正常结果每 100 条统计一次均值回传
      global count, total_pred_time
      count +=1
      total_pred_time += result["pred_time"]
      if count >=100:
          stats = {"node_id":"edge-node-01", "avg_pred_time":total_pred_time/100, "count":100}
          count, total_pred_time = 0, 0
          return stats
      return None
  
  # 数据压缩
  def compress_data(data):
      if not data:
          return None
      return gzip.compress(json.dumps(data).encode("utf-8"))

2. 优化边缘-云通信协议

KubeEdge 默认使用 HTTPS 通信，可优化为 NATS（轻量级消息总线），降低通信延迟：

# 1. 云端安装 NATS 服务器
helm repo add nats https://nats-io.github.io/k8s/helm/charts/
helm install nats nats/nats -n kubeedge

# 2. 配置 EdgeCore 使用 NATS 通信（边缘节点编辑配置）
sudo vi /etc/kubeedge/config/edgecore.yaml
# 修改以下配置
mqtt:
  mode: "nats"
  nats:
    server: "nats://云端公网IP:4222"
    user: "nats-user"
    password: "nats-password"

# 3. 重启 EdgeCore
sudo systemctl restart edgecore

• 优化效果：通信延迟降低 30%+，支持消息批量发送，减少连接开销。

3. 带宽占用对比测试

传输方案	原始数据量	回传数据量	带宽占用	传输延迟
全量回传云端	100MB/分钟（原始图像）	100MB/分钟	8Mbps	200ms+
边缘处理+结果回传	100MB/分钟（原始图像）	1MB/分钟（统计结果）	0.08Mbps	20ms
优化率	-	99% 减少	99% 降低	90% 降低

步骤 5：边缘-云协同运维与监控

1. 云端统一部署与升级边缘服务

通过 KubeEdge 实现边缘服务的一键部署与滚动升级，无需逐个登录边缘节点：

# 1. 升级边缘推理服务镜像版本（云端执行）
kubectl set image deployment/edge-infer-service edge-infer=你的镜像仓库/edge-infer:v1.1 -n edge

# 2. 查看升级状态（云端执行）
kubectl rollout status deployment/edge-infer-service -n edge

• 核心优势：支持灰度升级，先升级 1 个边缘节点验证，再批量升级，避免全网故障。

2. 边缘节点监控与告警

通过 Grafana 可视化边缘节点的资源负载、推理延迟、带宽占用，配置告警规则：

1. 导入 Grafana 边缘监控仪表盘：使用模板 ID 1860（Node Exporter Full），适配边缘节点监控；

2. 配置告警规则：

   1. 边缘节点 CPU 使用率＞80% 时告警；

   2. 推理延迟＞50ms 时告警；

   3. 边缘节点断网超过 5 分钟时告警；

3. 告警通知渠道：配置企业微信/短信告警，确保运维人员及时响应。

3. 边缘日志聚合与故障排查

边缘节点日志优先本地存储，异常日志自动回传云端，使用 ELK 栈聚合分析：

• 边缘侧：使用 Filebeat 采集容器日志，本地存储 7 天日志，仅回传 ERROR 级别日志；

• 云端侧：部署 ELK 栈，聚合所有边缘节点的异常日志，支持按节点/时间/日志级别检索；

• 故障排查流程：云端查看异常日志→定位边缘节点→远程登录边缘节点（KubeEdge 支持云端远程命令执行）→排查问题。

四、长效优化与生产环境建议

1. 算力下沉优化

• 边缘节点算力分层：根据业务需求，将边缘节点分为“轻量边缘”（2C4G）和“重型边缘”（8C16G），重型边缘运行复杂推理任务；

• 模型轻量化：使用模型量化（INT8）、剪枝技术，减小模型体积，提升边缘推理速度。

2. 高可用优化

• 边缘节点集群化：同一区域部署多个边缘节点，使用 K3s 集群实现服务高可用，节点故障时自动切换；

• 云端容灾：部署多地域云端节点，避免单云端故障导致边缘节点失控。

3. 安全优化

• 边缘节点身份认证：使用 KubeEdge 的证书机制，确保只有授权边缘节点才能接入云端；

• 数据加密：边缘-云传输数据使用 TLS 加密，本地缓存数据使用 AES 加密；

• 权限管控：边缘节点仅开放必要端口，云端管控平台使用 RBAC 权限控制。

五、核心经验总结

1. 边缘自治是核心：断网自治能力是边缘-云协同架构的关键，需确保边缘服务在离线状态下正常运行，数据不丢失；

2. 数据本地化处理是降延迟的关键：将推理、过滤等算力密集型任务下沉至边缘，仅回传结果数据，从源头减少传输延迟与带宽消耗；

3. 云端统一管控是运维效率的保障：通过 KubeEdge 实现边缘节点的统一部署、升级、监控，避免“孤岛式”运维；

4. 通信协议与数据压缩是优化细节：选择轻量级通信协议（如 NATS），配置合理的数据过滤规则，进一步降低延迟与带宽占用。

附：常见问题排查

1. 边缘节点无法接入云端：检查云端防火墙是否开放 10000/6443 端口、边缘节点令牌是否正确、网络是否连通；

2. 边缘服务离线后无法自治：检查 node.kubeedge.io/autonomy 注解是否设置为 true、核心镜像是否缓存；

3. 传输延迟未达标：检查数据过滤规则是否生效、通信协议是否为 NATS、边缘节点是否部署在终端设备附近；

4. 监控数据未聚合：检查 Prometheus 是否配置边缘节点采集任务、node-exporter 是否正常运行。