深入剖析 Linux Cgroups 子系统:资源精细管理

linux中cgroup的简单使用 Linux CGroup全称Linux Control Group, 是Linux内核的一个功能,用来限制,控制与分离一个进程组群的资源(如CPU、内存、磁盘输入输出等)。这个项目最早是由Google的工程师在2006年发起(主要是Paul Menage和Rohit Seth),最早的名称为进程容器(process containers)。在2007年时,因为在Linux内核中,容器(container)这个名词太过广泛,为避免混乱,被重命名为cgroup,并且被合并到2.6.24版的内核中去。 阅读详情

本章主要演示以下 cgroups 下各个 subsystem 的作用。

根据难易程度,依次演示了 pids 、cpu 和 memory 3 个 subsystem 的使用。

注:本文所有操作在 Ubuntu20.04 下进行。


如果你对云原生技术充满好奇,想要深入了解更多相关的文章和资讯,欢迎关注微信公众号。

搜索公众号【探索云原生】即可订阅


1. pids

pids subsystem 功能是限制 cgroup 及其所有子孙 cgroup 里面能创建的总的 task 数量。

注意:这里的 task 指通过 fork 和 clone 函数创建的进程,由于 clone 函数也能创建线程(在 Linux 里面,线程是一种特殊的进程),所以这里的 task 也包含线程。

本文统一以进程来代表 task,即本文中的进程代表了进程和线程>

创建子 cgroup

创建子 cgroup,取名为 test

#进入目录/sys/fs/cgroup/pids/并新建一个目录,即创建了一个子cgroup
lixd  /home/lixd $ cd /sys/fs/cgroup/pids
lixd  /sys/fs/cgroup/pids $ sudo mkdir test

再来看看 test 目录下的文件

lixd  /sys/fs/cgroup/pids $ cd test
#除了上一篇中介绍的那些文件外,多了两个文件
 lixd  /sys/fs/cgroup/pids/test $ ls
cgroup.clone_children  cgroup.procs  notify_on_release  pids.current  pids.events  pids.max  tasks

下面是这两个文件的含义:

  • pids.current: 表示当前 cgroup 及其所有子孙 cgroup 中现有的总的进程数量
  • pids.max: 当前 cgroup 及其所有子孙 cgroup 中所允许创建的总的最大进程数量

限制进程数

首先是将当前 bash 加入到 cgroup 中,并修改pids.max的值,为了便于测试,这里就限制为 1:

#--------------------------第一个shell窗口----------------------
# 将当前bash进程加入到该cgroup
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/pids/test# echo $$ > cgroup.procs
#将pids.max设置为1,即当前cgroup只允许有一个进程
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/pids/test# echo 1 > pids.max

由于 bash 已经占用了一个进程,所以此时 bash 中已经无法创建新的进程了:

root@DESKTOP-9K4GB6E:/sys/fs/cgroup/pids/test# ls
bash: fork: retry: Resource temporarily unavailable
bash: fork: retry: Resource temporarily unavailable
bash: fork: retry: Resource temporarily unavailable

创建新进程失败,于是命令运行失败,说明限制生效。

打开另一个 shell 查看

 lixd  /mnt/c/Users/意琦行 $ cd /sys/fs/cgroup/pids/test
 lixd  /sys/fs/cgroup/pids/test $ ls
cgroup.clone_children  cgroup.procs  notify_on_release  pids.current  pids.events  pids.max  tasks
 lixd  /sys/fs/cgroup/pids/test $ cat pids.current
1

果然,pids.current 为 1,已经到 pids.max 的限制了。

当前 cgroup 和子 cgroup 之间的关系

当前 cgroup 中的 pids.current 和 pids.max 代表了当前 cgroup 及所有子孙 cgroup 的所有进程,所以子孙 cgroup 中的 pids.max 大小不能超过父 cgroup。

如果子 cgroup 中的 pids.max 设置的大于父 cgroup 里的值,会怎么样?

答案是子 cgroup 中的进程不光受子 cgroup 限制,还要受其父 cgroup 的限制。

#继续使用上面的两个窗口
#--------------------------第二个shell窗口----------------------
#将pids.max设置成2
dev@dev:/sys/fs/cgroup/pids/test$ echo 2 > pids.max
#在test下面创建一个子cgroup
dev@dev:/sys/fs/cgroup/pids/test$ mkdir subtest
dev@dev:/sys/fs/cgroup/pids/test$ cd subtest/
#将subtest的pids.max设置为5
dev@dev:/sys/fs/cgroup/pids/test/subtest$ echo 5 > pids.max
#将当前bash进程加入到subtest中
dev@dev:/sys/fs/cgroup/pids/test/subtest$ echo $$ > cgroup.procs
#--------------------------第三个shell窗口----------------------
#重新打开一个bash窗口,看一下test和subtest里面的数据
#test里面的数据如下:
dev@dev:~$ cd /sys/fs/cgroup/pids/test
dev@dev:/sys/fs/cgroup/pids/test$ cat pids.max
2
#这里为2表示目前test和subtest里面总的进程数为2
dev@dev:/sys/fs/cgroup/pids/test$ cat pids.current
2
dev@dev:/sys/fs/cgroup/pids/test$ cat cgroup.procs
3083

#subtest里面的数据如下:
dev@dev:/sys/fs/cgroup/pids/test$ cat subtest/pids.max
5
dev@dev:/sys/fs/cgroup/pids/test$ cat subtest/pids.current
1
dev@dev:/sys/fs/cgroup/pids/test$ cat subtest/cgroup.procs
3185
#--------------------------第一个shell窗口----------------------
#回到第一个窗口,随便运行一个命令,由于test里面的pids.current已经等于pids.max了,
#所以创建新进程失败,于是命令运行失败,说明限制生效
dev@dev:/sys/fs/cgroup/pids/test$ ls
-bash: fork: retry: No child processes
-bash: fork: retry: No child processes
-bash: fork: retry: No child processes
-bash: fork: retry: No child processes
-bash: fork: Resource temporarily unavailable
#--------------------------第二个shell窗口----------------------
#回到第二个窗口,随便运行一个命令,虽然subtest里面的pids.max还大于pids.current,
#但由于其父cgroup “test”里面的pids.current已经等于pids.max了,
#所以创建新进程失败,于是命令运行失败,说明子cgroup中的进程数不仅受自己的pids.max的限制,还受祖先cgroup的限制
dev@dev:/sys/fs/cgroup/pids/test/subtest$ ls
-bash: fork: retry: No child processes
-bash: fork: retry: No child processes
-bash: fork: retry: No child processes
-bash: fork: retry: No child processes
-bash: fork: Resource temporarily unavailable

pids.current > pids.max 的情况

并不是所有情况下都是 pids.max >= pids.current,在下面两种情况下,会出现 pids.max < pids.current 的情况:

  • 设置 pids.max 时,将其值设置的比 pids.current 小
  • 将其他进程加入到当前 cgroup 有可能会导致 pids.current > pids.max
    • 因为 pids.max 只会在当前 cgroup 中的进程 fork、clone 的时候生效,将其他进程加入到当前 cgroup 时,不会检测 pids.max,所以可能触发这种情况

小结

作用:pids subsystem 用于限制 cgroups 下能够创建的 task(进程和线程)数。

原理:在调用 fork 和 clone 时对比 subsystem 中配置的 pids.max 和 pids.current 值来判断当前是否能够继续创建 task。

用法:配置 pids.max 防止容器消耗完 pid。

2. cpu

在 cgroup 里面,跟 CPU 相关的子系统有 cpusets、cpuacct 和 cpu。

  • 其中 cpuset 主要用于设置 CPU 的亲和性,可以限制 cgroup 中的进程只能在指定的 CPU 上运行,或者不能在指定的 CPU 上运行,同时 cpuset 还能设置内存的亲和性。设置亲和性一般只在比较特殊的情况才用得着,所以这里不做介绍。

  • cpuacct 包含当前 cgroup 所使用的 CPU 的统计信息,信息量较少,有兴趣可以去看看它的文档,这里不做介绍。

本节只介绍 cpu 子系统,包括怎么限制 cgroup 的 CPU 使用上限及相对于其它 cgroup 的相对值。

创建子 cgroup

通用是创建子目录即可。

#进入/sys/fs/cgroup/cpu并创建子cgroup
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/cpu# cd /sys/fs/cgroup/cpu
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/cpu# mkdir test
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/cpu# cd test/
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/cpu/test# ls
cgroup.clone_children  cpu.cfs_period_us  cpu.rt_period_us   cpu.shares  notify_on_release
cgroup.procs           cpu.cfs_quota_us   cpu.rt_runtime_us  cpu.stat    tasks

看起来文件比 memory subsystem 还是少一些。

cpu.cfs_period_us & cpu.cfs_quota_us:两个文件配合起来设置 CPU 的使用上限,两个文件的单位都是微秒(us)。

  • cfs_period_us:用来配置时间周期长度
    • 取值范围为 1 毫秒(ms)到 1 秒(s)
  • cfs_quota_us:用来配置当前 cgroup 在设置的周期长度内所能使用的 CPU 时间数
    • 取值大于 1ms 即可
    • 默认值为 -1,表示不受 cpu 时间的限制。

cpu.shares 用来设置 CPU 的相对值(比例),并且是针对所有的 CPU(内核),默认值是 1024。

假如系统中有两个 cgroup,分别是 A 和 B,A 的 shares 值是 1024,B 的 shares 值是 512,那么 A 将获得 1024/(1204+512)=66% 的 CPU 资源,而 B 将获得 33% 的 CPU 资源。

shares 有两个特点:

  • 如果 A 不忙,没有使用到 66% 的 CPU 时间,那么剩余的 CPU 时间将会被系统分配给 B,即 B 的 CPU 使用率可以超过 33%
  • 如果添加了一个新的 cgroup C,且它的 shares 值是 1024,那么 A 的限额变成了 1024/(1204+512+1024)=40%,B 的变成了 20%

从上面两个特点可以看出:

  • 在闲的时候,shares 基本上不起作用,只有在 CPU 忙的时候起作用,这是一个优点。
  • 由于 shares 是一个绝对值,需要和其它 cgroup 的值进行比较才能得到自己的相对限额,而在一个部署很多容器的机器上,cgroup 的数量是变化的,所以这个限额也是变化的,自己设置了一个高的值,但别人可能设置了一个更高的值,所以这个功能没法精确的控制 CPU 使用率。

cpu.stat 包含了下面三项统计结果:

  • nr_periods: 表示过去了多少个 cpu.cfs_period_us 里面配置的时间周期
  • nr_throttled: 在上面的这些周期中,有多少次是受到了限制(即 cgroup 中的进程在指定的时间周期中用光了它的配额)
  • throttled_time: cgroup 中的进程被限制使用 CPU 持续了多长时间(纳秒)

原理

前面配置的参数都是 cfs_xxx,这里的 cfs 是 Completely Fair Scheduler 的缩写。

CFS 是 Linux 内核中的调度器,它负责决定哪个进程在给定时间片内运行。CFS 使用 CFS 配额(cpu.cfs_quota_us)和 CFS 周期(cpu.cfs_period_us)来限制每个 cgroup 中的 CPU 使用。

CFS 的实现与 cgroups 协同工作,它负责追踪每个 cgroup 中的进程消耗的 CPU 时间,并在每个调度周期结束时根据 cgroup 的 CPU 配额调整进程的运行时间。

如果一个 cgroup 中的进程在调度周期内超过了它的 CPU 配额,它将被调度器限制,从而实现了 CPU 的使用限制。

即:cgroups 中的 subsystem 负责提供配置,cfs 负责记录进程使用的 cpu 时间,达到阈值后就从调度层面进行限制,避免该进程继续使用 cpu。

演示

#继续使用上面创建的子cgroup: test
#设置只能使用1个cpu的20%的时间
dev@ubuntu:/sys/fs/cgroup/cpu,cpuacct/test$ sudo sh -c "echo 50000 > cpu.cfs_period_us"
dev@ubuntu:/sys/fs/cgroup/cpu,cpuacct/test$ sudo sh -c "echo 10000 > cpu.cfs_quota_us"

#将当前bash加入到该cgroup
dev@ubuntu:/sys/fs/cgroup/cpu,cpuacct/test$ echo $$
5456
dev@ubuntu:/sys/fs/cgroup/cpu,cpuacct/test$ sudo sh -c "echo 5456 > cgroup.procs"

#在bash中启动一个死循环来消耗cpu,正常情况下应该使用100%的cpu(即消耗一个内核)
dev@ubuntu:/sys/fs/cgroup/cpu,cpuacct/test$ while :; do echo test > /dev/null; done

#--------------------------重新打开一个shell窗口----------------------
#通过top命令可以看到5456的CPU使用率为20%左右,说明被限制住了
#不过这时系统的%us+%sy在10%左右,那是因为我测试的机器上cpu是双核的,
#所以系统整体的cpu使用率为10%左右
dev@ubuntu:~$ top
Tasks: 139 total,   2 running, 137 sleeping,   0 stopped,   0 zombie
%Cpu(s):  5.6 us,  6.2 sy,  0.0 ni, 88.2 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem :   499984 total,    15472 free,    81488 used,   403024 buff/cache
KiB Swap:        0 total,        0 free,        0 used.   383332 avail Mem

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND
 5456 dev       20   0   22640   5472   3524 R  20.3  1.1   0:04.62 bash

#这时可以看到被限制的统计结果
dev@ubuntu:~$ cat /sys/fs/cgroup/cpu,cpuacct/test/cpu.stat
nr_periods 1436
nr_throttled 1304
throttled_time 51542291833
# cfs_period_us 值为 10W
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/cpu/test# cat cpu.cfs_period_us
100000
# 往 cfs_quota_us 写入 20000,即限制只能使用20%cpu
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/cpu/test# echo 20000 > cpu.cfs_quota_us

# 新开一个窗口,运行一个死循环
$ while : ; do : ; done &
[1] 519
# top 看一下 cpu 占用率,果然是100%了

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
  519 lixd      25   5   13444   2912      0 R 100.0   0.0   0:05.66 zsh


# 回到第一个shell窗口,限制当前进程的cpu使用率
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/cpu/test# echo 519 >> cgroup.procs

# 再切回第二个窗口,发现519进程的cpu已经降到20%了,说明限制生效了
  PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
  519 lixd      25   5   13444   2912      0 R  20.0   0.0   0:31.86 zsh

# 查看被限制的统计结果
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/cpu/test# cat cpu.stat
nr_periods 2090
nr_throttled 2088
throttled_time 166752684900

小结

作用:cpu subsystem 用于限制 cgroups 下进程可以使用的 cpu 上限。

原理:cgroups 中的 subsystem 负责提供配置,cfs 负责记录进程使用的 cpu 时间,达到阈值后就从调度层面进行限制,避免该进程继续使用 cpu。

用法:

  • 1)限制为具体值:用 cfs_period_us & cfs_quota_us 两个配置可以严格限制进程 cpu 使用量。
  • 2)按比例分配:用 shares 配置,可以使得多个 cgroups 之间按比例分配所有 cpu。

3. memory

memory subsystem 顾名思义,限制 cgroups 中进程的内存使用。

为什么需要内存控制

  • 站在一个普通开发者的角度,如果能控制一个或者一组进程所能使用的内存数,那么就算代码有 bug,内存泄漏也不会对系统造成影响,因为可以设置内存使用量的上限,当到达这个值之后可以将进程重启。
  • 站在一个系统管理者的角度,如果能限制每组进程所能使用的内存量,那么不管程序的质量如何,都能将它们对系统的影响降到最低,从而保证整个系统的稳定性。

内存控制能控制些什么?

  • 限 制 cgroup 中所有进程所能使用的物理内存总量
  • 限制 cgroup 中所有进程所能使用的物理内存+交换空间总量(CONFIG_MEMCG_SWAP): 一般在 server 上,不太会用到 swap 空间,所以不在这里介绍这部分内容。
  • 限制 cgroup 中所有进程所能使用的内核内存总量及其它一些内核资源(CONFIG_MEMCG_KMEM): 限制内核内存有什么用呢?其实限制内核内存就是限制当前 cgroup 所能使用的内核资源,比如进程的内核栈空间,socket 所占用的内存空间等,通过限制内核内存,当内存吃紧时,可以阻止当前 cgroup 继续创建进程以及向内核申请分配更多的内核资源。由于这块功能被使用的较少,本篇中也不对它做介绍。

创建子 cgroup

在 /sys/fs/cgroup/memory 下创建一个子目录就算是创建了一个子 cgroup

root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory# cd /sys/fs/cgroup/memory
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory# mkdir test
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory# ls test/
cgroup.clone_children           memory.kmem.tcp.max_usage_in_bytes  memory.oom_control
cgroup.event_control            memory.kmem.tcp.usage_in_bytes      memory.pressure_level
cgroup.procs                    memory.kmem.usage_in_bytes          memory.soft_limit_in_bytes
memory.failcnt                  memory.limit_in_bytes               memory.stat
memory.force_empty              memory.max_usage_in_bytes           memory.swappiness
memory.kmem.failcnt             memory.memsw.failcnt                memory.usage_in_bytes
memory.kmem.limit_in_bytes      memory.memsw.limit_in_bytes         memory.use_hierarchy
memory.kmem.max_usage_in_bytes  memory.memsw.max_usage_in_bytes     notify_on_release
memory.kmem.tcp.failcnt         memory.memsw.usage_in_bytes         tasks
memory.kmem.tcp.limit_in_bytes  memory.move_charge_at_immigrate

从上面 ls 的输出可以看出,除了每个 cgroup 都有的那几个文件外,和 memory 相关的文件还不少,这里先做个大概介绍(kernel 相关的文件除外),后面会详细介绍每个文件的作用:

 cgroup.event_control       #用于eventfd的接口
 memory.usage_in_bytes      #显示当前已用的内存
 memory.limit_in_bytes      #设置/显示当前限制的内存额度
 memory.failcnt             #显示内存使用量达到限制值的次数
 memory.max_usage_in_bytes  #历史内存最大使用量
 memory.soft_limit_in_bytes #设置/显示当前限制的内存软额度
 memory.stat                #显示当前cgroup的内存使用情况
 memory.use_hierarchy       #设置/显示是否将子cgroup的内存使用情况统计到当前cgroup里面
 memory.force_empty         #触发系统立即尽可能的回收当前cgroup中可以回收的内存
 memory.pressure_level      #设置内存压力的通知事件,配合cgroup.event_control一起使用
 memory.swappiness          #设置和显示当前的swappiness
 memory.move_charge_at_immigrate #设置当进程移动到其他cgroup中时,它所占用的内存是否也随着移动过去
 memory.oom_control         #设置/显示oom controls相关的配置
 memory.numa_stat           #显示numa相关的内存

添加进程

也是往 cgroup 中添加进程只要将进程号写入 cgroup.procs 就可以了。

#重新打开一个shell窗口,避免相互影响
root@DESKTOP-9K4GB6E:~# cd /sys/fs/cgroup/memory/test/
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# echo $$ >> cgroup.procs
#运行top命令,这样这个cgroup消耗的内存会多点,便于观察
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# top
# 后续操作不再在这个窗口进行,避免在这个bash中运行进程影响cgropu里面的进程数及相关统计

设置限额

设置限额很简单,将阈值写入 memory.limit_in_bytes 文件就可以了,例如:

  • echo 1M > memory.limit_in_bytes:限制只能用 1M 内存
  • echo -1 > memory.limit_in_bytes:-1 则是不限制
#回到第一个shell窗口
#开始设置之前,看看当前使用的内存数量,这里的单位是字节
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# cat memory.usage_in_bytes
2379776
#设置1M的限额
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# echo 1M > memory.limit_in_bytes
#设置完之后记得要查看一下这个文件,因为内核要考虑页对齐, 所以生效的数量不一定完全等于设置的数量
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# cat memory.usage_in_bytes
950272
#如果不再需要限制这个cgroup,写-1到文件memory.limit_in_bytes即可
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# echo -1 > memory.limit_in_bytes
#这时可以看到limit被设置成了一个很大的数字
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# cat memory.limit_in_bytes
9223372036854771712

如果设置的限额比当前已经使用的内存少呢?

root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# free -h
              total        used        free      shared  buff/cache   available
Mem:          7.7Gi       253Mi       7.4Gi       0.0Ki        95Mi       7.3Gi
Swap:         2.0Gi       0.0Ki       2.0Gi
# 此时用了 1232K
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# cat memory.usage_in_bytes
1232896
# 限制成500K
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# echo 500k > memory.limit_in_bytes
# 再次查看发现现在只用了401K
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# cat memory.usage_in_bytes
401408
# 发现swap多了1M,说明另外的数据被转移到swap上了
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# free -h
              total        used        free      shared  buff/cache   available
Mem:          7.7Gi       254Mi       7.4Gi       0.0Ki        94Mi       7.3Gi
Swap:         2.0Gi       1.0Mi       2.0Gi
#这个时候再来看failcnt,发现有381次之多(隔几秒再看这个文件,发现次数在增长)
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# cat memory.failcnt
381
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# cat memory.failcnt
385

#再看看memory.stat(这里只显示部分内容),发现物理内存用了400K,
#但有很多pgmajfault以及pgpgin和pgpgout,说明发生了很多的swap in和swap out
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# cat memory.stat
swap 946176 # 946K 差不多刚好是内存中少的量
pgpgin 30492
pgpgout 30443
pgfault 23859
pgmajfault 12507

从上面的结果可以看出,当物理内存不够时,就会触发 memory.failcnt 里面的数量加 1,但进程不会被 kill 掉,那是因为内核会尝试将物理内存中的数据移动到 swap 空间中,从而让内存分配成功。

如果设置的限额过小,就算 swap out 部分内存后还是不够会怎么样?

#--------------------------第一个shell窗口----------------------
# 限制到100k
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# echo 100K > memory.limit_in_bytes

#--------------------------第二个shell窗口----------------------
# 尝试执行 top 发现刚运行就被Kill了
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# top
Killed

从上面的这些测试可以看出,一旦设置了内存限制,将立即生效,并且当物理内存使用量达到 limit 的时候,memory.failcnt 的内容会加 1,但这时进程不一定就会

被 kill 掉,内核会尽量将物理内存中的数据移到 swap 空间上去,如果实在是没办法移动了(设置的 limit 过小,或者 swap 空间不足),默认情况下,就会 kill 掉 cgroup 里面继续申请内存的进程。

行为控制

通过修改memory.oom_control文件,可以控制 subsystem 在物理内存达到上限时的行为。文件中包含以下 3 个参数:

  • oom_kill_disable:是否启用 oom kill
    • 0:关闭
    • 1:开启
  • under_oom:表示当前是否已经进入 oom 状态,也即是否有进程被暂停了。
  • oom_kill:oom 后是否执行 kill
    • 1:启动,oom 后直接 kill 掉对应进程
    • 2:关闭:当内核无法给进程分配足够的内存时,将会暂停该进程直到有空余的内存之后再继续运行。同时会更新 under_oom 状态
    • 注意:root cgroup 的 oom killer 是不能被禁用的

为了演示 OOM-killer 的功能,创建了下面这样一个程序,用来向系统申请内存,它会每秒消耗 1M 的内存。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define MB (1024 * 1024)

int main(int argc, char *argv[])
{
    char *p;
    int i = 0;
    while(1) {
        p = (char *)malloc(MB);
        memset(p, 0, MB);
        printf("%dM memory allocated\n", ++i);
        sleep(1);
    }

    return 0;
}

保存上面的程序到文件~/mem-allocate.c,然后编译并测试

#--------------------------第一个shell窗口----------------------
#编译上面的文件
dev@dev:/sys/fs/cgroup/memory/test$ gcc ~/mem-allocate.c -o ~/mem-allocate
#设置内存限额为5M
dev@dev:/sys/fs/cgroup/memory/test$ sudo sh -c "echo 5M > memory.limit_in_bytes"
#将当前bash加入到test中,这样这个bash创建的所有进程都会自动加入到test中
dev@dev:/sys/fs/cgroup/memory/test$ sudo sh -c "echo $$ >> cgroup.procs"
#默认情况下,memory.oom_control的值为0,即默认启用oom killer
dev@dev:/sys/fs/cgroup/memory/test$ cat memory.oom_control
oom_kill_disable 0
under_oom 0
#为了避免受swap空间的影响,设置swappiness为0来禁止当前cgroup使用swap
dev@dev:/sys/fs/cgroup/memory/test$ sudo sh -c "echo 0 > memory.swappiness"
#当分配第5M内存时,由于总内存量超过了5M,所以进程被kill了
dev@dev:/sys/fs/cgroup/memory/test$ ~/mem-allocate
1M memory allocated
2M memory allocated
3M memory allocated
4M memory allocated
Killed

#设置oom_control为1,这样内存达到限额的时候会暂停
dev@dev:/sys/fs/cgroup/memory/test$ sudo sh -c "echo 1 >> memory.oom_control"
#跟预期的一样,程序被暂停了
dev@dev:/sys/fs/cgroup/memory/test$ ~/mem-allocate
1M memory allocated
2M memory allocated
3M memory allocated
4M memory allocated

#--------------------------第二个shell窗口----------------------
#再打开一个窗口
dev@dev:~$ cd /sys/fs/cgroup/memory/test/
#这时候可以看到memory.oom_control里面under_oom的值为1,表示当前已经oom了
dev@dev:/sys/fs/cgroup/memory/test$ cat memory.oom_control
oom_kill_disable 1
under_oom 1
#修改test的额度为7M
dev@dev:/sys/fs/cgroup/memory/test$ sudo sh -c "echo 7M > memory.limit_in_bytes"

#--------------------------第一个shell窗口----------------------
#再回到第一个窗口,会发现进程mem-allocate继续执行了两步,然后暂停在6M那里了
dev@dev:/sys/fs/cgroup/memory/test$ ~/mem-allocate
1M memory allocated
2M memory allocated
3M memory allocated
4M memory allocated
5M memory allocated
6M memory allocated

# 创建上面的文件并编译
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# vim ~/mem-allocate.c
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# gcc ~/mem-allocate.c -o ~/mem-allocate
# 限制5M的上限
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# echo 5M > memory.limit_in_bytes
#将当前bash加入到test中,这样这个bash创建的所有进程都会自动加入到test中
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# echo $$ >> cgroup.procs
#默认情况下,会启用oom killer
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# cat memory.oom_control
oom_kill_disable 0
under_oom 0
oom_kill 1
#为了避免受swap空间的影响,设置swappiness为0来禁止当前cgroup使用swap
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# echo 0 > memory.swappiness
#当分配第5M内存时,由于总内存量超过了5M,所以进程被kill了
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# ~/mem-allocate
1M memory allocated
2M memory allocated
3M memory allocated
4M memory allocated
Killed
#设置oom_control为1,这样内存达到限额的时候会暂停
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# echo 1 >> memory.oom_control
#跟预期的一样,程序被暂停了
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# ~/mem-allocate
1M memory allocated
2M memory allocated
3M memory allocated
4M memory allocated

#--------------------------第二个shell窗口----------------------
#再打开一个窗口
dev@dev:~$ cd /sys/fs/cgroup/memory/test/
#这时候可以看到memory.oom_control里面under_oom的值为1,表示当前已经oom了
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# cat memory.oom_control
oom_kill_disable 1
under_oom 1
oom_kill 2
#修改test的额度为7M
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# echo 7M > memory.limit_in_bytes

# 切换会第一个窗口,发送程序又跑了两步,停在了6M
root@DESKTOP-9K4GB6E:/sys/fs/cgroup/memory/test# ~/mem-allocate
1M memory allocated
2M memory allocated
3M memory allocated
4M memory allocated
5M memory allocated
6M memory allocated

其他

进程迁移(migration)

当一个进程从一个 cgroup 移动到另一个 cgroup 时,默认情况下,该进程已经占用的内存还是统计在原来的 cgroup 里面,不会占用新 cgroup 的配额,但新分配的内存会统计到新的 cgroup 中(包括 swap out 到交换空间后再 swap in 到物理内存中的部分)。

我们可以通过设置 memory.move_charge_at_immigrate 让进程所占用的内存随着进程的迁移一起迁移到新的 cgroup 中。

enable: echo 1 > memory.move_charge_at_immigrate
disable:echo 0 > memory.move_charge_at_immigrate

注意: 就算设置为 1,但如果不是 thread group 的 leader,这个 task 占用的内存也不能被迁移过去。

换句话说,如果以线程为单位进行迁移,必须是进程的第一个线程,如果以进程为单位进行迁移,就没有这个问题。

当 memory.move_charge_at_immigrate 被设置成 1 之后,进程占用的内存将会被统计到目的 cgroup 中,如果目的 cgroup 没有足够的内存,系统将尝试回收目的 cgroup 的部分内存(和系统内存紧张时的机制一样,删除不常用的 file backed 的内存或者 swap out 到交换空间上,请参考Linux 内存管理),如果回收不成功,那么进程迁移将失败。

注意:迁移内存占用数据是比较耗时的操作。

移除 cgroup

当 memory.move_charge_at_immigrate 为 0 时,就算当前 cgroup 中里面的进程都已经移动到其它 cgropu 中去了,由于进程已经占用的内存没有被统计过去,当前 cgroup 有可能还占用很多内存,当移除该 cgroup 时,占用的内存需要统计到谁头上呢?

答案是依赖 memory.use_hierarchy 的值,

  • 如果该值为 0,将会统计到 root cgroup 里;
  • 如果值为 1,将统计到它的父 cgroup 里面。

force_empty

当向 memory.force_empty 文件写入 0 时(echo 0 > memory.force_empty),将会立即触发系统尽可能的回收该 cgroup 占用的内存。该功能主要使用场景是移除 cgroup 前(cgroup 中没有进程),先执行该命令,可以尽可能的回收该 cgropu 占用的内存,这样迁移内存的占用数据到父 cgroup 或者 root cgroup 时会快些。

memory.swappiness

该文件的值默认和全局的 swappiness(/proc/sys/vm/swappiness)一样,修改该文件只对当前 cgroup 生效,其功能和全局的 swappiness 一样,请参考Linux 交换空间中关于 swappiness 的介绍。

注意:有一点和全局的 swappiness 不同,那就是如果这个文件被设置成 0,就算系统配置的有交换空间,当前 cgroup 也不会使用交换空间。

memory.use_hierarchy

该文件内容为 0 时,表示不使用继承,即父子 cgroup 之间没有关系;当该文件内容为 1 时,子 cgroup 所占用的内存会统计到所有祖先 cgroup 中。

如果该文件内容为 1,当一个 cgroup 内存吃紧时,会触发系统回收它以及它所有子孙 cgroup 的内存。

注意: 当该 cgroup 下面有子 cgroup 或者父 cgroup 已经将该文件设置成了 1,那么当前 cgroup 中的该文件就不能被修改。

#当前cgroup和父cgroup里都是1
dev@dev:/sys/fs/cgroup/memory/test$ cat memory.use_hierarchy
1
dev@dev:/sys/fs/cgroup/memory/test$ cat ../memory.use_hierarchy
1

#由于父cgroup里面的值为1,所以修改当前cgroup的值失败
dev@dev:/sys/fs/cgroup/memory/test$ sudo sh -c "echo 0 > ./memory.use_hierarchy"
sh: echo: I/O error

#由于父cgroup里面有子cgroup(至少有当前cgroup这么一个子cgroup),
#修改父cgroup里面的值也失败
dev@dev:/sys/fs/cgroup/memory/test$ sudo sh -c "echo 0 > ../memory.use_hierarchy"
sh: echo: I/O error

memory.soft_limit_in_bytes

有了 hard limit(memory.limit_in_bytes),为什么还要 soft limit 呢?hard limit 是一个硬性标准,绝对不能超过这个值。

而 soft limit 可以被超越,既然能被超越,要这个配置还有啥用?先看看它的特点

  • 1)当系统内存充裕时,soft limit 不起任何作用
  • 2)当系统内存吃紧时,系统会尽量的将 cgroup 的内存限制在 soft limit 值之下(内核会尽量,但不 100% 保证)

从它的特点可以看出,它的作用主要发生在系统内存吃紧时,如果没有 soft limit,那么所有的 cgroup 一起竞争内存资源,占用内存多的 cgroup 不会让着内存占用少的 cgroup,这样就会出现某些 cgroup 内存饥饿的情况。如果配置了 soft limit,那么当系统内存吃紧时,系统会让超过 soft limit 的 cgroup 释放出超过 soft limit 的那部分内存(有可能更多),这样其它 cgroup 就有了更多的机会分配到内存。

从上面的分析看出,这其实是系统内存不足时的一种妥协机制,给次等重要的进程设置 soft limit,当系统内存吃紧时,把机会让给其它重要的进程。

注意: 当系统内存吃紧且 cgroup 达到 soft limit 时,系统为了把当前 cgroup 的内存使用量控制在 soft limit 下,在收到当前 cgroup 新的内存分配请求时,就会触发回收内存操作,所以一旦到达这个状态,就会频繁的触发对当前 cgroup 的内存回收操作,会严重影响当前 cgroup 的性能。

memory.pressure_level

这个文件主要用来监控当前 cgroup 的内存压力,当内存压力大时(即已使用内存快达到设置的限额),在分配内存之前需要先回收部分内存,从而影响内存分配速度,影响性能,而通过监控当前 cgroup 的内存压力,可以在有压力的时候采取一定的行动来改善当前 cgroup 的性能,比如关闭当前 cgroup 中不重要的服务等。目前有三种压力水平:

  • low

    • 意味着系统在开始为当前 cgroup 分配内存之前,需要先回收内存中的数据了,这时候回收的是在磁盘上有对应文件的内存数据。
  • medium

    • 意味着系统已经开始频繁为当前 cgroup 使用交换空间了。
  • critical

    • 快撑不住了,系统随时有可能 kill 掉 cgroup 中的进程。

如何配置相关的监听事件呢?和 memory.oom_control 类似,大概步骤如下:

  1. 利用函数 eventfd(2) 创建一个 event_fd
  2. 打开文件 memory.pressure_level,得到 pressure_level_fd
  3. 往 cgroup.event_control 中写入这么一串:<event_fd> <pressure_level_fd> <level>
  4. 然后通过读 event_fd 得到通知

注意: 多个 level 可能要创建多个 event_fd,好像没有办法共用一个

Memory thresholds

我们可以通过 cgroup 的事件通知机制来实现对内存的监控,当内存使用量穿过(变得高于或者低于)我们设置的值时,就会收到通知。使用方法和 memory.oom_control 类似,大概步骤如下:

  1. 利用函数 eventfd(2) 创建一个 event_fd
  2. 打开文件 memory.usage_in_bytes,得到 usage_in_bytes_fd
  3. 往 cgroup.event_control 中写入这么一串:<event_fd> <usage_in_bytes_fd> <threshold>
  4. 然后通过读 event_fd 得到通知

stat file

这个文件包含的统计项比较细,需要一些内核的内存管理知识才能看懂,这里就不介绍了(怕说错)。详细信息可以参考 Memory Resource Controller中的“5.2 stat file”。这里有几个需要注意的地方:

  • 里面 total 开头的统计项包含了子 cgroup 的数据(前提条件是 memory.use_hierarchy 等于 1)。
  • 里面的 'rss + file_mapped" 才约等于是我们常说的 RSS(ps aux 命令看到的 RSS)
  • 文件(动态库和可执行文件)及共享内存可以在多个进程之间共享,不过它们只会统计到他们的 owner cgroup 中的 file_mapped 去。(不确定是怎么定义 owner 的,但如果看到当前 cgroup 的 file_mapped 值很小,说明共享的数据没有算到它头上,而是其它的 cgroup)

小结

作用:限制 cgroups 中的进程占用的内存上限

用法:

  • 1)memory.limit_in_bytes 配置进程可以使用的内存上限(hard limit),当超过该阈值时,一般是尝试使用 swap,如果不行则直接 kill 掉。
  • 2)memory.soft_limit_in_bytes 配置进程可以使用的内存上行(soft limit),当系统内存不足时,cgroups 会优先将使用量超过 soft limit 的进程进行内存回收,腾出内存。
  • 3)memory.oom_control 参数配置内存使用量到达阈值时内核的处理行为,默认为 oom_kill。

原理:当进程使用内存超过memory.limit_in_bytes 之后,系统会根据 memory.oom_control 配置的行为进行处理,一般是尝试使用 swap,如果不行则直接 kill 掉。

本节没有介绍 swap 和 kernel 相关的内容,不过在实际使用过程中一定要留意 swap 空间,如果系统使用了交换空间,那么设置限额时一定要注意一点,那就是当 cgroup 的物理空间不够时,内核会将不常用的内存 swap out 到交换空间上,从而导致一直不触发 oom killer,而是不停的 swap out/in,导致 cgroup 中的进程运行速度很慢。

如果一定要用交换空间,最好的办法是限制 swap+物理内存 的额度,虽然我们在这篇中没有介绍这部分内容,但其使用方法和限制物理内存是一样的,只是换做写文件 memory.memsw.limit_in_bytes 罢了。

4. 小结

本文主要简单介绍了 pid、cpu、memory 这三个 subsystem 的作用和基本使用,具体如下:

subsystem功能用法原理备注
pid限制 cgroups 中进程使用的 pid 数配置 subsystem 中的 pids.max 即可当 cgroups 中的进程调用 fork 或者 clone 系统调用时会判断,subsystem 中配置的 pids.max 和当前 pids.current 的值,来确定是否能够创建新的进程(或线程)linux 中的 pid 是有限的,通过该 subsystem 可以有效防止 fork 炸弹之类的恶意进程
cpu限制 cgroups 中进程使用的 cpu 上限1)限制为具体值:用 cfs_period_us & cfs_quota_us 两个配置可以严格限制进程 cpu 使用量。 2)按比例分配:用 shares 配置,可以使得多个 cgroups 之间按比例分配所有 cpu。subsystem 负责提供配置,cfs 负责记录进程使用的 cpu 时间,达到阈值后就从调度层面进行限制,避免该进程继续使用 cpu。一般使用 cfs_period_us & cfs_quota_us 方式限制具体值用得比较多。
memory限制 cgroups 中进程使用的 memory 上限1)memory.limit_in_bytes 配置进程可以使用的内存上限(hard limit),当超过该阈值时,一般是尝试使用 swap,如果不行则直接 kill 掉。 2)memory.soft_limit_in_bytes 配置进程可以使用的内存上行(soft limit),当系统内存不足时,cgroups 会优先将使用量超过 soft limit 的进程进行内存回收,腾出内存。 3)memory.oom_control 参数配置内存使用量到达阈值时内核的处理行为,默认为 oom_kill。当进程使用内存超过memory.limit_in_bytes 之后,系统会根据 memory.oom_control 配置的行为进行处理,一般是尝试使用 swap,如果不行则直接 kill 掉。如果系统使用了交换空间,那么设置限额时一定要注意一点,那就是当 cgroup 的物理空间不够时,内核会将不常用的内存 swap out 到交换空间上,从而导致一直不触发 oom killer,而是不停的 swap out/in,导致 cgroup 中的进程运行速度很慢。

如果你对云原生技术充满好奇,想要深入了解更多相关的文章和资讯,欢迎关注微信公众号。

搜索公众号【探索云原生】即可订阅


5. 参考

cgroups(7) — Linux manual page

美团技术团队—Linux 资源管理之 cgroups 简介

Red Hat—资源管理指南

`/sys/fs/cgroup/memory` 目录下文件的含义 目录下的这些文件是用于控制和监视 Linux 系统中的内存资源管理的参数和统计信息。: 对应 Kubernetes pod 的 cgroup。: 控制子进程是否继承其父进程的 cgroup 上下文。: 对应一个 KNP NMS Necho 代理的文件。: 对应一个 KNP NSS NetQ 代理的文件。: 控制是否启用了 cgroup 的安全行为模式。: 用于控制 cgroup 事件的注册和注销。: 对应一个基础设施 Kess 代理的文件。: 对应一个 KFS 代理的文件。: 对应一个基础设施代理的文件。 阅读详情

相关推荐

深入解析Linux Cgroups:从内核原理到容器化资源管理实战

在Linux系统资源管理中,进程组资源控制是一项基础且关键的技术。其核心原理是通过内核提供的控制组机制,将进程分组并对各组进行统一的资源分配与限制。这项技术的核心价值在于实现精细化的资源隔离与配额管理,确保系统资源的公平使用和稳定性。在应用场景上,它不仅是防止单个进程耗尽CPU、内存等系统资源的有效手段,更是现代容器化技术(如Docker、Kubernetes)实现资源隔离的基石。通过配置CPU、内存、I/O等子系统,可以精确控制进程的资源使用上限。本文聚焦于Cgroups这一核心机制,结合生产环境中常见的

weixin_32520095的博客 325

Linux Cgroups进程资源限制管理 之 资源子系统限制/控制、Docker资源隔离与限制原理解读

而对于 Docker 等 Linux 容器项目来说,它们只需要在每个子系统下面,为每个容器创建一个控制组(即创建一个新目录),然后在启动容器进程之后,把这个进程的 PID 填写到对应控制组的 tasks 文件中就可以了。结合前面的介绍,这意味着在每 100 ms 的时间里,被该控制组限制的进程只能使用 20 ms 的 CPU 时间,也就是说这个进程只能使用到 20% 的 CPU 带宽。blkio,为​​​块​​​设​​​备​​​设​​​定​​​I/O 限​​​制,一般用于磁盘等设备;

weixin_51910506的博客 1409

Linux cgroups资源隔离机制详解与实践指南

Linux系统中的进程资源管理是系统调优的重要环节,cgroups(Control Groups)作为内核级资源隔离机制,通过进程分组实现对CPU、内存、I/O等资源的精细化控制。其核心原理是通过多个子系统(如cpu、memory、blkio等)设置资源配额和权重,相比虚拟机方案具有更低开销。在容器化部署、多租户环境等场景下,cgroups能有效解决资源争抢问题,保障关键业务稳定性。本文以生产环境常见问题为切入点,详细解析如何通过cgroups v2的memory.high等新特性进行资源限制,并给出sys

weixin_29292431的博客 314

linux 内核资源配置--cgroups详解以及在docker中的应用

linux 内核资源配置--cgroups详解以及在docker中的应用

岳来的博客 7403

LXC容器网络配置与监控管理实战:从VLAN到cgroups资源控制

容器技术通过Linux内核的命名空间和控制组(cgroups)实现进程隔离与资源管理,为应用提供轻量级、高性能的运行环境。其核心原理在于利用网络命名空间创建独立的网络栈,并通过虚拟网络设备(如veth、macvlan、VLAN)实现容器间及容器与外部网络的通信。在工程实践中,合理的网络配置与资源管控是保障容器稳定运行的关键,尤其在微服务架构和云原生场景下,网络隔离与性能优化直接影响系统可靠性。本文聚焦LXC容器的VLAN网络配置与cgroups资源限制,通过实战演示如何实现网络逻辑隔离和精细化CPU/内存控

weixin_34174422的博客 405

【CGroup原理篇V1】四、CGroup V1子系统概况

简单介绍CGroupV1各个子系统概况,以及查询系统支持的子系统的方法等。

从0到1,突破自己 1141

Linux资源控制的核心:万字长文深入剖析Cgroups机制与实战

在现代计算环境中,无论是单台物理服务器、虚拟机还是成千上万的容器集群,我们都面临着一个共同的挑战:如何公平、高效、可控地分配和管理系统资源。想象一下,一个多租户的服务器上,如果一个用户的应用程序因为代码缺陷陷入死循环,占用了100%的CPU资源,那么其他所有用户的应用都将陷入停滞,整个系统的服务质量(QoS)将无从谈起。同样,如果一个数据分析任务瞬间消耗掉所有内存,可能会触发系统的OOM(Out-of-Memory)Killer,误杀掉关键的系统进程,导致系统崩溃。

2301_80863610的博客 1万+

操作系统 cgroups 对进程资源的有效管理

在多任务操作系统中,进程就像一群抢玩具的小朋友:有的"贪心"进程会霸占CPU不放,有的"大胃王"进程会吃掉所有内存,导致其他进程"饿肚子"。cgroups正是Linux内核为解决这个问题设计的机制,它能对进程的CPU、内存、磁盘IO等资源进行限制、统计和隔离。本文将覆盖cgroups的核心概念、工作原理、实战操作以及在容器中的应用。本文将按照"故事引入→核心概念→原理剖析→实战操作→应用场景"的逻辑展开,最后总结未来趋势。你不需要提前了解内核知识,只需带着"如何让进程公平使用资源"的问题往下读。子系统。

操作系统内核探秘的博客 431

Linux内核中的cgroups技术详解

cgroups是Linux内核中的一种机制,用于限制、记录和隔离进程组的资源使用(如CPU、内存、磁盘I/O、网络等)。cgroups可以将进程组织成层次化的树状结构,每个节点可以设置不同的资源限制。

jiang_style的博客 4366

数据驱动的老年人健康管理与生活品质提升实践研究

摘要 全球人口老龄化趋势显著,2025年65岁以上人口预计达8.57亿,中国老年人口已突破3亿。老年人健康挑战突出,75%以上患慢性病,且独居老人心理健康与应急需求迫切。数据驱动的健康管理通过智能设备(如跌倒检测、远程监测)和AI技术(如疾病预测算法)提升效率,改善生活品质。研究提出差异化需求解决方案,如慢性病患者的持续监测与用药管理,高龄老人的综合护理服务,并探讨政策与商业模式以推动智慧养老产业发展,2024年市场规模已达6.8万亿元。

聚焦程序设计语言理论与前沿技术落地,拆解代码世界的底层逻辑,探索语言设计的 “创造与沟通” 之道。从编译原理、类型系统到 AI 技术在金融、医疗、制造、养老、大健康等领域的实战案例,分享硬核技术干货与工程化思考。 1634

pgAdmin4备份恢复实战:从安装到避坑指南

本文提供了一份详尽的pgAdmin4备份恢复实战指南,涵盖从安装配置到执行备份恢复的全流程。针对Windows环境下的浏览器兼容性、二进制路径配置等常见问题,给出了具体解决方案。重点强调了使用pgAdmin4进行备份恢复的可靠性,特别是在处理包含PostGIS等扩展的数据库时,能有效避免数据类型和权限错误,确保数据迁移的完整性与安全性。

weixin_29266007的博客 439

【Linux】拆解 Linux 容器化核心:Namespace 隔离 + cgroups 资源控制,附 LXC 容器生命周期实战

本文介绍了虚拟化与容器化技术的核心概念与实现原理。主要内容包括:1)物理机、虚拟化(VM)和容器化(Docker)的定义与区别;2)虚拟化技术优势(资源利用率、环境一致性、弹性扩展);3)容器虚拟化实现原理(Namespace隔离与cgroups资源控制);4)LXC容器技术实践(安装、创建Ubuntu容器及生命周期管理)。文章通过技术对比、原理剖析和实操演示,系统性地阐释了现代虚拟化技术在资源管理和应用部署中的核心作用。

2302_79806056的博客 5118

第四届“网鼎杯”网络安全大赛 - 青龙组

第四届“网鼎杯”网络安全大赛 - 青龙组

lpppp小公主的博客 1315

深入解析Linux cgroups:资源隔离与容器技术基石

cgroups(控制组)是Linux内核提供的资源管理机制,通过进程分组实现对CPU、内存等系统资源的分配与限制。其核心原理是通过子系统(subsystem)架构,将不同资源控制器(如cpu、memory)挂载到统一的层级结构中。作为容器技术的底层支撑,cgroups在Docker和Kubernetes中实现资源隔离与配额管理,同时被systemd用于系统服务资源控制。最新v2版本采用单一层级树设计,解决了v1多层级管理的复杂性,提供更精确的线程级控制和内存保护特性。对于云计算和微服务场景,合理配置cgro

diankui6178的博客 493

RC滤波电路实战解析:无源与有源设计的性能对比与应用选择

本文深入解析了RC滤波电路的核心原理,重点对比了无源滤波电路与有源滤波电路的性能差异。文章通过实测波形与仿真数据,详细阐述了两者在带载能力、频率响应精度、噪声特性等方面的优劣,并提供了清晰的应用选择指南,帮助工程师根据信号属性、负载条件和性能要求做出最优设计决策。

weixin_29268637的博客 431

华为服务器RAID配置避坑指南:如何通过iBMC快速识别阵列卡型号并完成初始化

本文详细解析华为服务器RAID配置全流程,重点介绍通过iBMC快速识别阵列卡型号、硬盘健康诊断及RAID级别选择的场景化策略。提供从iBMC登录到缓存策略调优的实战技巧,帮助工程师避免常见配置陷阱,提升服务器存储系统性能和稳定性。

weixin_28475533的博客 492

Linux Cgroups概述

https://cloud.tencent.com/developer/article/1574064

cl2010abc的专栏 470

AutoSAR系列讲解(深入篇)14.7-Mcal Adc配置(上)

详细讲解了ADC的各个配置项的作用

雪云飞星的博客 1万+

Cgroups是什么

原文地址:https://www.cnblogs.com/lisperl/archive/2013/01/14/2860353.html 作者:王喆锋 zhefwang@gmail.com(侵删) Cgroups是什么? Cgroups是control groups的缩写,是Linux内核提供的一种可以限制、记录、隔离进程组(process groups)所使用的物理资源(如:cpu,memory,IO等等)的机制。最初由google的工程师提出,后来被整合进Linux内核。Cgroups也是L.

RToax 1069

星载SAR的各项指标解读(史上最全)

一、系统指标 系统指标主要指雷达系统的通用的指标,以及和卫星整星相关的指标,主要有一下几项: 工作频段: 雷达体制: 极化方式: 设计s

9278

openlayers全面教程306+【目录】

vue+openlayers系列教程旨在为开发者提供简单快捷的示例。在每一个示例中,解释相应的API知识点。

大剑师兰特的GIS世界 2万+

从零开始写 Docker(三)---基于 cgroups 实现资源限制

本文为从零开始写 Docker 系列第三篇,在`mydocker run` 基础上基于 cgroups 实现容器的资源限制。

探索云原生 1005

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

揭秘容器资源失控真相:如何用cgroups强制限制Docker CPU占用

解决Docker容器资源失控难题,教你通过cgroups精准限制CPU使用率。适用于多租户环境与生产部署,实现资源隔离与性能稳定。方法简单高效,提升系统可靠性,值得收藏。

ProcePerch的博客 871

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

Linux 进程资源限制的深度剖析

Linux 的进程资源限制机制,本质是通过一套 “规则系统” 确保每个进程在合理范围内使用资源,就像家长管理孩子一样:既给予足够的自由度,又防止过度索取导致家庭(系统)崩溃。从基础的ulimit到强大的 cgroups,从单个进程到进程组的管理,这套机制是系统稳定性、安全性和公平性的核心保障。能预防 “进程失控” 导致的故障(如内存泄漏、文件句柄耗尽)。能为不同服务分配合理的资源配额(如数据库服务需要更多内存,Web 服务需要更多文件描述符)。能在容器化、微服务架构中实现细粒度的资源隔离。

Mr_-G,一名勤奋底层软件开发工程师的博客 1315

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

Linux Cgroups详解(二)

cgroups 数据结构设计 我们从进程出发来剖析cgroups相关数据结构之间的关系。 在Linux中,管理进程的数据结构是task_struct,其中与cgroups有关的: #ifdef CONFIG_CGROUPS     /* Control Group info protected by css_set_lock */     struct css_set *cgroups;

华的专栏 1223

Linux资源管理之cgroups简介

转自:http://blog.youkuaiyun.com/hzrandd/article/details/52484332 cgroups 是Linux内核提供的一种可以限制单个进程或者多个进程所使用资源的机制,可以对 cpu,内存等资源实现精细化的控制,目前越来越火的轻量级容器 Docker 就使用了 cgroups 提供的资源限制能力来完成cpu,内存等部分的资源控制。 另外,开发者

空杯心态_虚怀若谷 183
上一篇: 我的创作纪念日
下一篇: Docker 与 Linux Cgroups:资源隔离的魔法之旅
探索云原生
博客等级 码龄9年 730粉丝 131原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值