cgroup v2 完全指南：从架构原理到生产实践

/sys/fs/cgroup/          ← 统一挂载点（cgroup2 文件系统）
├── cgroup.controllers   ← 全局可用控制器列表
├── cgroup.subtree_control ← 子级启用的控制器
├── cpu.weight            ← CPU 权重
├── memory.max            ← 内存上限
├── io.max                ← IO 上限
├── system.slice/         ← systemd 系统服务
│   ├── nginx.service/
│   │   ├── cpu.max       ← Nginx 的 CPU 限制
│   │   └── memory.max    ← Nginx 的内存限制
│   └── docker.service/
├── user.slice/           ← 用户会话
└── myapp/                ← 自定义 cgroup
    ├── cpu.max
    ├── memory.max
    └── cgroup.procs      ← 该 cgroup 中的进程列表

# 查看 cgroup 文件系统挂载情况
mount | grep cgroup

# cgroup v2 输出示例：
# cgroup2 on /sys/fs/cgroup type cgroup2 (rw,nosuid,nodev,noexec,relatime,nsdelegate,memory_recursiveprot)

# cgroup v1 输出示例（多行）：
# tmpfs on /sys/fs/cgroup type tmpfs (ro,nosuid,nodev,noexec,mode=755)
# cgroup on /sys/fs/cgroup/systemd type cgroup (rw,nosuid,nodev,noexec,relatime,xattr,name=systemd)
# cgroup on /sys/fs/cgroup/cpu,cpuacct type cgroup (rw,nosuid,nodev,noexec,relatime,cpu,cpuacct)
# cgroup on /sys/fs/cgroup/memory type cgroup (rw,nosuid,nodev,noexec,relatime,memory)

# 查看可用的控制器
cat /sys/fs/cgroup/cgroup.controllers

# 输出示例：
# cpuset cpu io memory hugetlb pids rdma misc

# GRUB 配置（编辑 /etc/default/grub）
# 在 GRUB_CMDLINE_LINUX 中添加：
GRUB_CMDLINE_LINUX="systemd.unified_cgroup_hierarchy=1"

# 更新 GRUB 并重启
sudo update-grub    # Debian/Ubuntu
sudo grub2-mkconfig -o /boot/grub2/grub.cfg   # RHEL/CentOS
sudo reboot

# 重启后验证
mount | grep cgroup2

GRUB_CMDLINE_LINUX="systemd.unified_cgroup_hierarchy=0 systemd.legacy_systemd_cgroup_controller=yes"

# 创建 cgroup 并设置 CPU 权重
sudo mkdir /sys/fs/cgroup/myapp
echo "+cpu" > /sys/fs/cgroup/cgroup.subtree_control
echo 500 > /sys/fs/cgroup/myapp/cpu.weight   # 权重 500（默认 100 的 5 倍）

# 对比：v1 的 cpu.shares
# v1: echo 512 > /sys/fs/cgroup/cpu/myapp/cpu.shares
# v2: echo 500 > /sys/fs/cgroup/myapp/cpu.weight  (语义不同但效果类似)

# 假设两个 cgroup，权重分别为 100 和 300
cgroup_A: cpu.weight = 100  → 获得 100/(100+300) = 25% 的 CPU
cgroup_B: cpu.weight = 300  → 获得 300/(100+300) = 75% 的 CPU

# 当 CPU 空闲时，两者都可以使用超过分配比例的 CPU
# 仅在 CPU 竞争时，权重才生效

# 限制为单核 50% 的 CPU（每 100ms 周期内最多用 50ms）
echo "50000 100000" > /sys/fs/cgroup/myapp/cpu.max

# 解释：max=50000us, period=100000us → 50000/100000 = 50% 单核

# 限制为 2 个完整核心
echo "200000 100000" > /sys/fs/cgroup/myapp/cpu.max

# 无限制（默认）
echo "max" > /sys/fs/cgroup/myapp/cpu.max

# 启用 cpuset 控制器
echo "+cpuset" > /sys/fs/cgroup/cgroup.subtree_control

# 限制进程只能运行在 CPU 0-3 上
echo "0-3" > /sys/fs/cgroup/myapp/cpuset.cpus

# 限制内存节点（NUMA 场景）
echo "0" > /sys/fs/cgroup/myapp/cpuset.mems

# 限制最大内存使用为 1GB
echo 1073741824 > /sys/fs/cgroup/myapp/memory.max

# 限制最大内存为 1GB（人类可读格式，内核 5.9+）
echo "1G" > /sys/fs/cgroup/myapp/memory.max

# 限制 swap 使用（内核 5.8+）
echo 536870912 > /sys/fs/cgroup/myapp/memory.swap.max   # 512MB swap

# 查看当前内存使用
cat /sys/fs/cgroup/myapp/memory.current
# 输出：536870912

# 查看内存峰值
cat /sys/fs/cgroup/myapp/memory.peak
# 输出：805306368

# 查看详细内存统计
cat /sys/fs/cgroup/myapp/memory.stat

anon 536870912          # 匿名内存（堆、栈等）
file 268435456          # 文件缓存
kernel 67108864         # 内核内存
sock 33554432           # socket 缓冲区
shmem 16777216          # 共享内存
slab_reclaimable 8388608    # 可回收 slab
slab_unreclaimable 4194304  # 不可回收 slab
pgfault 1234567         # 页错误次数
pgmajfault 1234         # 主要页错误次数
oom_kill 0               # OOM kill 次数

# 设置内存下限保护（在此范围内不被回收）
echo 536870912 > /sys/fs/cgroup/myapp/memory.low   # 512MB 受保护

# 设置内存上限
echo 1073741824 > /sys/fs/cgroup/myapp/memory.max  # 1GB 上限

# 当系统内存紧张时：
# - 低于 memory.low 的部分受保护，不会被优先回收
# - 超过 memory.low 但低于 memory.max 的部分可以被回收
# - 超过 memory.max 触发 OOM 或被 kill

# 禁止 OOM killer 杀死该 cgroup 中的进程
echo 1 > /sys/fs/cgroup/myapp/memory.oom.group

# 当 memory.oom.group=1 时，cgroup 中任何进程触发 OOM
# 会导致整个 cgroup 的所有进程被 kill

# 查看 OOM 事件
cat /sys/fs/cgroup/myapp/memory.events
# 输出：
# oom 0
# oom_kill 0
# oom_group_kill 0

# 启用 IO 控制器
echo "+io" > /sys/fs/cgroup/cgroup.subtree_control

# 查看可用块设备
cat /sys/fs/cgroup/myapp/io.stat
# 输出示例：
# 8:0 rbytes=1234567 wbytes=2345678 rios=100 wios=200
# 8:16 rbytes=345678 wbytes=456789 rios=50 wios=60

# 限制 /dev/sda (8:0) 的写入带宽为 10MB/s
echo "8:0 rbps=max wbps=10485760" > /sys/fs/cgroup/myapp/io.max

# 限制读写 IOPS
echo "8:0 riops=max wiops=1000" > /sys/fs/cgroup/myapp/io.max

# 同时限制带宽和 IOPS
echo "8:0 rbps=10485760 wbps=10485760 riops=1000 wiops=1000" > /sys/fs/cgroup/myapp/io.max

# 获取 /dev/sda 的 major:minor
lsblk -o NAME,MAJ:MIN /dev/sda
# 输出：sda 8:0

# 或使用 stat 命令
stat -c '%t:%T' /dev/sda
# 输出：8:0（十六进制，需转换为十进制）

# 限制最多 500 个进程
echo 500 > /sys/fs/cgroup/myapp/pids.max

# 查看当前进程数
cat /sys/fs/cgroup/myapp/pids.current
# 输出：42

# 当 pids.current 达到 pids.max 时，fork() 会失败并返回 EAGAIN

# 创建带资源限制的 systemd 服务
sudo tee /etc/systemd/system/heavy-app.service << 'EOF'
[Unit]
Description=Heavy Application
After=network.target

[Service]
Type=simple
ExecStart=/usr/bin/heavy-app
# CPU 限制：最多使用 2 个核心
CPUQuota=200%
# CPU 权重（相对优先级）
CPUWeight=500
# 内存限制
MemoryMax=2G
MemoryLow=512M
# IO 权重
IOWeight=500
# 进程数限制
TasksMax=300
# 重启策略
Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl start heavy-app

# 查看服务的 cgroup 资源使用情况
systemctl status heavy-app

# 输出中会包含 CGroup 信息：
# CGroup: /system.slice/heavy-app.service
#         ├─1234 /usr/bin/heavy-app

# 查看详细的 cgroup 控制器配置
systemctl show heavy-app | grep -E "CPUQuota|MemoryMax|MemoryLow|IOWeight|TasksMax"
# 输出：
# CPUQuotaPerSecUSec=2s
# MemoryMax=2147483648
# MemoryLow=536870912
# IOWeight=500
# TasksMax=300

# 实时监控 cgroup 资源
systemd-cgtop
# 输出示例：
# Control Group           Tasks   %CPU   Memory  Input/s Output/s
# /system.slice/heavy-app  1      45.0   1.2G    0B/s    10MB/s
# /system.slice/nginx      4       2.1   256M    0B/s    0B/s

# 临时增加内存限制
systemctl set-property heavy-app MemoryMax=4G

# 临时调整 CPU 配额
systemctl set-property heavy-app CPUQuota=300%

# 设置 IO 权重
systemctl set-property heavy-app IOWeight=800

# 如果要永久生效（写入配置文件）
systemctl set-property --runtime=false heavy-app MemoryMax=4G

# 创建线程化 cgroup
mkdir /sys/fs/cgroup/myapp/worker-threads
echo threaded > /sys/fs/cgroup/myapp/worker-threads/cgroup.type

# 将线程添加到线程化 cgroup
echo $TID > /sys/fs/cgroup/myapp/worker-threads/cgroup.threads

# 为不同线程组设置不同 CPU 权重
echo 200 > /sys/fs/cgroup/myapp/worker-threads/cpu.weight
echo 800 > /sys/fs/cgroup/myapp/main-threads/cpu.weight

#!/bin/bash
# cgroup-v2-manage.sh — cgroup v2 手动管理示例

set -euo pipefail

CGROOT="/sys/fs/cgroup"
CGROUP_NAME="batch-job"

# 确保以 root 运行
if [ "$(id -u)" -ne 0 ]; then
    echo "请以 root 权限运行" >&2
    exit 1
fi

# 创建 cgroup
echo ">>> 创建 cgroup: $CGROUP_NAME"
mkdir -p "$CGROOT/$CGROUP_NAME"

# 启用控制器（在父级 subtree_control 中启用）
echo "+cpu +memory +io +pids" > "$CGROOT/cgroup.subtree_control"

# 设置 CPU 限制：单核 30%
echo "30000 100000" > "$CGROOT/$CGROUP_NAME/cpu.max"

# 设置内存限制：512MB
echo 536870912 > "$CGROOT/$CGROUP_NAME/memory.max"

# 设置 swap 限制：128MB
echo 134217728 > "$CGROOT/$CGROUP_NAME/memory.swap.max"

# 设置进程数限制：100
echo 100 > "$CGROOT/$CGROUP_NAME/pids.max"

# 设置 IO 限制：写入 5MB/s
DEVICE=$(stat -c '%t:%T' /dev/sda)
MAJOR=$((0x$(stat -c '%t' /dev/sda)))
MINOR=$((0x$(stat -c '%T' /dev/sda)))
echo "$MAJOR:$MINOR wbps=5242880" > "$CGROOT/$CGROUP_NAME/io.max"

echo ">>> 资源限制已设置："
echo "    CPU:   30% 单核"
echo "    内存:  512MB"
echo "    Swap:  128MB"
echo "    进程:  100"
echo "    IO:    5MB/s 写入"

# 启动进程并加入 cgroup
echo ">>> 启动进程..."
python3 /opt/batch-job/main.py &
PID=$!

# 将进程加入 cgroup
echo $PID > "$CGROOT/$CGROUP_NAME/cgroup.procs"

echo ">>> 进程 PID=$PID 已加入 cgroup $CGROUP_NAME"
echo ">>> 监控资源使用（按 Ctrl+C 停止）..."

# 实时监控
while kill -0 "$PID" 2>/dev/null; do
    echo "--- $(date '+%H:%M:%S') ---"
    echo "CPU 使用: $(cat $CGROOT/$CGROUP_NAME/cpu.stat | grep 'usage_usec' | head -1)"
    echo "内存使用: $(cat $CGROOT/$CGROUP_NAME/memory.current) bytes"
    echo "进程数:   $(cat $CGROOT/$CGROUP_NAME/pids.current)"
    sleep 5
done

echo ">>> 进程已退出"
echo ">>> 内存峰值: $(cat $CGROOT/$CGROUP_NAME/memory.peak) bytes"
echo ">>> OOM 事件: $(cat $CGROOT/$CGROUP_NAME/memory.events | grep oom)"

# 清理 cgroup
rmdir "$CGROOT/$CGROUP_NAME"
echo ">>> cgroup 已清理"

# 对运行中的进程做检查点
criu dump --tree $PID --images-dir /tmp/checkpoint

# 在另一台机器上恢复（cgroup 配置会自动重建）
criu restore --images-dir /tmp/checkpoint --cgroup-root /sys/fs/cgroup/myapp

# 检查 Docker 的 cgroup driver
docker info | grep -i cgroup

# cgroup v2 输出：
#  Cgroup Driver: cgroupfs
#  Cgroup Version: 2

# 或
#  Cgroup Driver: systemd
#  Cgroup Version: 2

# 启动容器并限制 CPU 和内存
docker run -d \
    --name myapp \
    --cpus="1.5" \
    --cpu-shares=512 \
    --memory="1g" \
    --memory-swap="1.5g" \
    --pids-limit=200 \
    --device-write-bps /dev/sda:10mb \
    myapp:latest

# 验证容器的 cgroup 配置
# Docker 在 v2 下创建的 cgroup 路径：
# /sys/fs/cgroup/system.slice/docker-<container-id>.scope/

CONTAINER_ID=$(docker inspect -f '{{.Id}}' myapp)
CG_PATH="/sys/fs/cgroup/system.slice/docker-${CONTAINER_ID}.scope"

echo "CPU 限制: $(cat $CG_PATH/cpu.max)"
echo "内存限制: $(cat $CG_PATH/memory.max)"
echo "内存使用: $(cat $CG_PATH/memory.current)"
echo "进程数:   $(cat $CG_PATH/pids.current)/$(cat $CG_PATH/pids.max)"

# /var/lib/kubelet/config.yaml
apiVersion: kubelet.config.k8s.io/v1
kind: KubeletConfiguration
cgroupDriver: systemd   # 推荐使用 systemd（与 cgroup v2 配合最佳）
# 如果使用 cgroupfs，则 kubelet 直接操作 cgroup 文件系统

# Pod 定义
apiVersion: v1
kind: Pod
metadata:
  name: resource-demo
spec:
  containers:
  - name: app
    image: myapp:latest
    resources:
      requests:
        cpu: "500m"     # 0.5 核请求
        memory: "512Mi"
      limits:
        cpu: "1000m"    # 1 核限制
        memory: "1Gi"

# Pod 的 cgroup 路径（使用 systemd cgroup driver）
# /sys/fs/cgroup/kubepods.slice/kubepods-besteffort.slice/
#   kubepods-pod<uid>.slice/
#     cri-containerd-<container-id>.scope/

# CPU requests → cpu.weight
# 500m request → cpu.weight ≈ 50（基于公式转换）

# CPU limits → cpu.max
# 1000m limit → cpu.max = "100000 100000"（1 核）

# Memory limits → memory.max
# 1Gi limit → memory.max = 1073741824

# Memory requests → memory.low
# 512Mi request → memory.low = 536870912

# Kubernetes 将 CPU request 转换为 cgroup v2 cpu.weight 的逻辑
def cpu_request_to_weight(cpu_millicores):
    # 转换为核数
    cpu_cores = cpu_millicores / 1000.0
    # weight 公式：weight = 1 + (cpu_cores - 1) * 99（近似）
    # 实际使用的是对数映射，确保小请求也有合理权重
    if cpu_cores <= 0:
        return 1
    # Kubernetes 的映射表
    weight = min(10000, max(1, int(100 * (cpu_cores))))
    return weight

# 示例
print(cpu_request_to_weight(100))   # 100m → 10
print(cpu_request_to_weight(500))    # 500m → 50
print(cpu_request_to_weight(1000))  # 1 核 → 100
print(cpu_request_to_weight(4000))  # 4 核 → 400

# 进入容器
docker exec -it myapp bash

# 容器内查看 cgroup
cat /sys/fs/cgroup/cgroup.controllers
# 输出：cpu memory io pids

cat /sys/fs/cgroup/memory.max
# 输出：1073741824（即宿主机设置的 1GB 限制）

cat /sys/fs/cgroup/cpu.max
# 输出：150000 100000（即 1.5 核限制）

# cgroup v2 的统一视图让容器内进程
# 可以通过标准接口获取自身的资源限制

#!/bin/bash
# setup-mixed-workloads.sh — 混合负载 cgroup 配置

CGROOT="/sys/fs/cgroup"

# 创建工作负载分组
mkdir -p "$CGROOT"/{latency-sensitive,best-effort,batch}

# 启用所有需要的控制器
echo "+cpu +memory +io +pids" > "$CGROOT/cgroup.subtree_control"

# 1. 延迟敏感型应用（如 Web API）
#    高 CPU 权重，内存保护，低 IO 限制
echo 10000 > "$CGROOT/latency-sensitive/cpu.weight"     # 最高权重
echo 4294967296 > "$CGROOT/latency-sensitive/memory.max"  # 4GB 上限
echo 2147483648 > "$CGROOT/latency-sensitive/memory.low"   # 2GB 保护
echo 800 > "$CGROOT/latency-sensitive/io.weight"         # 高 IO 优先级

# 2. 尽力而为型应用（如后台任务）
#    中等 CPU 权重，适度内存
echo 200 > "$CGROOT/best-effort/cpu.weight"
echo 2147483648 > "$CGROOT/best-effort/memory.max"  # 2GB
echo 536870912 > "$CGROOT/best-effort/memory.low"   # 512MB 保护
echo 200 > "$CGROOT/best-effort/io.weight"

# 3. 批处理任务（如数据分析）
#    低 CPU 权重，大内存，IO 限制
echo 50 > "$CGROOT/batch/cpu.weight"              # 最低权重
echo 8589934592 > "$CGROOT/batch/memory.max"       # 8GB
echo 1073741824 > "$CGROOT/batch/memory.low"       # 1GB 保护
echo 50 > "$CGROOT/batch/io.weight"               # 低 IO 优先级

# 限制批处理任务的 IO 带宽（避免影响数据库性能）
DEV=$(stat -c '%t:%T' /dev/sda)
MAJOR=$((0x$(stat -c '%t' /dev/sda)))
MINOR=$((0x$(stat -c '%T' /dev/sda)))
echo "$MAJOR:$MINOR rbps=52428800 wbps=52428800" > "$CGROOT/batch/io.max"
# 限制读写各 50MB/s

echo ">>> 混合负载 cgroup 配置完成"
echo ">>> 延迟敏感: cpu.weight=10000, mem=4G(2G protected), io=800"
echo ">>> 尽力而为: cpu.weight=200,  mem=2G(512M protected), io=200"
echo ">>> 批处理:   cpu.weight=50,   mem=8G(1G protected),  io=50(50MB/s)"

#!/usr/bin/env python3
"""cgroup v2 资源监控脚本 — 采集指定 cgroup 的资源使用数据"""

import os
import time
import json
from pathlib import Path

class CgroupV2Monitor:
    """监控 cgroup v2 资源使用情况"""

    CGROOT = Path("/sys/fs/cgroup")

    def __init__(self, cgroup_path: str):
        self.cgpath = self.CGROOT / cgroup_path.lstrip("/")
        if not self.cgpath.exists():
            raise FileNotFoundError(f"cgroup path not found: {self.cgpath}")

    def read_file(self, name: str) -> str:
        filepath = self.cgpath / name
        if not filepath.exists():
            return ""
        return filepath.read_text().strip()

    def get_cpu_stats(self) -> dict:
        """获取 CPU 使用统计"""
        stats = {}
        cpu_max = self.read_file("cpu.max")
        if cpu_max and cpu_max != "max":
            parts = cpu_max.split()
            stats["cpu_quota_us"] = int(parts[0])
            stats["cpu_period_us"] = int(parts[1])
            stats["cpu_limit_cores"] = int(parts[0]) / int(parts[1])
        else:
            stats["cpu_limit_cores"] = -1  # 无限制

        cpu_stat = self.read_file("cpu.stat")
        for line in cpu_stat.split("\n"):
            if line:
                key, val = line.split()
                stats[f"cpu_{key}"] = int(val)
        return stats

    def get_memory_stats(self) -> dict:
        """获取内存使用统计"""
        stats = {}
        stats["memory_current"] = int(self.read_file("memory.current") or 0)
        stats["memory_max"] = int(self.read_file("memory.max") or 0)
        stats["memory_peak"] = int(self.read_file("memory.peak") or 0)
        stats["memory_low"] = int(self.read_file("memory.low") or 0)
        stats["memory_swap_current"] = int(self.read_file("memory.swap.current") or 0)
        stats["memory_swap_max"] = int(self.read_file("memory.swap.max") or 0)

        mem_stat = self.read_file("memory.stat")
        for line in mem_stat.split("\n"):
            if line:
                key, val = line.split()
                stats[f"mem_{key}"] = int(val)

        events = self.read_file("memory.events")
        for line in events.split("\n"):
            if line:
                key, val = line.split()
                stats[f"mem_event_{key}"] = int(val)
        return stats

    def get_io_stats(self) -> dict:
        """获取 IO 使用统计"""
        stats = {}
        io_stat = self.read_file("io.stat")
        for line in io_stat.split("\n"):
            if not line:
                continue
            parts = line.split()
            dev = parts[0]  # major:minor
            for field in parts[1:]:
                key, val = field.split("=")
                stats[f"io_{dev}_{key}"] = int(val)
        return stats

    def get_pids_stats(self) -> dict:
        """获取进程数统计"""
        return {
            "pids_current": int(self.read_file("pids.current") or 0),
            "pids_max": int(self.read_file("pids.max") or 0),
        }

    def collect_all(self) -> dict:
        """采集所有资源数据"""
        return {
            "timestamp": int(time.time()),
            "cgroup": str(self.cgpath),
            "cpu": self.get_cpu_stats(),
            "memory": self.get_memory_stats(),
            "io": self.get_io_stats(),
            "pids": self.get_pids_stats(),
        }

if __name__ == "__main__":
    # 示例：监控系统.slice 下的 nginx 服务
    monitor = CgroupV2Monitor("system.slice/nginx.service")

    while True:
        data = monitor.collect_all()
        print(json.dumps(data, indent=2))

        # 计算内存使用率
        mem = data["memory"]
        if mem["memory_max"] > 0:
            usage_pct = mem["memory_current"] / mem["memory_max"] * 100
            print(f"\n内存使用率: {usage_pct:.1f}%")

        time.sleep(10)

# 查看 cgroup 的 PSI 压力指标
cat /sys/fs/cgroup/myapp/psi/cpu.pressure
# 输出：
# some avg10=12.50 avg60=5.00 avg300=2.00 total=12345678
# full avg10=8.30 avg60=3.00 avg300=1.00 total=8765432

# some: 至少一个任务在等待 CPU
# full: 所有任务都在等待 CPU
# avg10/60/300: 10秒/60秒/300秒平均压力

cat /sys/fs/cgroup/myapp/psi/memory.pressure
cat /sys/fs/cgroup/myapp/psi/io.pressure

#!/usr/bin/env python3
"""基于 PSI 压力指标的自动扩缩容决策器"""

import re
from pathlib import Path

class PSIMonitor:
    """读取 cgroup PSI 压力数据"""

    def __init__(self, cgroup_path: str):
        self.cgroot = Path("/sys/fs/cgroup") / cgroup_path.lstrip("/")

    def read_psi(self, resource: str) -> dict:
        """读取指定资源的 PSI 数据"""
        filepath = self.cgroot / f"psi/{resource}.pressure"
        if not filepath.exists():
            return {}

        content = filepath.read_text()
        result = {}
        for line in content.strip().split("\n"):
            match = re.match(
                r'(\w+)\s+avg10=(\S+)\s+avg60=(\S+)\s+avg300=(\S+)\s+total=(\d+)',
                line
            )
            if match:
                result[match.group(1)] = {
                    "avg10": float(match.group(2)),
                    "avg60": float(match.group(3)),
                    "avg300": float(match.group(4)),
                    "total": int(match.group(5)),
                }
        return result

    def should_scale_up(self) -> tuple:
        """判断是否需要扩容"""
        cpu_psi = self.read_psi("cpu")
        mem_psi = self.read_psi("memory")

        cpu_pressure = cpu_psi.get("some", {}).get("avg10", 0)
        mem_pressure = mem_psi.get("full", {}).get("avg10", 0)

        if cpu_pressure > 30:
            return True, f"CPU 压力过高 ({cpu_pressure:.1f}%)，建议扩容"
        if mem_pressure > 20:
            return True, f"内存压力过高 ({mem_pressure:.1f}%)，建议扩容"

        return False, "资源压力正常"

if __name__ == "__main__":
    monitor = PSIMonitor("myapp")

    scale_up, reason = monitor.should_scale_up()
    if scale_up:
        print(f"[ALERT] {reason}")
        # 这里可以触发 Kubernetes HPA 或自动扩容逻辑
    else:
        print(f"[OK] {reason}")

#!/bin/bash
# migrate-to-cgroup-v2.sh — cgroup v1 到 v2 迁移脚本

set -euo pipefail

echo "=== cgroup v1 → v2 迁移工具 ==="

# 1. 预检查
echo ""
echo "[1/5] 预检查..."

# 检查内核版本
KERNEL_VERSION=$(uname -r | cut -d. -f1-2)
KERNEL_MAJOR=$(echo $KERNEL_VERSION | cut -d. -f1)
KERNEL_MINOR=$(echo $KERNEL_VERSION | cut -d. -f2)
if [ "$KERNEL_MAJOR" -lt 5 ] || { [ "$KERNEL_MAJOR" -eq 5 ] && [ "$KERNEL_MINOR" -lt 2 ]; }; then
    echo "  [FAIL] 内核版本 $KERNEL_VERSION 过低，需要 >= 5.2"
    exit 1
fi
echo "  [OK] 内核版本: $KERNEL_VERSION"

# 检查 systemd 版本
SYSTEMD_VERSION=$(systemctl --version | head -1 | awk '{print $2}')
if [ "$SYSTEMD_VERSION" -lt 239 ]; then
    echo "  [FAIL] systemd 版本 $SYSTEMD_VERSION 过低，需要 >= 239"
    exit 1
fi
echo "  [OK] systemd 版本: $SYSTEMD_VERSION"

# 检查当前 cgroup 模式
CURRENT_MODE=$(mount | grep -c "^cgroup ")
if [ "$CURRENT_MODE" -eq 0 ]; then
    echo "  [INFO] 系统可能已在使用 cgroup v2"
    echo "  [OK] 无需迁移"
    exit 0
fi
echo "  [OK] 当前为 cgroup v1，开始迁移准备"

# 2. 检查容器运行时兼容性
echo ""
echo "[2/5] 检查容器运行时..."
if command -v docker &>/dev/null; then
    DOCKER_VERSION=$(docker version --format '{{.Server.Version}}' 2>/dev/null || echo "0")
    DOCKER_MAJOR=$(echo $DOCKER_VERSION | cut -d. -f1)
    if [ "$DOCKER_MAJOR" -lt 20 ]; then
        echo "  [WARN] Docker $DOCKER_VERSION 需要升级到 >= 20.10"
        echo "  [INFO] 升级命令：curl -fsSL https://get.docker.com | sh"
    else
        echo "  [OK] Docker 版本: $DOCKER_VERSION"
    fi
fi

# 3. 检查 Kubernetes 兼容性
echo ""
echo "[3/5] 检查 Kubernetes..."
if command -v kubectl &>/dev/null; then
    K8S_VERSION=$(kubectl version --short 2>/dev/null | grep Server | awk '{print $3}' | cut -d. -f1-2 || echo "0.0")
    K8S_MINOR=$(echo $K8S_VERSION | cut -d. -f2)
    if [ "$K8S_MINOR" -lt 25 ]; then
        echo "  [WARN] Kubernetes $K8S_VERSION 建议升级到 >= 1.25"
    else
        echo "  [OK] Kubernetes 版本: $K8S_VERSION"
    fi
fi

# 4. 检查自定义脚本
echo ""
echo "[4/5] 检查自定义 cgroup 脚本..."
echo "  [INFO] 搜索依赖 cgroup v1 路径的脚本..."
V1_SCRIPTS=$(grep -rl "/sys/fs/cgroup/cpu" /etc/init.d/ /usr/local/bin/ /opt/ 2>/dev/null || true)
if [ -n "$V1_SCRIPTS" ]; then
    echo "  [WARN] 发现以下脚本引用了 cgroup v1 路径："
    echo "$V1_SCRIPTS" | while read script; do
        echo "    - $script"
    done
    echo "  [INFO] 需要将 v1 路径（如 /sys/fs/cgroup/cpu/xxx/cpu.cfs_quota_us）"
    echo "         更新为 v2 路径（如 /sys/fs/cgroup/xxx/cpu.max）"
else
    echo "  [OK] 未发现引用 v1 路径的脚本"
fi

# 5. 生成迁移指令
echo ""
echo "[5/5] 迁移指令..."
echo "  1. 编辑 GRUB 配置："
echo "     sudo sed -i 's/GRUB_CMDLINE_LINUX=\"/GRUB_CMDLINE_LINUX=\"systemd.unified_cgroup_hierarchy=1 /' /etc/default/grub"
echo ""
echo "  2. 更新 GRUB："
echo "     sudo update-grub    # Debian/Ubuntu"
echo "     sudo grub2-mkconfig -o /boot/grub2/grub.cfg   # RHEL/CentOS"
echo ""
echo "  3. 重启系统："
echo "     sudo reboot"
echo ""
echo "  4. 重启后验证："
echo "     mount | grep cgroup2"
echo "     cat /sys/fs/cgroup/cgroup.controllers"
echo ""
echo "  5. 更新 kubelet 配置（如使用 K8s）："
echo "     确保 cgroupDriver: systemd"
echo ""
echo "=== 迁移准备完成 ==="

def cpu_shares_to_weight(shares: int) -> int:
    """将 cgroup v1 cpu.shares 转换为 v2 cpu.weight"""
    # v1 范围: 2-262144, 默认 1024
    # v2 范围: 1-10000, 默认 100
    # 近似线性映射
    weight = max(1, min(10000, int(shares / 1024 * 100)))
    return weight

# 示例
print(cpu_shares_to_weight(1024))  # 默认 → 100
print(cpu_shares_to_weight(512))   # 低优先级 → 50
print(cpu_shares_to_weight(2048))  # 高优先级 → 200
print(cpu_shares_to_weight(8192))  # 最高 → 800

# 现象：写入 cgroup.subtree_control 时报错
echo "+cpu" > /sys/fs/cgroup/cgroup.subtree_control
# bash: echo: write error: Invalid argument

# 排查1：检查控制器是否在全局可用列表中
cat /sys/fs/cgroup/cgroup.controllers
# 如果 cpu 不在列表中，说明内核未启用该控制器

# 排查2：检查是否有进程在根 cgroup 中
cat /sys/fs/cgroup/cgroup.procs
# 根 cgroup 中有进程时，某些控制器无法启用
# 需要将进程迁移到子 cgroup

# 排查3：检查内核启动参数
cat /proc/cmdline | grep cgroup
# 确认没有 cgroup_no_v1 或 cgroup.disable 排除该控制器

# 现象：rmdir 报 "Device or resource busy"
rmdir /sys/fs/cgroup/myapp
# rmdir: failed to remove '/sys/fs/cgroup/myapp': Device or resource busy

# 排查：检查是否有活跃进程
cat /sys/fs/cgroup/myapp/cgroup.procs
# 如果有 PID，需要先将进程移出

# 移出进程
for pid in $(cat /sys/fs/cgroup/myapp/cgroup.procs); do
    echo $pid > /sys/fs/cgroup/cgroup.procs  # 移到根 cgroup
done

# 检查子 cgroup
ls /sys/fs/cgroup/myapp/
# 需要先删除所有子 cgroup

# 检查是否启用了控制器但未禁用
cat /sys/fs/cgroup/myapp/cgroup.type
# 如果是 threaded，需要先改回 domain
echo "domain" > /sys/fs/cgroup/myapp/cgroup.type

# 现象：docker run --memory=1g 但容器内可用内存远超 1G

# 排查1：确认 Docker 使用 cgroup v2
docker info | grep "Cgroup Version"
# 应输出 2

# 排查2：检查 swap 限制
# 在 cgroup v2 中，memory.swap.max 控制的是 swap 使用量
# 而不是 memory+swap 总量（v1 的行为）
docker run --memory=1g --memory-swap=1g myapp
# 这会将 swap 限制设为 0（swap = memory-swap - memory = 0）

# 排查3：检查内核参数
sysctl vm.swappiness
# 如果 swappiness=0，系统可能不使用 swap

# 排查4：确认容器内看到正确的限制
docker exec myapp cat /sys/fs/cgroup/memory.max
# 应输出 1073741824（1GB）

# 现象：设置了 limits.cpu=1000m 但容器使用的 CPU 超过 1 核

# 排查1：检查 kubelet cgroup driver
cat /var/lib/kubelet/config.yaml | grep cgroupDriver
# 推荐使用 systemd

# 排查2：检查 Pod 的 cgroup
# 获取 Pod UID
POD_UID=$(kubectl get pod mypod -o jsonpath='{.metadata.uid}')
# 查看 cgroup
cat /sys/fs/cgroup/kubepods.slice/kubepods-pod${POD_UID//-/_}.slice/cpu.max

# 排查3：多核场景下的 CPU 限制
# cpu.max = "100000 100000" 表示每 100ms 可用 100ms
# 在多核机器上，容器可以在一个 100ms 周期内
# 在多个 CPU 核心上运行总共 100ms 的计算
# 但瞬时可能看到多个核同时高使用率
# 这是正常行为：cpu.max 限制的是总量，不是并发核数