边缘智能科研入门

深色模式

L6 Kubernetes 与调度 ​

目标 ​

  • 理解 Kubernetes（K8s）的核心概念；
  • 先用 kind 在一台机器上搭学习集群，再了解用 kubeadm 搭真实集群的步骤；
  • 在 K8s 上部署一个使用 GPU 的大模型推理服务；
  • 用 Python 写一个最简单的自定义调度器。这是方向四做调度研究的起点。

核心概念 ​

概念说明
Node集群里的一台机器，分为控制平面节点和工作节点
Pod最小的调度单位，包含一个或多个容器
Deployment声明“我要几个这样的 Pod”，K8s 负责创建、替换、滚动升级
Service给一组 Pod 一个固定的访问入口，并做负载均衡
PV / PVC持久化存储：PV 是存储资源，PVC 是 Pod 对存储的申请
Namespace资源的逻辑分组
kube-scheduler决定每个 Pod 放到哪个节点上，这是调度研究最直接的切入点
kubelet每个节点上的代理，负责真正启动容器

推荐先读 Kubernetes 官方文档（中文）的“概念”部分。

第 1 步：用 kind 搭学习集群 ​

kind 用 Docker 容器模拟 K8s 节点，几分钟就能在一台机器上起一个多节点集群，弄坏了删掉重建即可。

按官方文档安装 kind 和 kubectl 后，写一个三节点集群配置 kind-config.yaml：

yaml
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
  - role: control-plane
  - role: worker
  - role: worker
bash
kind create cluster --name lab --config kind-config.yaml
kubectl get nodes                                    # 应该看到 3 个节点

kubectl create deployment web --image=nginx --replicas=3
kubectl get pods -o wide                             # 看每个 Pod 被调度到哪个节点
kubectl expose deployment web --port=80 --type=NodePort
kubectl scale deployment web --replicas=5            # 扩容
kubectl describe pod <pod名>                          # 查看事件，排错时最常用
kubectl logs <pod名>

kind delete cluster --name lab                       # 用完删除

也可以用 k3s（轻量级 K8s，适合边缘设备）或 minikube。

第 2 步：用 kubeadm 搭真实集群 ​

多台物理机或虚拟机组成真实集群时用 kubeadm。步骤较多，以官方文档为准，下面是主要流程（Ubuntu，截至 2026 年 10 月最新稳定版本为 1.37，安装前到官网确认当前版本）：

1. 每个节点：准备系统

bash
sudo swapoff -a                          # 关闭 swap，并注释掉 /etc/fstab 里的 swap 行
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF
sudo modprobe overlay && sudo modprobe br_netfilter
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
EOF
sudo sysctl --system

2. 每个节点：安装容器运行时 containerd

K8s 不再直接使用 Docker 作为容器运行时，改用 containerd：

bash
sudo apt-get install -y containerd
sudo mkdir -p /etc/containerd
containerd config default | sudo tee /etc/containerd/config.toml
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml
sudo systemctl restart containerd

国内网络还需要把配置文件里的 pause 镜像（sandbox image）改成国内镜像地址。

3. 每个节点：安装 kubeadm、kubelet、kubectl

从 2023 年起，官方软件源换成了 pkgs.k8s.io，每个小版本一个源，旧的 apt.kubernetes.io 已停用：

bash
sudo apt-get update && sudo apt-get install -y apt-transport-https ca-certificates curl gpg
sudo mkdir -p -m 755 /etc/apt/keyrings
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.37/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.37/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list
sudo apt-get update && sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

下载慢可以换成清华镜像，按页面说明替换地址。

4. 控制平面节点：初始化集群

bash
sudo kubeadm init \
  --apiserver-advertise-address=<本机内网 IP> \
  --image-repository=registry.cn-hangzhou.aliyuncs.com/google_containers \
  --pod-network-cidr=10.244.0.0/16

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

--image-repository 让国内拉取控制平面组件镜像；--pod-network-cidr 要和下面的网络插件一致（Flannel 默认 10.244.0.0/16）。

5. 安装网络插件 Flannel

bash
kubectl apply -f https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml
kubectl get nodes      # 节点状态变为 Ready

节点一直 NotReady、报 cni config uninitialized，通常是网络插件没装好或者 pod 网段不一致。

6. 工作节点：加入集群

在控制平面节点上运行 kubeadm token create --print-join-command，把输出的命令复制到工作节点执行。

集群管理界面：Rancher 提供图形化的集群管理，可以导入已有集群。多节点共享模型文件时，可以用 NFS 作为持久卷。

第 3 步：GPU 与推理服务 ​

让 K8s 识别 GPU：推荐用 NVIDIA GPU Operator，它会自动安装设备插件、容器工具包和 GPU 监控：

bash
helm repo add nvidia https://helm.ngc.nvidia.com/nvidia && helm repo update
helm install --wait gpu-operator -n gpu-operator --create-namespace nvidia/gpu-operator
# 节点上已经装好显卡驱动时，加上 --set driver.enabled=false
kubectl describe node <节点名> | grep nvidia.com/gpu     # 能看到 GPU 数量说明成功

部署 vLLM：保存为 vllm.yaml，把 L1 的模型放在节点的 /data/models 下：

yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-qwen
spec:
  replicas: 1
  selector:
    matchLabels:
      app: vllm-qwen
  template:
    metadata:
      labels:
        app: vllm-qwen
    spec:
      containers:
        - name: vllm
          image: vllm/vllm-openai:latest
          args: ["--model", "/models/Qwen3-0.6B", "--served-model-name", "qwen3-0.6b"]
          ports:
            - containerPort: 8000
          resources:
            limits:
              nvidia.com/gpu: 1          # 申请 1 张 GPU
          volumeMounts:
            - name: models
              mountPath: /models
            - name: shm                  # 相当于 docker run 的 --ipc=host
              mountPath: /dev/shm
          readinessProbe:                # 模型加载完成后才接收流量
            httpGet:
              path: /health
              port: 8000
            initialDelaySeconds: 30
            periodSeconds: 10
      volumes:
        - name: models
          hostPath:
            path: /data/models
            type: Directory
        - name: shm
          emptyDir:
            medium: Memory
            sizeLimit: 4Gi
---
apiVersion: v1
kind: Service
metadata:
  name: vllm-qwen
spec:
  type: NodePort
  selector:
    app: vllm-qwen
  ports:
    - port: 8000
      targetPort: 8000
      nodePort: 30800
bash
kubectl apply -f vllm.yaml
kubectl get pods -w                      # 等待 READY 变为 1/1
curl http://<任一节点 IP>:30800/v1/models

hostPath 要求模型文件在 Pod 所在的节点上；多节点时改用 NFS 等共享存储的 PV。Service 类型用 LoadBalancer 需要集群有负载均衡器（云厂商或 MetalLB），自建集群用 NodePort 最简单。

第 4 步：写一个自定义调度器 ​

K8s 允许同时运行多个调度器，Pod 通过 schedulerName 指定由谁调度。下面用 Python 写一个调度器：监听指定给它的 Pod，选一个节点，然后把 Pod 绑定到该节点。

bash
uv pip install kubernetes
python
# my_scheduler.py
import random

from kubernetes import client, config, watch

SCHEDULER_NAME = "my-scheduler"
config.load_kube_config()
v1 = client.CoreV1Api()


def candidate_nodes():
    """就绪、可调度、没有 NoSchedule 污点的节点"""
    names = []
    for node in v1.list_node().items:
        ready = any(c.type == "Ready" and c.status == "True" for c in node.status.conditions)
        tainted = any(t.effect == "NoSchedule" for t in (node.spec.taints or []))
        if ready and not tainted and not node.spec.unschedulable:
            names.append(node.metadata.name)
    return names


def choose_node(pod, nodes):
    # 在这里实现你的调度策略：比如从 Prometheus 读取各节点负载，选最空闲的；
    # 或者优先选已经缓存了该镜像层的节点
    return random.choice(nodes)


def bind(pod, node_name):
    body = client.V1Binding(
        metadata=client.V1ObjectMeta(name=pod.metadata.name),
        target=client.V1ObjectReference(api_version="v1", kind="Node", name=node_name),
    )
    # _preload_content=False 规避 Python 客户端解析 Binding 响应时的已知问题
    v1.create_namespaced_binding(pod.metadata.namespace, body, _preload_content=False)


for event in watch.Watch().stream(
    v1.list_pod_for_all_namespaces, field_selector=f"spec.schedulerName={SCHEDULER_NAME}"
):
    pod = event["object"]
    if event["type"] == "ADDED" and pod.status.phase == "Pending" and not pod.spec.node_name:
        node = choose_node(pod, candidate_nodes())
        bind(pod, node)
        print(f"{pod.metadata.namespace}/{pod.metadata.name} -> {node}")

运行调度器，然后创建一个指定它的 Pod：

yaml
# test-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  name: test-pod
spec:
  schedulerName: my-scheduler
  containers:
    - name: nginx
      image: nginx
bash
python my_scheduler.py            # 一个终端运行调度器
kubectl apply -f test-pod.yaml    # 另一个终端
kubectl get pod test-pod -o wide  # 看被调度到了哪个节点

练习：把 choose_node 改成“选当前 Pod 数最少的节点”，连续创建 10 个 Pod，和随机策略对比分布是否更均衡。再进一步，结合 L7 从 Prometheus 读取 CPU 和显存使用率做决策，或者把它接到强化学习的策略上。

在真实集群上比较调度策略又慢又费资源。研究中通常先在仿真器里比较，再挑出最好的策略到集群上验证。L9 层感知容器调度仿真就是这样一个仿真器，其中的“层共享 + 负载”打分可以直接搬到 choose_node 里：用 kubectl get nodes -o json 中每个节点的 status.images 字段可以知道节点上已有哪些镜像。

生产级调度器与前沿方向 ​

Python 调度器适合做原型和实验。正式的研究原型和对比对象通常是：

  • 调度框架（Scheduling Framework）：kube-scheduler 的插件机制，在 Filter、Score、Bind 等扩展点插入自己的逻辑，用 Go 编写。参考 scheduler-plugins。课题组的 LRScheduler（MSN 2024 最佳论文）也开源了实现。
  • 面向 AI 负载的批调度：Volcano（成组调度，国内使用广泛）、Kueue（作业排队）、KAI Scheduler（NVIDIA 开源的 GPU 调度器）。
  • GPU 资源的精细化分配：K8s 的动态资源分配（DRA）机制，以及 GPU 切分（MIG、时间片共享）。
  • K8s 上的大模型推理平台：llm-d、AIBrix、NVIDIA Dynamo，涉及请求路由、预填充与解码分离、KV Cache 感知调度、自动伸缩。

作者：崔涵帅、姚智、王振胜、唐志清 · 边缘智能系统实验室

内容许可待定