Docker 与 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版的内核中去。 阅读详情

docker-logo

这篇文章主要介绍了 Docker 如何利用 Linux 的 Control Groups(cgroups)实现容器的资源隔离和管理。

最后通过简单 Demo 演示了如何使用 Go 和 cgroups 交互。


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

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


1.Docker 是如何使用 Cgroups 的

我们知道 Docker 是通过 Cgroups 实现容器资源限制和监控的,那么具体是怎么用的呢?

演示

包含以下步骤:

  • 1)创建容器,指定内存限制
  • 2)查看 cgroup 情况
  • 3)停止容器
  • 4)再次查看 cgroup 情况

先启动一个容器:

[root@iZ2zefmrr626i66omb40ryZ memory]# docker run -itd -m 128m nginx
da82f9ebd384730dda7f831b4331c9e55893c100c83c0c9b0ce112436aa93416

这里通过-m参数设置了内存限制为 128M。

该命令执行后 docker 会在 memory cgroup 上(也就是 /sys/fs/cgroup/memory 路径下)创建一个叫 docker 的子 cgroup,具体如下:

$ ls -l /sys/fs/cgroup/memory/docker/
-rw-r--r-- 1 root root 0 Jan  6 19:53 cgroup.clone_children
--w--w--w- 1 root root 0 Jan  6 19:53 cgroup.event_control
-rw-r--r-- 1 root root 0 Jan  6 19:53 cgroup.procs
# 可以发现这一长串ID和创建容器时打印的是一致的
drwxr-xr-x 2 root root 0 Jan  6 19:56 da82f9ebd384730dda7f831b4331c9e55893c100c83c0c9b0ce112436aa93416
# 省略其他文件

内部除了 cgroup 相关的文件外,还有很多目录,使用容器 ID 作为目录名,其中每个目录即对应一个容器。

其中,da82f9e...这个目录名称和容器 ID 一致,说明 docker 是为每个容器创建了一个子 cgroup 来单独限制。

查看一下里面的具体配置:

[root@iZ2zefmrr626i66omb40ryZ docker]# cd da82f9ebd384730dda7f831b4331c9e55893c100c83c0c9b0ce112436aa93416/
[root@iZ2zefmrr626i66omb40ryZ da82f9ebd384730dda7f831b4331c9e55893c100c83c0c9b0ce112436aa93416]# cat memory.limit_in_bytes
134217728

可以发现,memory.limit_in_bytes 中配置的值为 134217728,转换一下134217728/1024/1024=128M, 刚好就是我们指定的 128M。

然后我们停止该容器

docker stop da82f9ebd384730dda7f831b4331c9e55893c100c83c0c9b0ce112436aa93416

再次查看 cgroup 情况

ls -l /sys/fs/cgroup/memory/docker/|grep da82f9ebd384730dda7f831b4331c9e55893c100c83c0c9b0ce112436aa93416

发现目录已经被删除,说明容器对应的子 cgroup 也同步被回收。

把停止的容器 start 一下看看

docker start da82f9ebd384730dda7f831b4331c9e55893c100c83c0c9b0ce112436aa93416

再次查看 cgroup 情况

[root@docker ~]# ls -l /sys/fs/cgroup/memory/docker/|grep da82f9ebd384730dda7f831b4331c9e55893c100c83c0c9b0ce112436aa93416
drwxr-xr-x 2 root root 0 Jan  6 19:58 da82f9ebd384730dda7f831b4331c9e55893c100c83c0c9b0ce112436aa93416

可以看到,同名目录又被创建出来了。

至此,演示完成。

结论:Docker 容器启动时创建容器 ID 同名子 group 以实现资源控制,容器停止时删除该子 cgroup。

Demo 中只演示了内存限制,其他资源也是类似的

小结

所以 docker 使用 cgroup 其实很简单,

  • 1)为每个容器创建一个子 cgroup
  • 2)根据 docker run 时提供的参数调整 cgroup 中的配置
  • 3)容器被删除时同步删除对应子 cgroup

2.Cgroups 相关操作命令

这里记录一下 cgroups 的一些常用操作命令。

hierarchy

创建

由于 Linux Cgroups 是基于内核中的 cgroup virtual filesystem 的,所以创建 hierarchy 其实就是将其挂载到指定目录。

语法为: mount -t cgroup -o subsystems name /cgroup/name

  • 其中 subsystems 表示需要挂载的 cgroups 子系统
  • /cgroup/name 表示挂载点(一般为具体目录)

这条命令同在内核中创建了一个 hierarchy 以及一个默认的 root cgroup。

例如:

$ mkdir cg1
$ mount -t cgroup -o cpuset cg1 ./cg1

比如以上命令就是挂载一个 cg1 的 hierarchy 到 ./cg1 目录,如果指定的 hierarchy 不存在则会新建。

hierarchy 创建的时候就会就会自动创建一个 cgroup 以作为 cgroup 树中的 root 节点。

删除

删除 hierarchy 则是卸载。

语法为:umount /cgroup/name

  • /cgroup/name 表示挂载点(一般为具体目录)

例如:

$ umount ./cg1

以上命令就是卸载 ./cg1 这个目录上挂载的 hierarchy,也就是前面挂载的 cg。

hierarchy 卸载后,相关的 cgroup 都会被删除。

不过 cg1 目录需要手动删除。

默认文件含义

hierarchy 挂载后会生成一些文件,具体如下:

为了避免干扰,未关联任何 subsystem

$ mkdir cg1
$ mount -t cgroup -o none,name=cg1 cg1 ./cg1
$ tree cg1
cg1
├── cgroup.clone_children
├── cgroup.procs
├── cgroup.sane_behavior
├── notify_on_release
├── release_agent
└── tasks

具体含义如下:

  • cgroup.clone_children:这个文件只对 cpuset subsystem 有影响,当该文件的内容为 1 时,新创建的 cgroup 将会继承父 cgroup
    的配置,即从父 cgroup 里面拷贝配置文件来初始化新
    cgroup,可以参考cgroup.clone_children
  • cgroup.procs:当前 cgroup 中的所有进程ID,系统不保证 ID 是顺序排列的,且 ID 有可能重复
  • cgroup.sane_behavior:这个文件只会存在于 root cgroup 下面,用于控制某些特性的开启和关闭。
    • 由于 cgroup 一直再发展,很多子系统有很多不同的特性,因此内核用CGRP_ROOT_SANE_BEHAVIOR来控制
  • notify_on_release:该文件的内容为 1 时,当 cgroup 退出时(不再包含任何进程和子 cgroup),将调用 release_agent 里面配置的命令。
    • 新 cgroup 被创建时将默认继承父 cgroup 的这项配置。
  • release_agent:里面包含了 cgroup 退出时将会执行的命令,系统调用该命令时会将相应 cgroup 的相对路径当作参数传进去。
    • 注意:这个文件只会存在于 root cgroup 下面,其他 cgroup 里面不会有这个文件。
    • 相当于配置一个回调用于清理资源。
  • tasks:当前 cgroup 中的所有线程 ID,系统不保证 ID 是顺序排列的

cgroup.procs 和 tasks 的区别见 cgroup 操作章节。

release_agent 演示

当一个 cgroup 里没有进程也没有子 cgroup 时,release_agent 将被调用来执行 cgroup 的清理工作。

具体操作流程:

  • 首先需要配置 notify_on_release 以开启该功能。
  • 然后将脚本内容写入到 release_agent 中去。
  • 最后 cgroup 退出时(不再包含任何进程和子 cgroup)就会执行 release_agent 中的命令。
#创建新的cgroup用于演示
dev@ubuntu:~/cgroup/demo$ sudo mkdir test
#先enable release_agent
dev@ubuntu:~/cgroup/demo$ sudo sh -c 'echo 1 > ./test/notify_on_release'

#然后创建一个脚本/home/dev/cgroup/release_demo.sh,
#一般情况下都会利用这个脚本执行一些cgroup的清理工作,但我们这里为了演示简单,仅仅只写了一条日志到指定文件
dev@ubuntu:~/cgroup/demo$ cat > /home/dev/cgroup/release_demo.sh << EOF
#!/bin/bash
echo \$0:\$1 >> /home/dev/release_demo.log
EOF

#添加可执行权限
dev@ubuntu:~/cgroup/demo$ chmod +x ../release_demo.sh

#将该脚本设置进文件release_agent
dev@ubuntu:~/cgroup/demo$ sudo sh -c 'echo /home/dev/cgroup/release_demo.sh > ./release_agent'
dev@ubuntu:~/cgroup/demo$ cat release_agent
/home/dev/cgroup/release_demo.sh

#往test里面添加一个进程,然后再移除,这样就会触发release_demo.sh
dev@ubuntu:~/cgroup/demo$ echo $$
27597
dev@ubuntu:~/cgroup/demo$ sudo sh -c 'echo 27597 > ./test/cgroup.procs'
dev@ubuntu:~/cgroup/demo$ sudo sh -c 'echo 27597 > ./cgroup.procs'

#从日志可以看出,release_agent被触发了,/test是cgroup的相对路径
dev@ubuntu:~/cgroup/demo$ cat /home/dev/release_demo.log
/home/dev/cgroup/release_demo.sh:/test

cgroup

创建

创建 cgroup 很简单,在父 cgroup 或者 hierarchy 目录下新建一个目录就可以了。

具体层级关系就和目录层级关系一样。

# 创建子cgroup cgroup-cpu
$ mkdir cgroup-cpu
$ cd cgroup-cpu
# 创建cgroup-cpu的子cgroup
$ mkdir cgroup-cpu-1

删除

删除也很简单,删除对应目录即可。

注意:是删除目录 rmdir,而不是递归删除目录下的所有文件。

如果有多层 cgroup 则需要先删除子 cgroup,否则会报错:

$ rmdir cgroup-cpu
# 如果cgroup中有进程正在本限制,也会出现这个错误,需要先停掉对应进程,或者把进程移动到另外的 cgroup 中(比如父cgroup)
rmdir: failed to remove 'cgroup-cpu': Device or resource busy

先删除子 cgroup 就可以了:

$ rmdir cg1
$ cd ../
$ rmdir cgroup-cpu

也可以借助 libcgroup 工具来创建或删除。

使用 libcgroup 工具前,请先安装 libcgroup 和 libcgroup-tools 数据包

redhat 系统安装:

$ yum install libcgroup
$ yum install libcgroup-tools

ubuntu 系统安装:

$ apt-get install cgroup-bin
# 如果提示cgroup-bin找不到,可以用 cgroup-tools 替换
$ apt-get install cgroup-tools

具体语法:

# controllers就是subsystem
# path可以用相对路径或者绝对路径
$ cgdelete controllers:path

例如:

$ cgcreate cpu:./mycgroup
$ cgdelete cpu:./mycgroup

添加进程

创建新的 cgroup 后,就可以往里面添加进程了。注意下面几点:

  • 在一颗 cgroup 树里面,一个进程必须要属于一个 cgroup。
    • 所以不能凭空从一个 cgroup 里面删除一个进程,只能将一个进程从一个 cgroup 移到另一个 cgroup
  • 新创建的子进程将会自动加入父进程所在的 cgroup。
    • 这也就是 tasks 和 cgroup.proc 的区别。
  • 从一个 cgroup 移动一个进程到另一个 cgroup 时,只要有目的 cgroup 的写入权限就可以了,系统不会检查源 cgroup 里的权限。
  • 用户只能操作属于自己的进程,不能操作其他用户的进程,root 账号除外。
#--------------------------第一个shell窗口----------------------
#创建一个新的cgroup
dev@ubuntu:~/cgroup/demo$ sudo mkdir test
dev@ubuntu:~/cgroup/demo$ cd test

#将当前bash加入到上面新创建的cgroup中
dev@ubuntu:~/cgroup/demo/test$ echo $$
1421
dev@ubuntu:~/cgroup/demo/test$ sudo sh -c 'echo 1421 > cgroup.procs'
#注意:一次只能往这个文件中写一个进程ID,如果需要写多个的话,需要多次调用这个命令

#--------------------------第二个shell窗口----------------------
#重新打开一个shell窗口,避免第一个shell里面运行的命令影响输出结果
#这时可以看到cgroup.procs里面包含了上面的第一个shell进程
dev@ubuntu:~/cgroup/demo/test$ cat cgroup.procs
1421

#--------------------------第一个shell窗口----------------------
#回到第一个窗口,随便运行一个命令,比如 top
dev@ubuntu:~/cgroup/demo/test$ top
#这里省略输出内容

#--------------------------第二个shell窗口----------------------
#这时再在第二个窗口查看,发现top进程自动加入了它的父进程(1421)所在的cgroup
dev@ubuntu:~/cgroup/demo/test$ cat cgroup.procs
1421
16515
dev@ubuntu:~/cgroup/demo/test$ ps -ef|grep top
dev      16515  1421  0 04:02 pts/0    00:00:00 top
dev@ubuntu:~/cgroup/demo/test$

#在一颗cgroup树里面,一个进程必须要属于一个cgroup,
#所以我们不能凭空从一个cgroup里面删除一个进程,只能将一个进程从一个cgroup移到另一个cgroup,
#这里我们将1421移动到root cgroup
dev@ubuntu:~/cgroup/demo/test$ sudo sh -c 'echo 1421 > ../cgroup.procs'
dev@ubuntu:~/cgroup/demo/test$ cat cgroup.procs
16515
#移动1421到另一个cgroup之后,它的子进程不会随着移动

#--------------------------第一个shell窗口----------------------
##回到第一个shell窗口,进行清理工作
#先用ctrl+c退出top命令
dev@ubuntu:~/cgroup/demo/test$ cd ..
#然后删除创建的cgroup
dev@ubuntu:~/cgroup/demo$ sudo rmdir test

cgroup.procs vs tasks

#创建两个新的cgroup用于演示
dev@ubuntu:~/cgroup/demo$ sudo mkdir c1 c2

#为了便于操作,先给root账号设置一个密码,然后切换到root账号
dev@ubuntu:~/cgroup/demo$ sudo passwd root
dev@ubuntu:~/cgroup/demo$ su root
root@ubuntu:/home/dev/cgroup/demo#

#系统中找一个有多个线程的进程
root@ubuntu:/home/dev/cgroup/demo# ps -efL|grep /lib/systemd/systemd-timesyncd
systemd+   610     1   610  0    2 01:52 ?        00:00:00 /lib/systemd/systemd-timesyncd
systemd+   610     1   616  0    2 01:52 ?        00:00:00 /lib/systemd/systemd-timesyncd
#进程610有两个线程,分别是610和616

#将616加入c1/cgroup.procs
root@ubuntu:/home/dev/cgroup/demo# echo 616 > c1/cgroup.procs
#由于cgroup.procs存放的是进程ID,所以这里看到的是616所属的进程ID(610)
root@ubuntu:/home/dev/cgroup/demo# cat c1/cgroup.procs
610
#从tasks中的内容可以看出,虽然只往cgroup.procs中加了线程616,
#但系统已经将这个线程所属的进程的所有线程都加入到了tasks中,
#说明现在整个进程的所有线程已经处于c1中了
root@ubuntu:/home/dev/cgroup/demo# cat c1/tasks
610
616

#将616加入c2/tasks中
root@ubuntu:/home/dev/cgroup/demo# echo 616 > c2/tasks

#这时我们看到虽然在c1/cgroup.procs和c2/cgroup.procs里面都有610,
#但c1/tasks和c2/tasks中包含了不同的线程,说明这个进程的两个线程分别属于不同的cgroup
root@ubuntu:/home/dev/cgroup/demo# cat c1/cgroup.procs
610
root@ubuntu:/home/dev/cgroup/demo# cat c1/tasks
610
root@ubuntu:/home/dev/cgroup/demo# cat c2/cgroup.procs
610
root@ubuntu:/home/dev/cgroup/demo# cat c2/tasks
616
#通过tasks,我们可以实现线程级别的管理,但通常情况下不会这么用,
#并且在cgroup V2以后,将不再支持该功能,只能以进程为单位来配置cgroup

#清理
root@ubuntu:/home/dev/cgroup/demo# echo 610 > ./cgroup.procs
root@ubuntu:/home/dev/cgroup/demo# rmdir c1
root@ubuntu:/home/dev/cgroup/demo# rmdir c2
root@ubuntu:/home/dev/cgroup/demo# exit
exit

结论:将线程 ID 加到 cgroup1 的 cgroup.procs 时,会把线程对应进程 ID 加入 cgroup.procs 且还会把当前进程下的全部线程 ID 加入到
tasks 中。

这里看起来,进程和线程好像效果是一样的。

区别来了,如果此时把某个线程 ID 移动到另外的 cgroup2 的 tasks 中,会自动把 线程 ID 对应的进程 ID 加入到 cgroup2 的
cgroup.procs 中,且只把对应线程加入 tasks 中。

此时 cgroup1 和 cgroup2 的 cgroup.procs 都包含了同一个进程 ID,但是二者的 tasks 中却包含了不同的线程 ID。

这样就实现了线程粒度的控制。但通常情况下不会这么用,并且在 cgroup V2 以后,将不再支持该功能,只能以进程为单位来配置
cgroup。

3.如何使用 Go 和 Cgroups 交互

其实挺简单的,就是用 Go 翻译了一遍上面的命令。

后续则是按照这个流程实现自己的 docker。

具体代码如下:

// cGroups cGroups初体验
func cGroups() {
// /proc/self/exe是一个符号链接,代表当前程序的绝对路径
if os.Args[0] == "/proc/self/exe" {
// 第一个参数就是当前执行的文件名,所以只有fork出的容器进程才会进入该分支
fmt.Printf("容器进程内部 PID %d\n", syscall.Getpid())
// 需要先在宿主机上安装 stress 比如 apt-get install stress
cmd := exec.Command("sh", "-c", `stress --vm-bytes 200m --vm-keep -m 1`)
cmd.SysProcAttr = &syscall.SysProcAttr{}
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
fmt.Println(err)
os.Exit(1)
}
} else {
// 主进程会走这个分支
cmd := exec.Command("/proc/self/exe")
cmd.SysProcAttr = &syscall.SysProcAttr{Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWNS | syscall.CLONE_NEWPID}
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Start(); err != nil {
fmt.Println(err)
os.Exit(1)
}
// 得到 fork 出来的进程在外部namespace 的 pid
fmt.Println("fork 进程 PID:", cmd.Process.Pid)
// 在默认的 memory cgroup 下创建子目录,即创建一个子 cgroup
err := os.Mkdir(filepath.Join(cgroupMemoryHierarchyMount, "testmemorylimit"), 0755)
if err != nil {
fmt.Println(err)
}
// 	将容器加入到这个 cgroup 中,即将进程PID加入到cgroup下的 cgroup.procs 文件中
err = ioutil.WriteFile(filepath.Join(cgroupMemoryHierarchyMount, "testmemorylimit", "cgroup.procs"),
[]byte(strconv.Itoa(cmd.Process.Pid)), 0644)
if err != nil {
fmt.Println(err)
os.Exit(1)
}
// 	限制进程的内存使用,往 memory.limit_in_bytes 文件中写入数据
err = ioutil.WriteFile(filepath.Join(cgroupMemoryHierarchyMount, "testmemorylimit", "memory.limit_in_bytes"),
[]byte("100m"), 0644)
if err != nil {
fmt.Println(err)
os.Exit(1)
}
cmd.Process.Wait()
}
}

首先是一个 if 判断,区分主进程和子进程,分别执行不同逻辑。

  • 主进程:fork 出子进程,并创建 cgroup,然后将子进程加入该 cgrouop
  • 子进程:执行 stress 命令,以消耗内存,便于查看 memory cgroup 的效果

运行并测试:

lixd  ~/projects/docker/mydocker main $ go build main.go
lixd  ~/projects/docker/mydocker main $ sudo ./main
fork 进程 PID: 21827
当前进程 pid 1
stress: info: [7] dispatching hogs: 0 cpu, 0 io, 1 vm, 0 hdd

根据输出可以知道,我们 fork 出的进程,pid 为 21827。

通过pstree -pl查看进程关系:

$pstree -pl
init(1)─┬─init(8)───init(9)───fsnotifier-wsl(10)
        ├─init(12)───init(13)─┬─exe(20618)─┬─sh(20623)───stress(20624)───stress(20625)
        │                     │            ├─{exe}(20619)
        │                     │            ├─{exe}(20620)
        │                     │            ├─{exe}(20621)
        │                     │            └─{exe}(20622)
└─zsh(14)───sudo(21821)───main(21822)─┬─exe(21827)─┬─sh(21832)───stress(21833)───stress(21834)

可以看到 21827 进程 最终启动了一个 21834 的 stress 进程。

top查看以下内存占用:

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
21834 root      20   0  208664 101564    272 D  35.2   1.3   0:14.38 stress

可以看到 RES 101564,也就是刚好 100M,说明我们的 cgroup 是有效果的。

4. 小结

本文主要介绍了

  • 1)Docker 是如何使用 cgroups 的;
  • 2) hierarchy 和 cgroup 相关的操作,如创建删除等;
  • 3)最后则是简单演示了如何使用 Go 和 cgroups 进行交互。

至此,cgroups 的相关内容就告一段落了,加上本文一共包括 3 篇文章:
初探 Linux Cgroups:资源控制的奇妙世界
深入剖析 Linux Cgroups 子系统:资源精细管理

包括以下内容:

  • 1)cgroups 怎么实现资源控制的
  • 2)相关 subsystem 演示
  • 3)docker 怎么使用 cgroups 的
  • 4)go 怎么操作 cgroups

后续可以使用 go 实现 docker 的时候,资源控制就会使用 go 和 cgroups 交互来实现。


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

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


5.参考

cgroups(7) — Linux manual page

Linux Cgroup 系列(02):创建并管理 cgroup

cgroup 源码分析 6——cgroup 中默认控制文件的内核实现分析

Docker 如何实现资源隔离? 【代码】Docker 如何实现资源隔离? 阅读详情

相关推荐

Docker核心原理之cgroups

cgroups资源限制 上一篇文章中,我们了解了Docker的资源隔离技术namespace,通过系统调用构建了一个相对隔离的shell环境。也可以称之为一个简单的容器。接下来将讲解另一个强大的内核工具-cgroups。它不仅可以限制被namespace隔离起来的资源,还可以为资源设置权重、计算使用量、操控任务(进程或线程)启停等。 1.cgroups是什么 cgroups顾名思义就是把任务放到一...

我不是大牛 2296

Docker——Docker资源隔离原理

Namespace是Linux内核的一项功能,该功能对内核资源进行分区,以使一组进程看到一组资源,而另一组进程看到另一组资源。 Namespace的工作方式通过为一组资源和进程设置相同的Namespace而起作用,但是这些Namespace引用了不同的资源。 资源可能存在于多个Namespace中。这些资源可以是进程ID、主机名、用户ID、文件名、与网络访问相关的名称和进程间通信。

庄小焱 1137

容器的关键:Cgroups编程

Cgroups提供了对进程进行资源限制、优先级控制和统计的功能,是实现容器隔离和资源管理的重要工具。Cgroups是Linux内核中的一个特性,通过将一组进程组织在一个层次结构中,可以对这组进程进行资源控制和限制。Cgroups可以对CPU、内存、磁盘IO等资源进行配置和限制,确保每个Cgroup中的进程都遵守相应的限制。本文将介绍Cgroups的基本概念和原理,并给出使用Cgroups进行资源限制和优先级控制的示例代码。现在,我们来看一个综合示例,演示如何使用Cgroups进行资源限制和优先级控制。

2301_79330511的博客 191

Docker资源隔离(namespace,cgroups)

Docker容器的本质是宿主机上的一个进程。Docker通过namespace实现了资源隔离通过cgroups实现了资源限制,通过写时复制机制(copy-on-write)实现了高效的文件操作。cgroups是Linux的另外一个强大的内核工具,有了cgroups,不仅可以限制被namespace隔离起来的资源,还可以为资源设置权重、计算使用量、操控任务(进程或县城)启停等。

驰兔的博客 1373

Docker 核心原理详解:Namespaces 与 Cgroups 如何实现资源隔离与限制

Docker 作为容器化技术的代表,通过 Linux 内核的 Namespaces 和 Cgroups 技术,实现了轻量、快速且一致的运行环境。Namespaces 负责隔离系统资源,如进程、网络、文件系统等,使得每个容器拥有独立的资源视图;Cgroups 则负责限制和监控容器的资源使用,如 CPU、内存等,确保资源分配的公平性和安全性。相比于传统的虚拟机技术,Docker 容器共享宿主机内核,避免了额外操作系统的开销,启动更快,资源利用率更高。

专栏 803

全志 mipi屏幕和触摸驱动调试记录

mipi屏幕与触摸调试记录

u011996684的博客 3222

Docker-- cgroups资源控制实战

cgroups是Linux内核中的一项功能,最初由Google的工程师提出,后来被整合进Linux内核;它允许用户将一系列系统任务及其子任务整合或分隔到按资源划分等级的不同组内,从而为系统资源管理提供一个统一的框架。

m0_74068921的博客 4180

告别玄学调试:手把手教你读懂全志芯片的sys_config.fex配置文件(以i2c配置为例)

本文深入解析全志芯片的sys_config.fex配置文件,以I2C设备驱动为例,详细讲解从引脚定义到驱动加载的全过程。通过实战案例和高级调试技巧,帮助开发者快速掌握硬件配置与内核驱动的联动机制,提升开发效率。

weixin_33737134的博客 420

Docker-04:CGroups资源控制组

Cgroups 通过层级化的控制组和子系统,以配置文件动态约束进程资源。保障容器间资源公平性、隔离性及宿主机的稳定性。Cgroups v2 通过统一层级简化管理,逐渐成为主流。

weixin_75232881的博客 1483

深入解析Vivado FIFO的Standard与FWFT模式:性能对比与应用场景

本文深入解析了Vivado FIFO的Standard与FWFT两种工作模式的核心差异。通过对比数据就绪时机、读延迟、控制逻辑和有效深度等关键特性,并结合图像处理、数据包转发等典型应用场景,为FPGA设计者提供了清晰的选择依据和实战配置指南,帮助优化数据流性能与设计效率。

weixin_29219189的博客 259

亚马逊SP-API授权实战:从OAuth流程到Refresh Token获取

本文详细解析了亚马逊SP-API授权流程,从OAuth认证到Refresh Token获取的全过程。通过实战经验分享,帮助开发者快速掌握Marketplace Appstore、Website Workflow和自行授权三种方式,解决常见错误如MD5100和MD9999,并提供了安全存储Refresh Token的最佳实践。

weixin_30379531的博客 519

Docker与Cgroups资源控制实战

Cgroups(Control Groups)是Linux内核提供的一种机制,用于将进程按组进行管理,并限制和统计这些进程的资源使用情况。这些资源包括CPU、内存、存储、网络等。通过Cgroups,系统管理员可以方便地限制某个进程或进程组的资源占用,并实时监控这些资源的使用情况。Cgroups的核心概念包括cgroup、subsystem和hierarchy。cgroup。

Chujun123528的博客 1218

【Labview学习】——如何实现软件的中/英文切换

各位亲爱的小伙伴们大家好,这里是小万的labview专题,今天为大家带来的是软件的中/英文切换,在全球化的浪潮之下,各行各业发生着巨大的变化,emmm………… 以下是简单的演示图片,注意观察菜单栏和软件界面各控件的语言状态: 本次分享将分为两部分:菜单中英文切换&界面控件中英文切换 ** 菜单中英文切换 ** 1. 中/英文菜单制造 要想实现菜单的中/英文语言切换,就得做两个菜单,一个...

weixin_44827166的博客 1万+

Docker 的资源隔离与资源限制

Docker 的资源隔离与资源限制Docker容器的本质Linux内核的namespace机制linux的namespace机制namespace可以隔离哪些Linux的 cgroups强大内核工具cgroups Docker容器的本质 docker容器的本质是宿主机上的一个进程。 Docker通过namespace实现了资源隔离,通过cgroups实现了资源限制,通过*写时复制机制(copy-o...

AbeyQ_Q的博客 4240

YOLOv12模型详解及代码复现

YOLOV12算法详解及Python代码复现

hasakie的博客 6489

【华为OD机试真题】29、组成最大数 | 机试真题+思路参考+代码解析 (C++、Java、Py、C语言、JS)

题目描述 >小组中每位都有一张卡片,卡片上是6位内的正整数,将卡片连起来可以组成多种数字,计算组成的最大数字

KJ.JK 2419

深入解析:Docker 容器如何实现文件系统与资源的多维隔离?

通过RootFs和cgroups的巧妙组合,Docker 容器能够在同一个 Linux 内核上运行,却拥有与宿主机和其他容器相对独立的文件系统、进程空间、网络环境、IPC、以及严格的资源配额/限制。这为容器提供了接近虚拟机的隔离性,同时也保留了“共享同一个内核”的优势(启动速度快、资源开销小等)。RootFs:让容器拥有独立的文件系统视图,与宿主机的根目录区分开来。PID Namespace 让容器内部进程有各自的 PID 视图。Network Namespace 让容器拥有独立的虚拟网卡、网络栈。

人心有反复,好在山水有重逢。 2863

进阶06:C#连接TwinCAT 3使用ADS通讯

本文介绍了使用C#通过ADS协议与倍福TwinCAT3 PLC通讯的实现方法。主要内容包括:1)在两台电脑上安装TwinCAT3开发环境并建立网络连接;2)在TwinCAT中定义变量和结构体;3)使用C# Winform开发界面,通过TwinCAT.Ads.dll实现读写功能;4)实现主动读取和通知两种数据获取方式。详细说明了连接建立、变量定义、读写操作及事件通知的实现代码。该方案实现了对PLC寄存器数据的实时监控和操作,为工业控制系统的开发提供了参考。

weixin_38637405的博客 3690

【Docker高级篇】吃透Linux底层:Namespace做隔离,Cgroups控资源,UnionFS搭存储

本文深入解析Linux容器技术的两大核心机制:Namespace与Cgroups。Namespace实现进程环境隔离(如PID、网络、文件系统),让容器拥有独立运行空间;Cgroups则负责资源限制(CPU、内存等),防止单一容器耗尽系统资源。文章通过通俗比喻和实操示例(如创建PID Namespace、配置CPU配额),帮助读者掌握容器底层原理,提升Linux系统管理与问题排查能力。适合开发者和运维人员深入学习容器技术本质。

m0_58782205的博客 1222

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

揭秘Docker魔法:Linux内核的namespaces、cgroups与unionfs如何铸就容器化奇迹

本文深入探讨了Docker容器技术的底层实现,着重分析了Linux内核的namespaces、cgroups和unionfs等特性如何支持Docker的运行。首先,文章概述了Docker的概念和重要性,并指出了Linux内核在其中的关键作用。接着,文章详细解释了namespaces如何隔离进程和资源,创建独立的容器环境。然后,文章探讨了cgroups的工作原理及其在Docker中的应用,如何限制和管理容器的资源使用。此外,文章还介绍了UnionFS和AUFS等联合文件系统的工作原理。

博客虽小,世界尽在其中 1880

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

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

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

diankui6178的博客 493

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

Docker资源隔离与资源管控

Docker为每一个容器分配一个IPC namespace,这个新的IPC namespace会拥有自己独立的资源(例如:信号量、消息队列和共享内存段),同时该容器内IPC namespace内的进程只可以使用本空间的资源,确保容器内的进程无法直接干扰宿主系统或其他容器的IPC通信。Docker为容器内的用户空间进程分配独立且唯一的 PID(容器内视角),将容器内运行的进程封装在独立的namespaces中并限制其权限和可见性,防止受损容器利用进程管理接口对其他容器或底层宿主系统造成干扰。

qq_56716671的博客 1003

深入解读Docker核心原理:Cgroups资源限制机制详解

是Linux内核的一个功能模块,允许系统管理员对进程组使用的资源进行控制和管理。它通过将进程分配到不同的组中,然后对这些组应用资源限制,来实现对CPU、内存、磁盘I/O等资源的配额管理。对于Docker来说,每个容器都对应一个Cgroup。Docker通过Cgroups为容器分配和限制资源,确保容器不会无节制地消耗系统资源,从而影响宿主机或其他容器的正常运行。Cgroups作为Docker核心原理之一,为容器提供了灵活且精细的资源管理功能。

qq_39241682的博客 2172

【Docker入门】cgroups 资源控制

本文介绍了Linux系统中的cgroups资源控制机制和两个实用命令:pidstat和stress。cgroups是Linux内核提供的资源管理框架,可以对CPU、内存等资源进行精细化管控。文章详细讲解了pidstat命令的使用方法,包括监控CPU、内存、IO等系统资源的参数选项。同时介绍了stress压力测试工具的功能及常用参数,演示了如何通过stress模拟CPU负载并使用pidstat进行监控。这些工具对于系统资源管理和性能测试具有重要价值。

optimistic_chen的博客 1133
上一篇: 深入剖析 Linux Cgroups 子系统:资源精细管理
下一篇: Docker 魔法解密:探索 UnionFS 与 OverlayFS
探索云原生
博客等级 码龄9年 730粉丝 131原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值