Docker 资源限制：如何通过 Cgroups 机制实现资源限制？

已于 2024-03-19 10:01:50 修改
阅读量642 收藏 2
点赞数 1
分类专栏： Docker Cgroup 文章标签： docker
于 2020-12-29 10:49:47 首次发布
原文链接：c.com
版权

我们知道使用不同的 Namespace，可以实现容器中的进程看不到别的容器的资源，但是有一个问题你是否注意到？容器内的进程仍然可以任意地使用主机的 CPU 、内存等资源，如果某一个容器使用的主机资源过多，可能导致主机的资源竞争，进而影响业务。那如果我们想限制一个容器资源的使用（如 CPU、内存等）应该如何做呢？

这里就需要用到 Linux 内核的另一个核心技术cgroups。那么究竟什么是cgroups？我们应该如何使用cgroups？Docker 又是如何使用cgroups的？下面我带你一一解密。

首先我们来学习下什么是cgroups。

cgroups

cgroups（全称：control groups）是 Linux 内核的一个功能，它可以实现限制进程或者进程组的资源（如 CPU、内存、磁盘 IO 等）。

在 2006 年，Google 的工程师（ Rohit Seth 和 Paul Menage 为主要发起人） 发起了这个项目，起初项目名称并不是cgroups，而被称为进程容器（process containers）。在 2007 年cgroups代码计划合入Linux 内核，但是当时在 Linux 内核中，容器（container）这个词被广泛使用，并且拥有不同的含义。为了避免命名混乱和歧义，进程容器被重名为cgroups，并在 2008 年成功合入 Linux 2.6.24 版本中。cgroups目前已经成为 systemd、Docker、Linux Containers（LXC） 等技术的基础。

cgroups 功能及核心概念 

cgroups 主要提供了如下功能。

  • 资源限制： 限制资源的使用量，例如我们可以通过限制某个业务的内存上限，从而保护主机其他业务的安全运行。
  • 优先级控制：不同的组可以有不同的资源（ CPU 、磁盘 IO 等）使用优先级。
  • 审计：计算控制组的资源使用情况。
  • 控制：控制进程的挂起或恢复。

了解了 cgroups 可以为我们提供什么功能，下面我来看下 cgroups 是如何实现这些功能的。

cgroups功能的实现依赖于三个核心概念：子系统、控制组、层级树。

  • 子系统（subsystem）：是一个内核的组件，一个子系统代表一类资源调度控制器。例如内存子系统可以限制内存的使用量，CPU 子系统可以限制 CPU 的使用时间。
  • 控制组（cgroup）：表示一组进程和一组带有参数的子系统的关联关系。例如，一个进程使用了 CPU 子系统来限制 CPU 的使用时间，则这个进程和 CPU 子系统的关联关系称为控制组。
  • 层级树（hierarchy）：是由一系列的控制组按照树状结构排列组成的。这种排列方式可以使得控制组拥有父子关系，子控制组默认拥有父控制组的属性，也就是子控制组会继承于父控制组。比如，系统中定义了一个控制组 c1，限制了 CPU 可以使用 1 核，然后另外一个控制组 c2 想实现既限制 CPU 使用 1 核，同时限制内存使用 2G，那么 c2 就可以直接继承 c1，无须重复定义 CPU 限制。

cgroups 的三个核心概念中，子系统是最核心的概念，因为子系统是真正实现某类资源的限制的基础。

cgroups 子系统实例 

 下面我通过一个实例演示一下在 Linux 上默认都启动了哪些子系统。我们先通过 mount 命令查看一下当前系统已经挂载的cgroups信息：

$ sudo mount -t cgroup

cgroup on /sys/fs/cgroup/systemd type cgroup (rw,nosuid,nodev,noexec,relatime,seclabel,xattr,release_agent=/usr/lib/systemd/systemd-cgroups-agent,name=systemd)
cgroup on /sys/fs/cgroup/net_cls,net_prio type cgroup (rw,nosuid,nodev,noexec,relatime,seclabel,net_prio,net_cls)
cgroup on /sys/fs/cgroup/blkio type cgroup (rw,nosuid,nodev,noexec,relatime,seclabel,blkio)
cgroup on /sys/fs/cgroup/pids type cgroup (rw,nosuid,nodev,noexec,relatime,seclabel,pids)
cgroup on /sys/fs/cgroup/cpu,cpuacct type cgroup (rw,nosuid,nodev,noexec,relatime,seclabel,cpuacct,cpu)
cgroup on /sys/fs/cgroup/perf_event type cgroup (rw,nosuid,nodev,noexec,relatime,seclabel,perf_event)
cgroup on /sys/fs/cgroup/freezer type cgroup (rw,nosuid,nodev,noexec,relatime,seclabel,freezer)
cgroup on /sys/fs/cgroup/devices type cgroup (rw,nosuid,nodev,noexec,relatime,seclabel,devices)
cgroup on /sys/fs/cgroup/memory type cgroup (rw,nosuid,nodev,noexec,relatime,seclabel,memory)
cgroup on /sys/fs/cgroup/cpuset type cgroup (rw,nosuid,nodev,noexec,relatime,seclabel,cpuset)
cgroup on /sys/fs/cgroup/hugetlb type cgroup (rw,nosuid,nodev,noexec,relatime,seclabel,hugetlb)

我的操作系统版本为 CentOS7.8，内核为 3.10.0-1127.el7.x86_64 版本，不同内核版本cgroups子系统和使用方式可能略有差异。如果你对cgroups不是很熟悉，请尽量使用与我相同的内核环境操作。

通过输出，可以看到当前系统已经挂载了我们常用的cgroups子系统，例如 cpu、memory、pids 等我们常用的cgroups子系统。这些子系统中，cpu 和 memory 子系统是容器环境中使用最多的子系统，下面我对这两个子系统做详细介绍。 

 

cpu 子系统

我首先以 cpu 子系统为例，演示一下cgroups如何限制进程的 cpu 使用时间。由于cgroups的操作很多需要用到 root 权限，我们在执行命令前要确保已经切换到了 root 用户，以下命令的执行默认都是使用 root 用户。

第一步：在 cpu 子系统下创建 cgroup

cgroups的创建很简单，只需要在相应的子系统下创建目录即可。下面我们到 cpu 子系统下创建测试文件夹：

# mkdir /sys/fs/cgroup/cpu/mydocker

执行完上述命令后，我们查看一下我们新创建的目录下发生了什么？

# ls -l /sys/fs/cgroup/cpu/mydocker
total 0
-rw-r--r--. 1 root root 0 Sep  5 09:19 cgroup.clone_children
--w--w--w-. 1 root root 0 Sep  5 09:19 cgroup.event_control
-rw-r--r--. 1 root root 0 Sep  5 09:19 cgroup.procs
-rw-r--r--. 1 root root 0 Sep  5 09:19 cpu.cfs_period_us
-rw-r--r--. 1 root root 0 Sep  5 09:19 cpu.cfs_quota_us
-rw-r--r--. 1 root root 0 Sep  5 09:19 cpu.rt_period_us
-rw-r--r--. 1 root root 0 Sep  5 09:19 cpu.rt_runtime_us
-rw-r--r--. 1 root root 0 Sep  5 09:19 cpu.shares
-r--r--r--. 1 root root 0 Sep  5 09:19 cpu.stat
-r--r--r--. 1 root root 0 Sep  5 09:19 cpuacct.stat
-rw-r--r--. 1 root root 0 Sep  5 09:19 cpuacct.usage
-r--r--r--. 1 root root 0 Sep  5 09:19 cpuacct.usage_percpu
-rw-r--r--. 1 root root 0 Sep  5 09:19 notify_on_release
-rw-r--r--. 1 root root 0 Sep  5 09:19 tasks

由上可以看到我们新建的目录下被自动创建了很多文件，其中 cpu.cfs_quota_us 文件代表在某一个阶段限制的 CPU 时间总量，单位为微秒。例如，我们想限制某个进程最多使用 1 核 CPU，就在这个文件里写入 100000（100000 代表限制 1 个核） ，tasks 文件中写入进程的 ID 即可（如果要限制多个进程 ID，在 tasks 文件中用换行符分隔即可）。

此时，我们所需要的 cgroup 就创建好了。对，就是这么简单。

[root@jenkins-master e2e3f2f0d1f27d627b64adb181d66799882a03fc72083435afe3f0000d2d7047]# cat cpu.cfs_quota_us 
-1

第二步：创建进程，加入 cgroup

这里为了方便演示，我先把当前运行的 shell 进程加入 cgroup，然后在当前 shell 运行 cpu 耗时任务（这里利用到了继承，子进程会继承父进程的 cgroup）。

使用以下命令将 shell 进程加入 cgroup 中：

# cd /sys/fs/cgroup/cpu/mydocker
# echo $$ > tasks

查看一下 tasks 文件内容：

# cat tasks
3485
3543

其中第一个进程 ID 为当前 shell 的主进程，也就是说，当前 shell 主进程为 3485。

第三步：执行 CPU 耗时任务，验证 cgroup 是否可以限制 cpu 使用时间

下面，我们使用以下命令制造一个死循环，来提升 cpu 使用率：

# while true;do echo;done;

 执行完上述命令后，我们新打开一个 shell 窗口，使用 top -p 命令查看当前 cpu 使用率，-p 参数后面跟进程 ID，我这里是 3485。

$ top -p 3485
top - 09:51:35 up 3 days, 22:00,  4 users,  load average: 1.59, 0.58, 0.27
Tasks:   1 total,   0 running,   1 sleeping,   0 stopped,   0 zombie
%Cpu(s):  9.7 us,  2.8 sy,  0.0 ni, 87.4 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem : 32779616 total, 31009780 free,   495988 used,  1273848 buff/cache
KiB Swap:        0 total,        0 free,        0 used. 31852336 avail Mem
  PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND
3485 root      20   0  116336   2852   1688 S  99.7  0.0   2:10.71 bash

通过上面输出可以看到 3485 这个进程被限制到了只能使用 100 % 的 cpu，也就是 1 个核。说明我们使用 cgroup 来限制 cpu 使用时间已经生效。此时，执行 while 循环的命令行窗口可以使用 Ctrl+c 退出循环。

为了进一步证实 cgroup 限制 cpu 的准确性，我们修改 cpu 限制时间为 0.5 核，命令如下：

# cd /sys/fs/cgroup/cpu/mydocker
# echo 50000 > cpu.cfs_quota_us

同样使用上面的命令来制造死循环：

# while true;do echo;done;

保持当前窗口，新打开一个 shell 窗口，使用 top -p 参数查看 cpu 使用率：

$ top -p 3485
top - 10:05:25 up 3 days, 22:14,  3 users,  load average: 1.02, 0.43, 0.40
Tasks:   1 total,   1 running,   0 sleeping,   0 stopped,   0 zombie
%Cpu(s):  5.0 us,  1.3 sy,  0.0 ni, 93.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem : 32779616 total, 31055676 free,   450224 used,  1273716 buff/cache
KiB Swap:        0 total,        0 free,        0 used. 31898216 avail Mem
  PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND
 3485 root      20   0  115544   2116   1664 R  50.0  0.0   0:23.39 bash

通过上面输出可以看到，此时 cpu 使用率已经被限制到了 50%，即 0.5 个核。验证完 cgroup 限制 cpu，我们使用相似的方法来验证 cgroup 对内存的限制。

memroy 子系统

第一步：在 memory 子系统下创建 cgroup

# mkdir /sys/fs/cgroup/memory/mydocker

同样，我们查看一下新创建的目录下发生了什么？

total 0
-rw-r--r--. 1 root root 0 Sep  5 10:18 cgroup.clone_children
--w--w--w-. 1 root root 0 Sep  5 10:18 cgroup.event_control
-rw-r--r--. 1 root root 0 Sep  5 10:18 cgroup.procs
-rw-r--r--. 1 root root 0 Sep  5 10:18 memory.failcnt
--w-------. 1 root root 0 Sep  5 10:18 memory.force_empty
-rw-r--r--. 1 root root 0 Sep  5 10:18 memory.kmem.failcnt
-rw-r--r--. 1 root root 0 Sep  5 10:18 memory.kmem.limit_in_bytes
-rw-r--r--. 1 root root 0 Sep  5 10:18 memory.kmem.max_usage_in_bytes
-r--r--r--. 1 root root 0 Sep  5 10:18 memory.kmem.slabinfo
-rw-r--r--. 1 root root 0 Sep  5 10:18 memory.kmem.tcp.failcnt
-rw-r--r--. 1 root root 0 Sep  5 10:18 memory.kmem.tcp.limit_in_bytes
-rw-r--r--. 1 root root 0 Sep  5 10:18 memory.kmem.tcp.max_usage_in_bytes
-r--r--r--. 1 root root 0 Sep  5 10:18 memory.kmem.tcp.usage_in_bytes
-r--r--r--. 1 root root 0 Sep  5 10:18 memory.kmem.usage_in_bytes
-rw-r--r--. 1 root root 0 Sep  5 10:18 memory.limit_in_bytes
-rw-r--r--. 1 root root 0 Sep  5 10:18 memory.max_usage_in_bytes
-rw-r--r--. 1 root root 0 Sep  5 10:18 memory.memsw.failcnt
-rw-r--r--. 1 root root 0 Sep  5 10:18 memory.memsw.limit_in_bytes
-rw-r--r--. 1 root root 0 Sep  5 10:18 memory.memsw.max_usage_in_bytes
-r--r--r--. 1 root root 0 Sep  5 10:18 memory.memsw.usage_in_bytes
-rw-r--r--. 1 root root 0 Sep  5 10:18 memory.move_charge_at_immigrate
-r--r--r--. 1 root root 0 Sep  5 10:18 memory.numa_stat
-rw-r--r--. 1 root root 0 Sep  5 10:18 memory.oom_control
----------. 1 root root 0 Sep  5 10:18 memory.pressure_level
-rw-r--r--. 1 root root 0 Sep  5 10:18 memory.soft_limit_in_bytes
-r--r--r--. 1 root root 0 Sep  5 10:18 memory.stat
-rw-r--r--. 1 root root 0 Sep  5 10:18 memory.swappiness
-r--r--r--. 1 root root 0 Sep  5 10:18 memory.usage_in_bytes
-rw-r--r--. 1 root root 0 Sep  5 10:18 memory.use_hierarchy
-rw-r--r--. 1 root root 0 Sep  5 10:18 notify_on_release
-rw-r--r--. 1 root root 0 Sep  5 10:18 tasks

其中 memory.limit_in_bytes 文件代表内存使用总量，单位为 byte。

例如，这里我希望对内存使用限制为 1G，则向 memory.limit_in_bytes 文件写入 1073741824，命令如下：

# cd /sys/fs/cgroup/memory/mydocker
# echo 1073741824 > memory.limit_in_bytes

第二步：创建进程，加入 cgroupcd

同样把当前 shell 进程 ID 写入 tasks 文件内：

# cd /sys/fs/cgroup/memory/mydocker
# echo $$ > tasks

第三步，执行内存测试工具，申请内存

这里我们需要借助一下工具 memtester，memtester 的安装这里不再详细介绍了CentOS7 安装内存测试工具 memtester

安装好 memtester 后，我们执行以下命令：

# memtester 1500M 1
memtester version 4.2.2 (64-bit)
Copyright (C) 2010 Charles Cazabon.
Licensed under the GNU General Public License version 2 (only).
pagesize is 4096
pagesizemask is 0xfffffffffffff000
want 1500MB (1572864000 bytes)
got  1500MB (1572864000 bytes), trying mlock ...Killed

该命令会申请 1500 M 内存，并且做内存测试。由于上面我们对当前 shell 进程内存限制为 1 G，当 memtester 使用的内存达到 1G 时，cgroup 便将 memtester 杀死。

上面最后一行的输出结果表示 memtester 想要 1500 M 内存，但是由于 cgroup 限制，达到了内存使用上限，被杀死了，与我们的预期一致。

我们可以使用以下命令，降低一下内存申请，将内存申请调整为 500M：

# memtester 500M 1
memtester version 4.2.2 (64-bit)
Copyright (C) 2010 Charles Cazabon.
Licensed under the GNU General Public License version 2 (only).
pagesize is 4096
pagesizemask is 0xfffffffffffff000
want 500MB (524288000 bytes)
got  500MB (524288000 bytes), trying mlock ...locked.
Loop 1/1:
  Stuck Address       : ok
  Random Value        : ok
  Compare XOR         : ok
  Compare SUB         : ok
  Compare MUL         : ok
  Compare DIV         : ok
  Compare OR          : ok
  Compare AND         : ok
  Sequential Increment: ok
  Solid Bits          : ok
  Block Sequential    : ok
  Checkerboard        : ok
  Bit Spread          : ok
  Bit Flip            : ok
  Walking Ones        : ok
  Walking Zeroes      : ok
  8-bit Writes        : ok
  16-bit Writes       : ok
Done.

这里可以看到，此时 memtester 已经成功申请到 500M 内存并且正常完成了内存测试。
到此，我们讲解了cgroups的 cpu 和 memroy 子系统，如果你想了解更多的cgroups的知识和使用，可以参考

Chapter 1. Introduction to Control Groups (Cgroups) Red Hat Enterprise Linux 7 | Red Hat Customer Portal

 

Docker 是如何使用cgroups的？

首先，我们使用以下命令创建一个 nginx 容器：

docker run -it -m=1g nginx

上述命令创建并启动了一个 nginx 容器，并且限制内存为 1G。然后我们进入cgroups内存子系统的目录，使用 ls 命令查看一下该目录下的内容：

# ls -l /sys/fs/cgroup/memory
total 0
-rw-r--r--.  1 root root 0 Sep  1 11:50 cgroup.clone_children
--w--w--w-.  1 root root 0 Sep  1 11:50 cgroup.event_control
-rw-r--r--.  1 root root 0 Sep  1 11:50 cgroup.procs
-r--r--r--.  1 root root 0 Sep  1 11:50 cgroup.sane_behavior
drwxr-xr-x.  3 root root 0 Sep  5 10:50 docker
... 省略部分输出

上述命令创建并启动了一个 nginx 容器，并且限制内存为 1G。然后我们进入cgroups内存子系统的目录，使用 ls 命令查看一下该目录下的内容：

# ls -l /sys/fs/cgroup/memory
total 0
-rw-r--r--.  1 root root 0 Sep  1 11:50 cgroup.clone_children
--w--w--w-.  1 root root 0 Sep  1 11:50 cgroup.event_control
-rw-r--r--.  1 root root 0 Sep  1 11:50 cgroup.procs
-r--r--r--.  1 root root 0 Sep  1 11:50 cgroup.sane_behavior
drwxr-xr-x.  3 root root 0 Sep  5 10:50 docker
... 省略部分输出

通过上面输出可以看到，该目录下有一个 docker 目录，该目录正是 Docker 在内存子系统下创建的。我们进入到 docker 目录下查看一下相关内容：

# cd /sys/fs/cgroup/memory/docker
# ls -l
total 0
drwxr-xr-x. 2 root root 0 Sep  5 10:49 cb5c5391177b44ad87636bf3840ecdda83529e51b76a6406d6742f56a2535d5e
-rw-r--r--. 1 root root 0 Sep  4 10:40 cgroup.clone_children
--w--w--w-. 1 root root 0 Sep  4 10:40 cgroup.event_control
-rw-r--r--. 1 root root 0 Sep  4 10:40 cgroup.procs
... 省略部分输出
-rw-r--r--. 1 root root 0 Sep  4 10:40 tasks

可以看到 docker 的目录下有一个一串随机 ID 的目录，该目录即为我们上面创建的 nginx 容器的 ID。然后我们进入该目录，查看一下该容器的 memory.limit_in_bytes 文件的内容。

# cd cb5c5391177b44ad87636bf3840ecdda83529e51b76a6406d6742f56a2535d5e
# cat memory.limit_in_bytes
1073741824

可以看到内存限制值正好为 1G。
 

事实上，Docker 创建容器时，Docker 会根据启动容器的参数，在对应的 cgroups 子系统下创建以容器 ID 为名称的目录，然后根据容器启动时设置的资源限制参数，修改对应的 cgroups 子系统资源限制文件从而达到资源限制的效果。

 

小结

其实 cgroups 不仅可以实现资源的限制，还可以为我们统计资源的使用情况，容器监控系统的数据来源也是 cgroups 提供的。

另外，请注意 cgroups 虽然可以实现资源的限制，但是不能保证资源的使用。例如，cgroups 限制某个容器最多使用 1 核 CPU，但不保证总是能使用到 1 核 CPU，当 CPU 资源发生竞争时，可能会导致实际使用的 CPU 资源产生竞争。

富士康质检员张全蛋
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
内存测试工具linux,Linux 内存测试工具memtester
weixin_42396918的博客
04-30 399
源码已经编译好，只要make一下就好了。使用方法：Usage: memtester [-p physaddrbase] [B|K|M|G] [loops]如：memtester 28G 3 #测试28G的内存3次。因为系统运行和本工具运行都需要内存，所以不能把所有的内存都测试到。可以先用free 命令查看系统剩余多少内存空间再测试。高级点的可以用-p参数从内存地址开始测试。memtester ve...
Docker学习视频（讲师马永亮）10集之第10集：系统资源限制及验正
07-05
Docker学习视频（讲师马永亮）10集之第10集：如何分配以及限制docker在宿主机上的资源分配。
详解Docker 容器使用 cgroups 限制资源使用
09-30
本篇文章主要介绍了Docker 容器使用 cgroups 限制资源使用，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
docker资源限制工具镜像，stress.tar
05-27
docker，container资源限制镜像
docker资源限制及应用总结1
08-03
一、CPU资源控制 二、内存配额控制 二、内存配额控制 三、磁盘IO配额控制
如何在Docker容器中使用巨页(大页)
weixin_33862188的博客
09-28 1429
在linux环境下常规页面大小是4K，常规巨页大小有两种一种是2MB，一种是1GB。巨页的好处是：减少硬件tlb miss，如此在连续内存访问场景下可以得到较大的性能提升。一般在数据库如：postgreSQL，mySql等数据库都有使用巨页时的优化措施。本文将详细介绍如何在容器环境下使用巨页，以及如何对容器使...
cordns报错failed to write 1 to memory.kmem.limit_in_bytes
静望红尘的博客
06-19 1347
kubeadm初始化集群，cordns报错failed to write 1 to memory.kmem.limit_in_bytes
memtester4.3.0
学海无涯
09-20 4394
前言 为一究memtester原理，现对其每个函数均按照如下格式进行描述： 方法 原理 时间花销 以下是对每个测试项的简要描述： memtester-4.3.0 memtester-ARM int test_stuck_address(bufa, count); （√ ） 先全部把地址值交替取反放入对应存储位置，然后再读出比较，重复2次（官网的重复了16次）：测试addr...
嵌入式Linux内存压力测试
weixin_40673765的博客
01-21 732
1 前言   内存是电子计算机的最重要组成要素之一。 与内存对应的就是外存，如硬盘、外部存储器等。内存是将外存与CPU连接起来的桥梁，计算机中所有数据都需经过内存进行交互，而且所有应用程序都运行在内存中。可见，内存的重要性。如果内存出现问题，轻则是数据错误，严重则是导致系统崩溃。 与通用计算机的内存条可插拔的形式不同，嵌入式计算机（Linux、Android、IOS）的内存通常是焊接在PCB上，与CPU内存控制器直接相连。内存芯片，一般指的是SDRAM，如DDR3、DDR4；内存芯片数据线属于高速总线，由几
极简组调度-CGroup如何限制cpu
qq_41146932的博客
08-10 534
/ 取se.my_q，如果是普通的task se，cfs_rq = NULL，这里就会退出循环，如果是group se，cfs_rq = group_se.my_q，然后在group se的cfs_rq中继续寻找vruntime最小的se。2>task_group.cfs_rq也是一个数组，每个cpu都有一个其对应的cfs_rq，每个cpu上的group se.my_q指向该cpu上对应的group cfs_rq，group下的task.se.cfs_rq也指向该group cfs_rq。
docker镜像存储详解
happyAnger6的专栏
11-11 3003
镜像来源 镜像需要存在于本地仓库中才能用其启动容器，镜像通常有以下三种来源: l  使用dockerfile构建 l  导入从其它仓库save的镜像 l  从远端仓库pull镜像   其它还有对容器进行commit等，但它们的原理都包含在了以上3种方式之中。   无论采用哪种方式，镜像的最初来源一般都是通过dockerfile构建而来，因此首先分析dockerfile构建镜像的过程
Docker学习五：资源限制——Cgroups
weixin_41402069的博客
07-20 928
Docker学习系列
Docker-制作redis容器
weixin_44175366的博客
08-07 166
1.搜索一哈 docker search redis 出来了一堆，我们使用的是第一个 redis Redis is an open source key-value store that… 8420 [OK] bitnami/redis Bitnami Redis Docker Image 155
Linux下CGroup进行CPU内存等资源控制
lbyyy的专栏
01-11 7219
留存 from: http://www.cnblogs.com/kevingrace/p/5685433.html  and  http://www.cnblogs.com/wang_yb/p/3942208.html CGroup 介绍 CGroup 是 Control Groups 的缩写，是 Linux 内核提供的一种可以限制、记录、隔离进程组 (process groups)
内存测试工具memtester使用详解
热门推荐
androidstar_cn的博客
10-16 3万+
memtester的下载地址：http://pyropus.ca/software/memtester/  有源码安装包、deb包、rpm包等。 源码已经编译好，在linux下只要make一下就好了。 笔者要测试的是目标板的内存，所以要交叉编译，目标板为mips架构，所以要改变 Makefile， 解压之后，目录下有这样两个文件：conf-cc、conf-ld 打开conf-c
使用cgroup限制进程的cpu资源
docker、kubernetes学习笔记
04-14 4564
今天尝试了一下使用cgroup (control group)来限制进程对CPU时间的使用。对于一个计算密集型的进程，要求只能使用10%的CPU时间。 准备工作： 1）准备一台CentOS 7服务器。 2）安装go环境。 3）安装cgexec命令。 [root@workstation cpu-01]# yum install libcgroup-tools.x86_64 -y Loaded plugins: fastestmirror Determining fastest m...
linux 内核资源配置--cgroups详解以及在docker中的应用
岳来的博客
06-21 3459
linux 内核资源配置--cgroups详解以及在docker中的应用
Docker学习笔记|第三篇:常用软件docker启动
过期的酒的博客
01-07 270
1.启动consul docker run -p 8500:8500 --name consul -v /home/milk/docker/consul/conf:/consul/conf/ -v /home/milk/docker/consul/data:/consul/data -d consul 2.启动mysql docker run -p 3306:3306 --name mysql ...
内存测试用例memtester4.3.0
精通多种语言helloworld
08-22 1398
memtester-4.3.0 memtester-ARM int test_stuck_address(bufa, count); （√ ） 先全部把地址值交替取反放入对应存储位置，然后再读出比较，重复2次（官网的重复了16次）：测试address bus int test_random_value(bufa, bufb, count); （√ ）等效test_random_compar
docker容器追加资源限制
最新发布
12-20
可以使用Docker的资源限制功能来为容器追加资源限制。具体的方法如下： 1. 内存资源限制： 可以使用`--memory`选项来限制容器的内存使用量。例如，要将容器的内存限制为1GB，可以使用以下命令： ```shell docker run --memory=1g <image_name> ``` 2. CPU资源限制： 可以使用`--cpus`选项来限制容器可以使用的CPU核心数量。例如，要将容器限制为使用1个CPU核心，可以使用以下命令： ```shell docker run --cpus=1 <image_name> ``` 3. 网络资源限制： 可以使用Docker的网络功能来限制容器的网络资源使用。通过创建自定义网络并将多个容器连接到该网络，可以实现应用程序的多个方面。例如，可以使用以下命令创建一个自定义网络： ```shell docker network create mynetwork ``` 然后，可以使用`--network`选项将容器连接到该网络： ```shell docker run --network=mynetwork <image_name> ``` 请注意，以上命令中的`<image_name>`应替换为您要运行的容器的镜像名称。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值