1
# 查看 Cgroup v2 的根目录
2
ls /sys/fs/cgroup/
3

4
# 核心文件
5
cgroup.controllers        # 当前 cgroup 可用的控制器
6
cgroup.subtree_control    # 子 cgroup 启用的控制器
7
cgroup.procs              # 属于当前 cgroup 的进程 PID
8
cgroup.type               # cgroup 类型（domain/threaded）
9
cgroup.max.depth          # 最大嵌套深度
10
cgroup.max.descendants    # 最大后代数量
11
cgroup.stat               # 统计信息
12

13
# PSI（Pressure Stall Information）
14
cpu.pressure              # CPU 压力
15
memory.pressure           # 内存压力
16
io.pressure               # IO 压力

1
# 限制容器最多使用 2 个 CPU 核心
2
# quota = 200000μs, period = 100000μs
3
echo "200000 100000" > /sys/fs/cgroup/docker/container1/cpu.max
4

5
# 查看当前设置
6
cat /sys/fs/cgroup/docker/container1/cpu.max
7
# 200000 100000
8

9
# 不限制（默认）
10
echo "max 100000" > /sys/fs/cgroup/docker/container1/cpu.max

1
可用 CPU 核数 = quota / period
2
例如：200000 / 100000 = 2 核

1
# 设置权重为 200（相对于默认 100，获得 2 倍 CPU 时间）
2
echo "200" > /sys/fs/cgroup/docker/container1/cpu.weight
3

4
# 两个容器的 CPU 时间分配比例
5
# container1 (weight=200) : container2 (weight=100) = 2:1

1
# 限制容器只能使用 CPU 0 和 CPU 2
2
echo "0,2" > /sys/fs/cgroup/docker/container1/cpuset.cpus
3

4
# 限制 NUMA 节点
5
echo "0" > /sys/fs/cgroup/docker/container1/cpuset.mems
6

7
# Docker 等价参数
8
docker run --cpuset-cpus=0,2 nginx

1
# 限制容器最多使用 512MB 内存
2
echo "536870912" > /sys/fs/cgroup/docker/container1/memory.max  # 512 * 1024 * 1024
3

4
# 查看当前内存使用
5
cat /sys/fs/cgroup/docker/container1/memory.current
6
# 134217728 (128MB)
7

8
# 查看内存限制
9
cat /sys/fs/cgroup/docker/container1/memory.max
10
# 536870912
11

12
# 不限制
13
echo "max" > /sys/fs/cgroup/docker/container1/memory.max

1
# 设置内存保护
2
echo "134217728" > memory.min   # 保证至少 128MB
3
echo "268435456" > memory.low   # 尽量保留 256MB
4
echo "536870912" > memory.max   # 最多使用 512MB

1
# Cgroup v2 的 swap 控制
2
# memory.swap.max = 最大 swap 使用量
3
echo "268435456" > memory.swap.max  # 最多 256MB swap
4

5
# 查看当前 swap 使用
6
cat memory.swap.current
7

8
# 禁用 swap（Docker 默认）
9
echo "0" > memory.swap.max
10

11
# Docker 等价参数
12
docker run --memory=512m --memory-swap=1g nginx

1
# OOM 控制组
2
echo "1" > memory.oom.group   # 整个 cgroup 作为 OOM 受害者
3

4
# OOM 事件通知（通过 cgroup.events）
5
cat memory.events
6
# oom 5            # OOM 事件计数
7
# oom_kill 3       # OOM kill 计数
8
# oom_group_kill 2 # 组 OOM kill 计数
9

10
# 内存压力统计
11
cat memory.stat
12
# anon 134217728        # 匿名页
13
# file 67108864         # 文件缓存页
14
# slab 33554432         # Slab 缓存
15
# pgfault 12345         # 页错误
16
# pgmajfault 67         # 主要页错误

1
# 限制容器对 /dev/sda 的读写速率
2
# 格式：major:minor rbps wbps riops wiops
3
echo "8:0 rbps=104857600 wbps=52428800 riops=1000 wiops=500" > io.max
4

5
# 查看当前 IO 限制
6
cat io.max
7
# 8:0 rbps=104857600 wbps=52428800 riops=1000 wiops=500
8

9
# 查看当前 IO 统计
10
cat io.stat
11
# 8:0 rbytes=12345678 wbytes=87654321 rios=1234 wios=567 dbytes=0 dios=0

1
# 设置 IO 权重（1-10000，默认 100）
2
echo "200" > io.weight
3

4
# 按设备设置权重
5
echo "8:0 200" > io.weight

1
# 查看 IO 限流统计
2
cat io.stat
3
# 8:0 rbytes=12345678 wbytes=87654321 rios=1234 wios=567
4
#     dbytes=0 dios=0
5
#     cost.wait=123456 cost.inflight=7890
6

7
# cost.wait: IO 限流导致的等待时间（纳秒）

1
# 查看 CPU 压力
2
cat /sys/fs/cgroup/docker/container1/cpu.pressure
3
# some avg10=0.00 avg60=0.10 avg300=0.05 total=1234567
4
# full avg10=0.00 avg60=0.00 avg300=0.00 total=0
5

6
# some: 至少一个任务等待资源
7
# full: 所有任务都在等待资源（更严重）
8
# avg10/60/300: 最近 10/60/300 秒的百分比

1
# 监控容器的内存压力
2
watch -n 1 "cat /sys/fs/cgroup/docker/container1/memory.pressure"
3

4
# 基于 PSI 触发告警
5
# 当 avg10 > 50% 时，表示严重内存压力
6
# 可能需要增加内存限制或优化应用

1
# Docker 的 Cgroup 参数映射
2
docker run \
3
  --memory=512m \          # memory.max = 536870912
4
  --memory-reservation=256m \ # memory.low = 268435456
5
  --memory-swap=1g \       # memory.swap.max = 536870912
6
  --cpus=2 \               # cpu.max = 200000 100000
7
  --cpu-shares=2048 \      # cpu.weight = 2048
8
  --cpuset-cpus=0,2 \      # cpuset.cpus = 0,2
9
  --pids-limit=100 \       # pids.max = 100
10
  --device-write-bps /dev/sda:50MB \ # io.max wbps
11
  nginx
12

13
# 查看容器的 Cgroup 路径
14
docker inspect mycontainer --format '{{.CgroupPath}}'

1
# Kubernetes Pod 的资源限制
2
apiVersion: v1
3
kind: Pod
4
spec:
5
  containers:
6
  - name: nginx
7
    resources:
8
      requests:
9
        cpu: "1"          # cpu.weight 权重分配
10
        memory: "512Mi"   # memory.min 保证
11
      limits:
12
        cpu: "2"          # cpu.max 硬限制
13
        memory: "1Gi"     # memory.max 硬限制

1
// containerd 的 Cgroup 管理代码（简化）
2
package cgroups
3

4
import (
5
    "fmt"
6
    "os"
7
    "path/filepath"
8
)
9

10
type CgroupConfig struct {
11
    MemoryMax int64  // memory.max
12
    MemoryMin int64  // memory.min
13
    CPUMax    string // cpu.max (quota period)
14
    CPUWeight uint64 // cpu.weight
15
    PidsMax   int64  // pids.max
16
}
17

18
func ApplyCgroup(cgroupPath string, config *CgroupConfig) error {
19
    root := "/sys/fs/cgroup"
20

21
    // 创建 cgroup 目录
22
    path := filepath.Join(root, cgroupPath)
23
    if err := os.MkdirAll(path, 0755); err != nil {
24
        return err
25
    }
26

27
    // 设置 memory.max
28
    if config.MemoryMax > 0 {
29
        if err := os.WriteFile(
30
            filepath.Join(path, "memory.max"),
31
            []byte(fmt.Sprintf("%d", config.MemoryMax)),
32
            0644,
33
        ); err != nil {
34
            return err
35
        }
36
    }
37

38
    // 设置 cpu.max
39
    if config.CPUMax != "" {
40
        if err := os.WriteFile(
41
            filepath.Join(path, "cpu.max"),
42
            []byte(config.CPUMax),
43
            0644,
44
        ); err != nil {
45
            return err
46
        }
47
    }
48

49
    // 将进程加入 cgroup
50
    if err := os.WriteFile(
51
        filepath.Join(path, "cgroup.procs"),
52
        []byte(fmt.Sprintf("%d", os.Getpid())),
53
        0644,
54
    ); err != nil {
55
        return err
56
    }
57

58
    return nil
59
}

1
// eBPF 程序：限制网络连接
2
// 附加到 cgroup 的 BPF_CGROUP_INET_SOCK_CREATE hook
3
SEC("cgroup/sock")
4
int restrict_sockets(struct bpf_sock *ctx) {
5
    // 只允许 TCP 和 UDP
6
    if (ctx->protocol != IPPROTO_TCP &&
7
        ctx->protocol != IPPROTO_UDP) {
8
        return 0; // 拒绝
9
    }
10
    return 1; // 允许
11
}

1
#!/bin/bash
2
# 手动创建 Cgroup v2 并限制进程
3

4
# 1. 创建 cgroup
5
CGROUP_PATH="/sys/fs/cgroup/mycontainer"
6
sudo mkdir -p $CGROUP_PATH
7

8
# 2. 启用控制器
9
echo "+cpu +memory +io +pids" | sudo tee /sys/fs/cgroup/cgroup.subtree_control
10

11
# 3. 设置 CPU 限制（1 核）
12
echo "100000 100000" | sudo tee $CGROUP_PATH/cpu.max
13

14
# 4. 设置内存限制（256MB）
15
echo "268435456" | sudo tee $CGROUP_PATH/memory.max
16

17
# 5. 设置 PID 限制
18
echo "100" | sudo tee $CGROUP_PATH/pids.max
19

20
# 6. 启动进程并加入 cgroup
21
stress-ng --cpu 4 --timeout 60s &
22
PID=$!
23
echo $PID | sudo tee $CGROUP_PATH/cgroup.procs
24

25
# 7. 观察限流效果
26
watch -n 1 "cat $CGROUP_PATH/cpu.stat"
27
# nr_periods 10
28
# nr_throttled 8      ← 被限流 8 次
29
# throttled_usec 800000  ← 限流了 800ms
30

31
# 8. 清理
32
sudo rmdir $CGROUP_PATH

1
#!/bin/bash
2
# 监控容器的 Cgroup 资源使用
3

4
CONTAINER=$1
5
CGROUP=$(docker inspect -f '{{.CgroupPath}}' $CONTAINER 2>/dev/null)
6

7
if [ -z "$CGROUP" ]; then
8
    echo "Container not found"
9
    exit 1
10
fi
11

12
CGROUP_FS="/sys/fs/cgroup${CGROUP}"
13

14
echo "=== CPU ==="
15
echo "Limit: $(cat $CGROUP_FS/cpu.max)"
16
echo "Usage: $(cat $CGROUP_FS/cpu.stat | grep usage_usec)"
17
echo "Throttled: $(cat $CGROUP_FS/cpu.stat | grep throttled)"
18

19
echo ""
20
echo "=== Memory ==="
21
echo "Limit: $(cat $CGROUP_FS/memory.max)"
22
echo "Current: $(cat $CGROUP_FS/memory.current)"
23
echo "Swap: $(cat $CGROUP_FS/memory.swap.current) / $(cat $CGROUP_FS/memory.swap.max)"
24
echo "OOM events: $(cat $CGROUP_FS/memory.events | grep oom)"
25

26
echo ""
27
echo "=== IO ==="
28
echo "Stats: $(cat $CGROUP_FS/io.stat)"
29
echo "Pressure: $(cat $CGROUP_FS/io.pressure)"
30

31
echo ""
32
echo "=== PSI ==="
33
echo "CPU: $(cat $CGROUP_FS/cpu.pressure)"
34
echo "Memory: $(cat $CGROUP_FS/memory.pressure)"

1
mount | grep cgroup2
2
# cgroup2 on /sys/fs/cgroup type cgroup2 (rw,nosuid,nodev,noexec,relatime,nsdelegate)
3

4
cat /sys/fs/cgroup/cgroup.controllers
5
# cpuset cpu io memory hugetlb pids rdma

1
# 创建 cgroup 目录
2
mkdir -p /sys/fs/cgroup/my-demo
3

4
# 启用 CPU 和 memory 控制器（从根 cgroup 委派）
5
echo "+cpu +memory" > /sys/fs/cgroup/cgroup.subtree_control
6

7
# 确认控制器已启用
8
cat /sys/fs/cgroup/my-demo/cgroup.controllers
9
# cpuset cpu io memory hugetlb pids rdma

1
# 设置内存上限为 512MB
2
echo "536870912" > /sys/fs/cgroup/my-demo/memory.max
3

4
# 确认限制生效
5
cat /sys/fs/cgroup/my-demo/memory.max
6
# 536870912

1
# 限制 CPU 使用率为 50%（每 100000 微秒中最多使用 50000 微秒）
2
echo "50000 100000" > /sys/fs/cgroup/my-demo/cpu.max
3

4
# 确认限制生效
5
cat /sys/fs/cgroup/my-demo/cpu.max
6
# 50000 100000

1
# 启动一个消耗 CPU 的进程
2
stress --cpu 1 --timeout 30 &
3

4
# 将进程 PID 写入 cgroup
5
echo $! > /sys/fs/cgroup/my-demo/cgroup.procs
6

7
# 观察 CPU 使用率被限制在 50%
8
top -bn1 | grep stress

1
cat /sys/fs/cgroup/my-demo/cpu.pressure
2
# some avg10=0.00 avg60=0.00 avg300=0.00 total=0
3
# full avg10=0.00 avg60=0.00 avg300=0.00 total=0
4

5
cat /sys/fs/cgroup/my-demo/memory.pressure
6
# some avg10=0.00 avg60=0.00 avg300=0.00 total=0
7
# full avg10=0.00 avg60=0.00 avg300=0.00 total=0