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

linux磁盘管理说明(10)文件系统的挂载(下)  查看一个目录或者文件是不是挂载点,我们可以使用mountpoint命令,此命令也是检查/proc/self/mountinfo文件,同时这个命令还可以方便的查看设备的主次设备代码。 mountpoint 常用参数: -d 打印挂载于指定目录上的设备的主次设备代码 -q 安静模式 -x 打印指定块设备的主次设备代码 常见用法:  判断目录是否挂载点  输出挂载在此目录的设备的主次设备代码  输出指定设备的主次设备代码  查看挂载的文件系统的详细信息,相较于mount -l现在更倾向于使用findmnt命令, 阅读详情

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


完整代码见:https://github.com/lixd/mydocker
欢迎 Star



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

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


推荐阅读以下文章对 docker 基本实现有一个大致认识:



开发环境如下:

root@mydocker:~# lsb_release -a
No LSB modules are available.
Distributor ID:	Ubuntu
Description:	Ubuntu 20.04.2 LTS
Release:	20.04
Codename:	focal
root@mydocker:~# uname -r
5.4.0-74-generic

注意:需要使用 root 用户

1. 概述

上一节中,已经可以通过命令行mydocker run -it的方式创建并启动容器。这一节,将通过 cgroups 实现对容器资源进行限制。

这一节中,将实现通过增加-mem、-cpu 等 flag 来实现容器 cpu、内存资源限制,完整命令如下:

./mydocker run -it -mem 10m  -cpu 20 /bin/sh

包含以下几个部分:

  • mydocker run 命令增加对应 flag
  • 实现统一 CgroupsManager
  • 实现各个 Subsystem
  • 容器创建、停止时调用对应方法配置 cgroup

2. 具体实现

2.1. Cli 增加 flags

run 命令增加mem、cpu、cpuset 这几个 flag,具体如下:

var runCommand = cli.Command{
	Name: "run",
	Usage: `Create a container with namespace and cgroups limit
			mydocker run -it [command]`,
	Flags: []cli.Flag{
		cli.BoolFlag{
			Name:  "it", // 简单起见,这里把 -i 和 -t 参数合并成一个
			Usage: "enable tty",
		},
		cli.StringFlag{
			Name:  "mem", // 限制进程内存使用量,为了避免和 stress 命令的 -m 参数冲突 这里使用 -mem,到时候可以看下解决冲突的方法
			Usage: "memory limit,e.g.: -mem 100m",
		},
		cli.StringFlag{
			Name:  "cpu",
			Usage: "cpu quota,e.g.: -cpu 100", // 限制进程 cpu 使用率
		},
		cli.StringFlag{
			Name:  "cpuset",
			Usage: "cpuset limit,e.g.: -cpuset 2,4", // 限制进程 cpu 使用率
		},
	},
	/*
		这里是run命令执行的真正函数。
		1.判断参数是否包含command
		2.获取用户指定的command
		3.调用Run function去准备启动容器:
	*/
	Action: func(context *cli.Context) error {
		if len(context.Args()) < 1 {
			return fmt.Errorf("missing container command")
		}

		var cmdArray []string
		for _, arg := range context.Args() {
			cmdArray = append(cmdArray, arg)
		}

		tty := context.Bool("it")
		resConf := &subsystems.ResourceConfig{
			MemoryLimit: context.String("mem"),
			CpuSet:      context.String("cpuset"),
			CpuCfsQuota: context.Int("cpu"),
		}
		Run(tty, cmdArray, resConf)
		return nil
	},
}

从命令行中解析对应参数并传给 subsystem 以配置 cgroups。

2.2. Subsystem 实现

核心思想就是根据传递过来的参数,创建对应的 cgroups 并配置 subsystem。

例如指定了 -m 100m 就创建 memory subsystem,限制只能使用 100m 内存

定义 Subsystem

首先定义 Subsystem,这里将其抽象为一个接口以适应各种 subsystem:

// Subsystem 接口,每个Subsystem可以实现下面的4个接口,
// 这里将cgroup抽象成了path,原因是cgroup在hierarchy的路径,便是虚拟文件系统中的虚拟路径
type Subsystem interface {
	// Name 返回当前Subsystem的名称,比如cpu、memory
	Name() string
	// Set 设置某个cgroup在这个Subsystem中的资源限制
	Set(path string, res *ResourceConfig) error
	// Apply 将进程添加到某个cgroup中
	Apply(path string, pid int) error
	// Remove 移除某个cgroup
	Remove(path string) error
}

// ResourceConfig 用于传递资源限制配置的结构体,包含内存限制,CPU 时间片权重,CPU核心数
type ResourceConfig struct {
    MemoryLimit string
    CpuCfsQuota int
    CpuShare    string
    CpuSet      string
}
  • Name:Subsystem 名称,例如 memory、cpu。
  • Set:根据 ResourceConfig 设置 cgroup,即将阈值写入对应配置文件。
    • 例如 memory subsystem 则需将配置写入 memory.limit_in_bytes 文件
    • cpu subsystem 则是写入 cpu.cfs_period_us 和 cpu.cfs_quota_us
  • Apply:将对应 pid 添加到指定 cgroup 里
  • Remove:删除指定 cgroup

不同 Subsystem 只需要实现该接口即可。

找到 cgroup 挂载路径

在实现 Subsystem 之前,我们还需要先找到 cgroup 的挂载路径,这样才能对 cgroup 进行操作。


那么,是如何找到挂载了 subsystem 的 hierarchy 的挂载目录的呢?

先来熟悉下/proc/{pid}/mountinfo文件,如下:

$ cat /proc/24334/mountinfo 
613 609 0:59 / /sys ro,nosuid,nodev,noexec,relatime - sysfs sysfs ro
620 613 0:61 / /sys/fs/cgroup rw,nosuid,nodev,noexec,relatime - tmpfs tmpfs rw,mode=755
624 620 0:26 /docker/fa4b9c67d031dd83cedbad7b744b4ae64eb689c5089f77d0c95379bd3b66d791 /sys/fs/cgroup/systemd ro,nosuid,nodev,noexec,relatime master:5 - cgroup cgroup rw,xattr,release_agent=/usr/lib/systemd/systemd-cgroups-agent,name=systemd
625 620 0:29 /docker/fa4b9c67d031dd83cedbad7b744b4ae64eb689c5089f77d0c95379bd3b66d791 /sys/fs/cgroup/perf_event ro,nosuid,nodev,noexec,relatime master:6 - cgroup cgroup rw,perf_event
627 620 0:30 /docker/fa4b9c67d031dd83cedbad7b744b4ae64eb689c5089f77d0c95379bd3b66d791 /sys/fs/cgroup/net_cls,net_prio ro,nosuid,nodev,noexec,relatime master:7 - cgroup cgroup rw,net_cls,net_prio
629 620 0:31 /docker/fa4b9c67d031dd83cedbad7b744b4ae64eb689c5089f77d0c95379bd3b66d791 /sys/fs/cgroup/cpu,cpuacct ro,nosuid,nodev,noexec,relatime master:8 - cgroup cgroup rw,cpu,cpuacct
631 620 0:32 /docker/fa4b9c67d031dd83cedbad7b744b4ae64eb689c5089f77d0c95379bd3b66d791 /sys/fs/cgroup/pids ro,nosuid,nodev,noexec,relatime master:9 - cgroup cgroup rw,pids
634 620 0:33 / /sys/fs/cgroup/rdma ro,nosuid,nodev,noexec,relatime master:10 - cgroup cgroup rw,rdma
641 620 0:38 /docker/fa4b9c67d031dd83cedbad7b744b4ae64eb689c5089f77d0c95379bd3b66d791 /sys/fs/cgroup/hugetlb ro,nosuid,nodev,noexec,relatime master:15 - cgroup cgroup rw,hugetlb
644 620 0:39 /docker/fa4b9c67d031dd83cedbad7b744b4ae64eb689c5089f77d0c95379bd3b66d791 /sys/fs/cgroup/freezer ro,nosuid,nodev,noexec,relatime master:16 - cgroup cgroup rw,freezer
646 611 0:52 / /dev/mqueue rw,nosuid,nodev,noexec,relatime - mqueue mqueue rw
647 611 0:63 / /dev/shm rw,nosuid,nodev,noexec,relatime - tmpfs shm rw,size=65536k
648 609 253:1 /var/lib/docker/containers/fa4b9c67d031dd83cedbad7b744b4ae64eb689c5089f77d0c95379bd3b66d791/resolv.conf /etc/resolv.conf rw,relatime - xfs /dev/vda1 rw,attr2,inode64,noquota
649 609 253:1 /var/lib/docker/containers/fa4b9c67d031dd83cedbad7b744b4ae64eb689c5089f77d0c95379bd3b66d791/hostname /etc/hostname rw,relatime - xfs /dev/vda1 rw,attr2,inode64,noquota
650 609 253:1 /var/lib/docker/containers/fa4b9c67d031dd83cedbad7b744b4ae64eb689c5089f77d0c95379bd3b66d7
# ... 省略

通过/proc/self/mountinfo 可以找出 与当前进程相关的 mount 信息。


而 Cgroups 的 hierarchy 的虚拟文件系统是以 cgroup 类型文件系统的 mount 挂载上去的,其中的 option 中加上 subsystem,代表挂载的 subsystem 类型。

根据这个就可以在 mountinfo 中找到对应的 subsystem 的挂载目录了,比如 memory:

/sys/fs/cgroup/memory ro,nosuid,nodev,noexec,relatime master:11 - cgroup cgroup rw,memory

通过最后的 option 是 rw, memory 看出这一条挂载的 subsystem 是 memory。

那么在/sys/fs/cgroup/memory中创建文件夹对应创建的 cgroup,就可以用来做内存的限制。

根据这个规则我们就可以找到对应 cgroup 挂载位置了,具体代码实现如下。

下面的 getCgroupPath 函数是找到对应 subsystem 挂载的 hierarchy 相对路径对应的 cgroup 在虚拟文件系统中的路径,然后通过这个目录的读写去操作 cgroup。

const mountPointIndex = 4

// getCgroupPath 找到cgroup在文件系统中的绝对路径
/*
实际就是将根目录和cgroup名称拼接成一个路径。
如果指定了自动创建,就先检测一下是否存在,如果对应的目录不存在,则说明cgroup不存在,这里就给创建一个
*/
func getCgroupPath(subsystem string, cgroupPath string, autoCreate bool) (string, error) {
	// 不需要自动创建就直接返回
	cgroupRoot := findCgroupMountpoint(subsystem)
	absPath := path.Join(cgroupRoot, cgroupPath)
	if !autoCreate {
		return absPath, nil
	}
	// 指定自动创建时才判断是否存在
	_, err := os.Stat(absPath)
	// 只有不存在才创建
	if err != nil && os.IsNotExist(err) {
		err = os.Mkdir(absPath, constant.Perm0755)
		return absPath, err
	}
	// 其他错误或者没有错误都直接返回,如果err=nil,那么errors.Wrap(err, "")也会是nil
	return absPath, errors.Wrap(err, "create cgroup")
}

// findCgroupMountpoint 通过/proc/self/mountinfo找出挂载了某个subsystem的hierarchy cgroup根节点所在的目录
func findCgroupMountpoint(subsystem string) string {
	// /proc/self/mountinfo 为当前进程的 mountinfo 信息
	// 可以直接通过 cat /proc/self/mountinfo 命令查看
	f, err := os.Open("/proc/self/mountinfo")
	if err != nil {
		return ""
	}
	defer f.Close()
	// 这里主要根据各种字符串处理来找到目标位置
	scanner := bufio.NewScanner(f)
	for scanner.Scan() {
		// txt 大概是这样的:104 85 0:20 / /sys/fs/cgroup/memory rw,nosuid,nodev,noexec,relatime - cgroup cgroup rw,memory
		txt := scanner.Text()
		// 然后按照空格分割
		fields := strings.Split(txt, " ")
		// 对最后一个元素按逗号进行分割,这里的最后一个元素就是 rw,memory
		// 其中的的 memory 就表示这是一个 memory subsystem
		subsystems := strings.Split(fields[len(fields)-1], ",")
		for _, opt := range subsystems {
			if opt == subsystem {
				// 如果等于指定的 subsystem,那么就返回这个挂载点跟目录,就是第四个元素,
				// 这里就是`/sys/fs/cgroup/memory`,即我们要找的根目录
				return fields[mountPointIndex]
			}
		}
	}

	if err = scanner.Err(); err != nil {
		log.Error("read err:", err)
		return ""
	}
	return ""
}

接下来我们就可以实现各个 Subsystem 了。

memory subsystem

memory subsystem 实现如下:

type MemorySubSystem struct {
}

// Name 返回cgroup名字
func (s *MemorySubSystem) Name() string {
	return "memory"
}

// Set 设置cgroupPath对应的cgroup的内存资源限制
func (s *MemorySubSystem) Set(cgroupPath string, res *ResourceConfig) error {
	if res.MemoryLimit == "" {
		return nil
	}
	subsysCgroupPath, err := getCgroupPath(s.Name(), cgroupPath, true)
	if err != nil {
		return err
	}
	// 设置这个cgroup的内存限制,即将限制写入到cgroup对应目录的memory.limit_in_bytes 文件中。
	if err := os.WriteFile(path.Join(subsysCgroupPath, "memory.limit_in_bytes"), []byte(res.MemoryLimit), constant.Perm0644); err != nil {
		return fmt.Errorf("set cgroup memory fail %v", err)
	}
	return nil
}

// Apply 将pid加入到cgroupPath对应的cgroup中
func (s *MemorySubSystem) Apply(cgroupPath string, pid int, res *ResourceConfig) error {
	if res.MemoryLimit == "" {
		return nil
	}
	subsysCgroupPath, err := getCgroupPath(s.Name(), cgroupPath, false)
	if err != nil {
		return errors.Wrapf(err, "get cgroup %s", cgroupPath)
	}
	if err := os.WriteFile(path.Join(subsysCgroupPath, "tasks"), []byte(strconv.Itoa(pid)), constant.Perm0644); err != nil {
		return fmt.Errorf("set cgroup proc fail %v", err)
	}
	return nil
}

// Remove 删除cgroupPath对应的cgroup
func (s *MemorySubSystem) Remove(cgroupPath string) error {
	subsysCgroupPath, err := getCgroupPath(s.Name(), cgroupPath, false)
	if err != nil {
		return err
	}
	return os.RemoveAll(subsysCgroupPath)
}

可以看到,其实就是将操作 cgroups 的命令换成了 Go 语法罢了:

  • 比如限制内存则是往memory.limit_in_bytes里写入指定值
  • 添加某个进程到 cgroup 中就是往对应的 tasks 文件中写入对应的 pid
  • 删除 cgroup 就是把对应目录删掉

另外的cpu subsystem 就不再贴代码了,都是类似的操作。

2.3 CgroupManager

实现了各个 Subsystem 之后,我们在往上抽象一层,定义一个 CgroupManager 来统一管理各个 subsystem。

这样调用方就可以不用管具体的底层的实现了,只需要调用 CgroupManager 即可。

实现也很简单,就是循环调用每个 subsystem 中的方法。

type CgroupManager struct {
	// cgroup在hierarchy中的路径 相当于创建的cgroup目录相对于root cgroup目录的路径
	Path string
	// 资源配置
	Resource *subsystems.ResourceConfig
}

func NewCgroupManager(path string) *CgroupManager {
	return &CgroupManager{
		Path: path,
	}
}

// Apply 将进程pid加入到这个cgroup中
func (c *CgroupManager) Apply(pid int) error {
	for _, subSysIns := range subsystems.SubsystemsIns {
		err := subSysIns.Apply(c.Path, pid)
		if err != nil {
			logrus.Errorf("apply subsystem:%s err:%s", subSysIns.Name(), err)
		}
	}
	return nil
}

// Set 设置cgroup资源限制
func (c *CgroupManager) Set(res *subsystems.ResourceConfig) error {
	for _, subSysIns := range subsystems.SubsystemsIns {
		err := subSysIns.Set(c.Path, res)
		if err != nil {
			logrus.Errorf("apply subsystem:%s err:%s", subSysIns.Name(), err)
		}
	}
	return nil
}

// Destroy 释放cgroup
func (c *CgroupManager) Destroy() error {
	for _, subSysIns := range subsystems.SubsystemsIns {
		if err := subSysIns.Remove(c.Path); err != nil {
			logrus.Warnf("remove cgroup fail %v", err)
		}
	}
	return nil
}
  • Set:配置 cgroup,具体实现则是循环调用各个 Subsystem 的 Set 方法
  • Apply:将指定 pid 进程加入到 cgroup 中,实现同上
  • Destroy:释放 cgroup,实现同上

通过 CgroupManager 将 Subsystem 进行封装,对上层隐藏了资源限制的配置,以及将进程移动到 cgroup 中等操作细节。

具体 CgroupManager 和 Subsystem 的调用流程如下所示:

resource-limit-by-cgroups

如图所示,CgroupManager 在配置容器资源限制时

  • 首先会初始化 Subsystem 实例;
  • 然后遍历调用 Subsystem 实例的 Set 方法,创建和配置不同 Subsystem 挂载的 hierarchy 中的 cgroup;
  • 接着再通过调用 Subsystem 实例的 Apply 方法将容器进程对应 PID 分别加入到那些 cgroup 中,以实现容器的资源限制;
  • 最后容器运行结束时则调用 Subsystem 实例的 Destory 销毁 cgroup。

到此,整个 Cgroups 的实现就算是完成了,后续剩下的就是在启动的时候,解析参数,并配置对应的 Cgroups 即可。

2.4. 实现 Cgroups 配置

至此,实现了参数解析以及 CgroupManager,剩下的只需要使用 flag 中解析的参数初始化 CgroupManager 实例并调用相关方法即可实现 Cgroups 配置。


前面讲解析的参数组装为 subsystems.ResourceConfig 对象,传递到 Run 方法中,

然后 Run 方法则根据前面解析好的 config 设置对应的 Cgroups。

func Run(tty bool, comArray []string, res *subsystems.ResourceConfig) {
	parent, writePipe := container.NewParentProcess(tty)
	if parent == nil {
		log.Errorf("New parent process error")
		return
	}
	if err := parent.Start(); err != nil {
		log.Errorf("Run parent.Start err:%v", err)
	}
	// 创建cgroup manager, 并通过调用set和apply设置资源限制并使限制在容器上生效
	cgroupManager := cgroups.NewCgroupManager("mydocker-cgroup")
	defer cgroupManager.Destroy()
	_ = cgroupManager.Set(res)
	_ = cgroupManager.Apply(parent.Process.Pid)
	// 再子进程创建后才能通过匹配来发送参数
	sendInitCommand(comArray, writePipe)
	_ = parent.Wait()
}

核心代码如下:

cgroupManager := cgroups.NewCgroupManager("mydocker-cgroup")
	defer cgroupManager.Destroy()
	_ = cgroupManager.Set(res)
	_ = cgroupManager.Apply(parent.Process.Pid)

创建一个 Cgroups,然后调用 Set 方法写入对应的配置信息,最后调用 Apply 将子进程 pid 加入到这个 Cgroups 中。

这样就完成了 Cgroups 全部配置,已经可以限制子进程的资源使用了。

同时通过defer cgroupManager.Destroy() 指定了 Destory 方法,以实现在容器退出后自动销毁对应 cgroup。

3. 测试

这里主要通过跑 stress 命令来测试 Cgroups 限制是否生效。

宿主机上需要先安装 stress,因为此时还没有切换 rootfs,因此可以直接使用宿主机上安装的程序。

memory

memory subsystem 测试流程如下:

  • 启动容器并使用 -mem flag 限制内存

  • 使用程序占用大量内存,测试能否超过阈值

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

vi ~/mem-allocate.c

完整内容如下:

cat > ~/mem-allocate.c <<EOF
#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;
}
EOF

编译一下

gcc ~/mem-allocate.c -o ~/mem-allocate

然后启动容器

root@mydocker:~/feat-cgroups/mydocker# ./mydocker run -it -mem 10m /bin/sh
{"level":"info","msg":"command all is /bin/sh","time":"2024-01-08T13:19:37+08:00"}
{"level":"info","msg":"init come on","time":"2024-01-08T13:19:37+08:00"}
{"level":"info","msg":"Find path /bin/sh","time":"2024-01-08T13:19:37+08:00"}

并在容器中运行内存占用程序

# ~/mem-allocate
1M memory allocated
2M memory allocated
3M memory allocated
4M memory allocated
5M memory allocated
6M memory allocated
7M memory allocated
8M memory allocated
9M memory allocated
Killed

可以看到,在第 10 次申请时由于达到了内存上限(10M) 程序直接被 OOM Kill 了。

内存和 CPU 不同,如果进程超过了分配的内存阈值,Linux 内核会采取 OOM (Out of Memory) 机制,以保证系统不会因内存不足而崩溃。

说明,我们的内存限制是生效的

最后在看一下 mydocker 创建的 cgroup 在哪儿

查看 memory subsystem 中的内容:

root@mydocker:~# ls /sys/fs/cgroup/memory/
cgroup.clone_children           memory.kmem.tcp.failcnt             memory.soft_limit_in_bytes      mydocker-cgroup 
tasks user.slice

可以看到,有一个 mydocker-cgroup 目录,这就是为 mydocker 容器创建的 memory cgroup。

查看内部的具体内容:

root@mydocker:~# cat /sys/fs/cgroup/memory/mydocker-cgroup/memory.limit_in_bytes
10485760
root@mydocker:~# cat /sys/fs/cgroup/memory/mydocker-cgroup/tasks
116477

memory.limit_in_bytes 中的配置 10485760 转换下单位就是我们启动时配置的 10m。

而tasks 中的 116477 就是容器进程 PID。

最后,当我们执行 exit,退出容器后 mydocker-cgroup 也会随之删除。

cpu

cpu subsystem 测试也类似:

  • 启动容器并使用 -cpu flag 限制 cpu

  • 使用程序占用大量 cpu,测试能否超过阈值

启动容器并限制只能占用 0.1核 cpu:

root@mydocker:~/feat-cgroups/mydocker# ./mydocker run -it -cpu 10 /bin/sh
{"level":"info","msg":"init come on","time":"2024-01-08T13:25:03+08:00"}
{"level":"info","msg":"command all is /bin/sh","time":"2024-01-08T13:25:03+08:00"}
{"level":"info","msg":"Find path /bin/sh","time":"2024-01-08T13:25:03+08:00"}

然后在容器中启动一个 while 循环

# while : ; do : ; done &

理论上,该 while 循环会占用满一整个 cpu,但是该容器被限制了只能占用 0.1 核 cpu。

查看CPU占用情况:

    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
 116464 root      20   0    2608     88      0 R  10.0   0.0   0:05.37 sh

稳稳的被限制在了 10%,说明 cpu subsystem 也是生效的。

4. 小结

整个实现不算复杂,不过只要理解了实现原理,再写就很简单了。

几个重要的点如下:

  • 1)找到 cgroup 挂载路径:根据 /proc/self/mountinfo 中的信息,按规则解析得到 cgroup 挂载路径
  • 2)各个 Subsystem 的实现:使用 Go 实现 Cgroups 配置
  • 3)使用匿名管道传递参数:在父进程和子进程间使用了匿名管道来传递参数。

resource-limit-by-cgroups

具体流程就是:

  • 1)解析命令行参数,取到 Cgroups 相关参数
    • 比如 -mem 100m 表示把内存限制到100m
    • 又比如 -cpu 20 表示把 cpu 限制在 20%
  • 2)根据参数,创建对应 Cgroups 并配置对应的 subsystem,最后把 fork 出来的子进程 pid 加入到这个 Cgroups 中即可。
    • 1)创建 Cgroups
    • 2)配置 subsystem
    • 3)fork 出子进程
    • 4)把子进程 pid 加入到 Cgroups 中
  • 3)子进程(容器)结束时删除对于的 Cgroup

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

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


最后再推荐下 cgroups 相关的几篇文章:

Docker 之 使用cgroups实现资源限制 Docker 之 使用cgroups实现资源限制 参考:Docker cgroup cgroups是什么 cgroup是一个强大的内核工具。通俗的来说,cgroups 可以限制、记录、隔离进程组所使用的物理资源(包括:CPU、memory、IO 等),为容器实现虚拟化提供了基本保证,是构建 Docker 等一系列虚拟化管理工具的基石。 本质上来说,cgroups 是内核附加在程序上的一系列钩子(hooks),通过程序运行时对资源的调度触发相应的钩子以达到资源追踪和限制的目的 cgroups的作用 资源限制、 阅读详情

相关推荐

Docker资源隔离(namespace,cgroups)

一、概述 Docker容器的本质是宿主机上的一个进程。Docker通过namespace实现了资源隔离,通过cgroups实现了资源限制,通过*写时复制机制(copy-on-write)*实现了高效的文件操作。 二、Linux内核的namespace机制 namespace 机制提供一种资源隔离方案。 PID,IPC,Network等系统资源不再是全局性的,而是属于某个特定的Namespace. 每个namespace下的资源对于其它的namespace下的资源是透明的,不可见的。 Linux内核实现

匠人精神,持之以恒! 1288

linux磁盘管理说明(9)文件系统的挂载(中)

接上文 loop设备的挂载:  所谓的loop设备,是用文件来模拟块设备的一种技术。在使用时,loop设备必须和一个文件连接,以给用户提供一个替代块特殊文件的接口。一般linux中会有8个loop设备,分别是/dev/loop0~loop7。 一般情况下  创建一个空文件  在这个文件上创建一个文件系统,再挂载上去  划线部分表示,将/root/tieba/test.disk文件连接到/dev/loop1的回环设备上去,然后再将其挂载到/mnt目录,并显示指明其文件系统类型是vfat。如果有镜像文件,也可以

fuluoyide312的博客 460

ABAQUS应用15——Abaqus软件中边界条件与力学中自由度的关系

核心关系:Abaqus通过约束自由度实现边界条件,自由度类型由单元决定。正确设置步骤:确定模型类型(实体/梁/壳)。识别节点的自由度(平动或转动)。根据实际约束施加对应的自由度限制。验证:通过检查变形模式、反力分布等确认边界条件合理性。正确理解自由度与边界条件的关系,是确保有限元模型准确模拟实际物理行为的关键。

George的博客 1546

Linux:虚拟文件系统/proc和self进程

Linux。

保持终身学习的能力,温故而知新 2848

HFSS仿真的后处理结果,如何根据天线表面的电流密度分布对天线进行优化?

在HFSS仿真中,天线表面的Jsurf​是最直观、最有价值的诊断工具之一。它不仅告诉你天线“能不能工作”,还能告诉你“为什么工作”以及“哪里出了问题”。

degogmy的博客 1163

2024最新指南:如何用Python批量下载Sentinel-2数据(附避坑清单)

本文提供2024年最新Python批量下载Sentinel-2遥感数据的完整指南,涵盖环境配置、API准备、核心下载流程实现及实战避坑清单。通过智能查询器、断点续传下载器等实用工具,帮助用户高效获取遥感数据,避免常见网络问题和数据完整性验证失败。

silver的专栏 621

Cgroup 研究报告

Control Groups (Cgroups) 是 Red Hat Enterprise Linux 6 (以后简称 RHEL6) 提供的一项内核功能。Cgroup是将任意进程进行分组化管理的内核功能。 Cgroup提供了一个cgroup虚拟文件系统,作为进行分组管理和各子系统设置的用户接口。因此,要使用cgroup,必须先挂载cgroup文件系统: mount -t cgroup -o 子系统名 层级名(目录名) /sys/fs/cgroup/层级名(目录名) 我们可以使用 Cgroups 为任

omnispace的博客 642

一文搞懂深度学习:最全神经网络介绍

本文是深度学习系列文章的第二篇,我们将深入探讨各种类型的人工神经网络,探索它们独特的特性和应用。

2402_82802238的博客 2803

/proc/初窥门径

为了查看及使用上的方便,proc里的文件通常会按照相关性进行分类存储于不同的目录甚至子目录中,如/proc/scsi目录中存储的就是当前系统上所有SCSI设备的相关信息,/proc/N中存储的则是系统当前正在运行的进程的相关信息,其中N为正在运行的进程(可以想象得到,在某进程结束后其相关目录则会消失)。而后面则是表示空闲的区域。当前系统上的交换分区及其空间利用信息,如果有多个交换分区的话,则会每个交换分区的信息分别存储于/proc/swap目录中的单独文件中,而其优先级数字越低,被使用到的可能性越大;

neeking1949的博客 304

[WeChatMsg]导出csv格式微信聊天记录的手把手教程

手把手教大家如何导出自己的聊天记录得到csv文件,即使是电脑小白也可以轻松学会o(* ̄▽ ̄*)ブ

weixin_51094633的博客 1万+

4G+GNSS定位模块DX-CT511N-B:AT指令实战与多协议通信指南

本文详细介绍了4G+GNSS定位模块DX-CT511N-B的AT指令实战应用与多协议通信配置。内容涵盖TCP/UDP通信、MQTT协议集成、HTTP服务交互以及GNSS定位功能的深度解析,为开发者提供从基础指令到高级调试的完整指南,助力物联网设备开发。

hope8的博客 291

Docker-- cgroups资源控制实战

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

m0_74068921的博客 4180

基于Simulink的转向控制系统仿真建模示例

本文完成了基于 Simulink 的 EPS 转向控制系统仿真,实现了:✅掌握 EPS 助力控制基本原理✅构建车速敏感的可变助力策略✅在 Simulink 中验证低速轻便、高速沉稳的手感✅达成“安全、舒适、高效”的现代转向系统。

xiaoheshang_123的博客 88

Docker 基于 Cgroups 实现资源限制详解【实战+源码】

限制项说明CPU控制分配的 CPU 核数或使用比例内存限制容器使用的最大内存和 SwapI/O限制磁盘读写速率PID控制进程数量容器的“轻量级资源隔离”正是依赖它实现。通过对 Cgroups 的配置和使用,Docker 实现了对容器资源的精细化控制。多租户场景下保障隔离性测试场景中模拟低性能环境防止单容器资源过载崩溃主机中都扮演着核心角色。

2303_78594540的博客 1706

STM32 W5500 Freemodbus Modbus TCP协议功能实现

STM32F103VCT6 W5500(SPI1),实现Modbus-TCP协议的功能

坚韧与专注 2万+

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

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

【docker】cgroups资源限制

通过-cpu-share并不是cpu资源的绝对数量,而是一个相对的权重值,某个容器最终能分配到的cpu资源取决于它的cpu share占所有容器 cpu share综合的比例。Block IO 是另一种可以限制容器使用的资源,Block IO 指的是磁盘的读写,docker可通过设置权重,限制bps和iops的方式控制容器读写磁盘的带宽。共享式CPU资源,是按比例切分CPU资源,Docker默认每个容器的权值为1024。在有多个容器竞争CPU时,我们可以设置每个容器能会用的CPU时间比例,这个比例叫做。

种一颗树最好的时间是十年前,其次是现在! 2690

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

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

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

qq_39241682的博客 2172

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

Docker 资源限制:如何通过 Cgroups 机制实现资源限制?

我们知道使用不同的 Namespace,可以实现容器中的进程看不到别的容器的资源,但是有一个问题你是否注意到?容器内的进程仍然可以任意地使用主机的 CPU 、内存等资源,如果某一个容器使用的主机资源过多,可能导致主机的资源竞争,进而影响业务。那如果我们想限制一个容器资源的使用(如 CPU、内存等)应该如何做呢? 这里就需要用到 Linux 内核的另一个核心技术cgroups。那么究竟什么是cgroups?我们应该如何使用cgroups?Docker 又是如何使用cgroups的?下面我带你一一解密。 首

小楼一夜听春雨,深巷明朝卖杏花 1103

关于docker cgroups资源限制的问题例子解析

在容器化技术中,Docker 利用 Linux 内核的 Cgroups(Control Groups)功能来实现对容器资源的限制和管理。Cgroups 允许系统管理员对进程组使用的资源进行控制、监控和隔离,包括 CPU、内存、磁盘 I/O 等资源。

IT老农民的博客 1004

Docker与Cgroups资源控制实战

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

Chujun123528的博客 1218

Docker Cgroups——Docker 资源限制背后的技术原理

但是 Linux Cgroups 对资源的限制最大的问题还是限制不彻底,Linux 下的 /proc 路径下存储着当前内核运行状态的一系列特殊文件,用户可以通过访问这些文件来查看系统信息,它们也是 top 查看 CPU 占用的数据来源。代表在每 100ms 的时间里,被 9226c3249105f42d04b433baa134af9bb10891de2df72fe2edfc6f2bb0a41fb2 控制组限制的进程只能使用 20ms 的 CPU 时间,也就是这个进程最多只能使用 20% 的 CPU 带宽。

RayPick的博客 4401

Docker中调用cgroups技术,gvisor中资源限制技术

Docker 是一个开源的容器化平台,它允许开发者打包应用及其依赖到一个轻量级、可移植的容器中,然后可以在任何支持 Docker 的机器上运行这个容器。Docker 使用 Linux 容器(LXC)技术,但它提供了比传统 LXC 更简单的操作界面。Containerd 是一个容器运行时,它是 Docker 的核心组件之一,但也可以独立于 Docker 使用。Containerd 负责容器的生命周期管理,包括镜像管理、容器的创建、执行、暂停、停止等。

远方雪的专栏 870

Docker 背后的内核知识——cgroups 资源限制

Docker 背后的内核知识——cgroups 资源限制 上一篇中,我们了解了 Docker 背后使用的资源隔离技术 namespace,通过系统调用构建一个相对隔离的 shell 环境,也可以称之为一个简单的“容器”。本文我们则要开始讲解另一个强大的内核工具——cgroups。他不仅可以限制被 namespace 隔离起来的资源,还可以为资源设置权重、计算使用量、操控进程启停等等。在介绍完基本...

qccz123456的博客 797

Docker-04:CGroups资源控制组

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

weixin_75232881的博客 1483
上一篇: 从零开始写 Docker(二)---优化:使用匿名管道传递参数
下一篇: 从零开始写 Docker(四)---使用 pivotRoot 切换 rootfs 实现文件系统隔离
探索云原生
博客等级 码龄9年 730粉丝 131原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值