Docker安全之cgroup的权限限制

最新推荐文章于 2024-05-27 12:37:11 发布
最新推荐文章于 2024-05-27 12:37:11 发布
阅读量1.3k 收藏 2
点赞数 1
分类专栏： Docker
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44658961/article/details/103089316
版权

LXC:linuxcgroup namespace
控制组 命名空间 ：环境独立资源隔离
docker run 为容器创建一个独立的命名空间
docker实现隔离没有虚拟机彻底

什么是cgroup

Cgroups 是 control groups 的缩写，是 Linux 内核提供的一种可以限制、记录、隔离进程组（process groups）所使用的物理资源（如：cpu,memory,IO等等）的机制。最初由 google 的工程师提出，后来被整合进 Linux 内核。Cgroups 也是 LXC 为实现虚拟化所使用的资源管理手段，可以说没有cgroups就没有LXC。

cgroup可以干什么

  • 限制进程组可以使用的资源数量（Resource limiting ）。比如：memory子系统可以为进程组设定一个memory使用上限，一旦进程组使用的内存达到限额再申请内存，就会出发OOM（out of memory）。

  • 进程组的优先级控制（Prioritization ）。比如：可以使用cpu子系统为某个进程组分配特定cpu share。

  • 记录进程组使用的资源数量（Accounting ）。比如：可以使用cpuacct子系统记录某个进程组使用的cpu时间

  • 进程组隔离（Isolation）。比如：使用ns子系统可以使不同的进程组使用不同的namespace，以达到隔离的目的，不同的进程组有各自的进程、网络、文件系统挂载空间。

  • 进程组控制（Control）。比如：使用freezer子系统可以将进程组挂起和恢复。

cgroup中需要了解的四个概念

Subsystems: 称之为子系统，一个子系统就是一个资源控制器，比如 cpu子系统就是控制cpu时间分配的一个控制器。

Hierarchies: 可以称之为层次体系也可以称之为继承体系，指的是Control Groups是按照层次体系的关系进行组织的。

Control Groups: 一组按照某种标准划分的进程。进程可以从一个Control Groups迁移到另外一个Control

Groups中，同时Control Groups中的进程也会受到这个组的资源限制。 Tasks:在cgroups中，Tasks就是系统的一个进程。

实验是基于docker已经安装好的基础上，且使用的系统是rhel7.3

控制cpu的占用情况

[root@su1 ~]# systemctl start docker
[root@su1 ~]# mount -t cgroup ##检测cgroup时是否开启##都显示on即可
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/freezer type cgroup (rw,nosuid,nodev,noexec,relatime,seclabel,freezer)
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/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)
cgroup on /sys/fs/cgroup/memory type cgroup (rw,nosuid,nodev,noexec,relatime,seclabel,memory)
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/devices type cgroup (rw,nosuid,nodev,noexec,relatime,seclabel,devices)
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子系统的层级目录

[root@su1 ~]# cd /sys/fs/cgroup
[root@su1 cgroup]# ls
blkio    cpu,cpuacct  freezer  net_cls           perf_event
cpu      cpuset       hugetlb  net_cls,net_prio  pids
cpuacct  devices      memory   net_prio          systemd

创建一个cpu控制群组

[root@su1 cgroup]# cd cpu
[root@su1 cpu]# ls
cgroup.clone_children  cpuacct.usage         cpu.rt_runtime_us  release_agent
cgroup.event_control   cpuacct.usage_percpu  cpu.shares         system.slice
cgroup.procs           cpu.cfs_period_us     cpu.stat           tasks
cgroup.sane_behavior   cpu.cfs_quota_us      docker             user.slice
cpuacct.stat           cpu.rt_period_us      notify_on_release
[root@su1 cpu]# mkdir x1
进入创建的目录，可以看到自动生成文件，与cpu目录里面的文件相同，伪文件
[root@su1 cpu]# cd x1
[root@su1 x1]# ls
cgroup.clone_children  cpuacct.usage         cpu.rt_period_us   notify_on_release
cgroup.event_control   cpuacct.usage_percpu  cpu.rt_runtime_us  tasks
cgroup.procs           cpu.cfs_period_us     cpu.shares
cpuacct.stat           cpu.cfs_quota_us      cpu.stat

测试限制cpu的使用

[root@su1 x1]# cat cpu.cfs_period_us ##cpu分配的周期
100000
[root@su1 x1]# cat cpu.cfs_quota_us
-1 ##-1表示全部使用
[root@su1 x1]# echo 20000 > cpu.cfs_quota_us
[root@su1 x1]# cat cpu.cfs_quota_us
20000 ##表示使用20%
[root@su1 x1]# dd if=/dev/zero of=/dev/null &
[1] 2777

top命令检测占用了99.9%
[root@su1 x1]# top

top - 21:43:25 up  1:49,  1 user,  load average: 0.22, 0.06, 0.06
Tasks: 108 total,   2 running, 106 sleeping,   0 stopped,   0 zombie
%Cpu(s): 38.7 us, 61.3 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem :  1015564 total,   459664 free,   203144 used,   352756 buff/cache
KiB Swap:  2097148 total,  2097148 free,        0 used.   635364 avail Mem 

  PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND       
 2777 root      20   0  107992    608    516 R 99.9  0.1   0:21.28 dd            
 2778 root      20   0  161840   2236   1592 R  0.3  0.2   0:00.03 top

限制cpu使用

[root@su1 x1]# echo 2777 > tasks 
[root@su1 x1]# top

top - 21:47:22 up  1:53,  1 user,  load average: 1.24, 0.65, 0.30
Tasks: 108 total,   2 running, 106 sleeping,   0 stopped,   0 zombie
%Cpu(s):  6.8 us, 11.6 sy,  0.0 ni, 81.6 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem :  1015564 total,   459448 free,   203356 used,   352760 buff/cache
KiB Swap:  2097148 total,  2097148 free,        0 used.   635148 avail Mem 

  PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND       
 2777 root      20   0  107992    608    516 R 20.3  0.1   4:14.16 dd            
5e80ed8bffa8a1a85d8f6af3ce09ba3e46565dc5d4b8225d063a914cf2010555
84dc63ea61d595ac8863018a6133bd6178122f22ee2cbcee7c78cf2e29f378ee
90a979cdd1e326175923f450f7966731ba1fd9bd718bb6fd5a50667878e9ca24
cgroup.clone_children
cgroup.event_control
cgroup.procs
cpuacct.stat
cpuacct.usage
cpuacct.usage_percpu
cpu.cfs_period_us
cpu.cfs_quota_us
cpu.rt_period_us
cpu.rt_runtime_us
cpu.shares
cpu.stat
edc582852d08a74371c36b223476b9d9fdb031381b705700887d6e7fcc6e2677
notify_on_release
tasks

创建一个docker限制其cpu使用

[root@su1 x1]# docker run --help | grep cpu
      --cpu-period int                 Limit CPU CFS (Completely Fair
      --cpu-quota int                  Limit CPU CFS (Completely Fair
      --cpu-rt-period int              Limit CPU real-time period in
      --cpu-rt-runtime int             Limit CPU real-time runtime in
  -c, --cpu-shares int                 CPU shares (relative weight)
      --cpus decimal                   Number of CPUs
      --cpuset-cpus string             CPUs in which to allow execution
      --cpuset-mems string             MEMs in which to allow execution

[root@su1 docker]# docker run -it --name vm1 --cpu-rt-period 100000 --cpu-quota 20000 ubuntu
root@5e80ed8bffa8:/# dd if=/dev/zero of=/dev/null

[root@su1 docker]# cd 5e80ed8bffa8a1a85d8f6af3ce09ba3e46565dc5d4b8225d063a914cf2010555
[root@su1 5e80ed8bffa8a1a85d8f6af3ce09ba3e46565dc5d4b8225d063a914cf2010555]# ls
cgroup.clone_children  cpuacct.usage         cpu.rt_period_us   notify_on_release
cgroup.event_control   cpuacct.usage_percpu  cpu.rt_runtime_us  tasks
cgroup.procs           cpu.cfs_period_us     cpu.shares
cpuacct.stat           cpu.cfs_quota_us      cpu.stat
[root@su1 5e80ed8bffa8a1a85d8f6af3ce09ba3e46565dc5d4b8225d063a914cf2010555]# top

top - 21:56:38 up  2:02,  2 users,  load average: 0.02, 0.25, 0.25
Tasks: 114 total,   3 running, 111 sleeping,   0 stopped,   0 zombie
%Cpu(s): 16.0 us, 24.3 sy,  0.0 ni, 59.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem :  1015564 total,   423572 free,   233684 used,   358308 buff/cache
KiB Swap:  2097148 total,  2097148 free,        0 used.   603480 avail Mem 

  PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND       
 2777 root      20   0  107992    608    516 R 20.3  0.1   6:05.44 dd

不做限制时情况如下

[root@su1 docker]# docker run -it --name vm2  ubuntu
root@94d5d362f0d6:/#  dd if=/dev/zero of=/dev/null
[root@su1 5e80ed8bffa8a1a85d8f6af3ce09ba3e46565dc5d4b8225d063a914cf2010555]# top

top - 21:59:13 up  2:04,  2 users,  load average: 0.78, 0.40, 0.30
Tasks: 114 total,   3 running, 111 sleeping,   0 stopped,   0 zombie
%Cpu(s): 40.0 us, 60.0 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem :  1015564 total,   422828 free,   234212 used,   358524 buff/cache
KiB Swap:  2097148 total,  2097148 free,        0 used.   602860 avail Mem 

  PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND       
 2987 root      20   0    4560    392    328 R 80.0  0.0   1:01.91 dd

限制内存

[root@su1 ~]# cd /sys/fs/cgroup/memory/
[root@su1 memory]# ls
cgroup.clone_children               memory.memsw.failcnt
cgroup.event_control                memory.memsw.limit_in_bytes
cgroup.procs                        memory.memsw.max_usage_in_bytes
cgroup.sane_behavior                memory.memsw.usage_in_bytes
docker                              memory.move_charge_at_immigrate
memory.failcnt                      memory.numa_stat
memory.force_empty                  memory.oom_control
memory.kmem.failcnt                 memory.pressure_level
memory.kmem.limit_in_bytes          memory.soft_limit_in_bytes
memory.kmem.max_usage_in_bytes      memory.stat
memory.kmem.slabinfo                memory.swappiness
memory.kmem.tcp.failcnt             memory.usage_in_bytes
memory.kmem.tcp.limit_in_bytes      memory.use_hierarchy
memory.kmem.tcp.max_usage_in_bytes  notify_on_release
memory.kmem.tcp.usage_in_bytes      release_agent
memory.kmem.usage_in_bytes          system.slice
memory.limit_in_bytes               tasks
memory.max_usage_in_bytes           user.slice
[root@su1 memory]# mkdir x2
[root@su1 memory]# cd x2
[root@su1 x2]# ls
cgroup.clone_children               memory.memsw.failcnt
cgroup.event_control                memory.memsw.limit_in_bytes
cgroup.procs                        memory.memsw.max_usage_in_bytes
memory.failcnt                      memory.memsw.usage_in_bytes
memory.force_empty                  memory.move_charge_at_immigrate
memory.kmem.failcnt                 memory.numa_stat
memory.kmem.limit_in_bytes          memory.oom_control
memory.kmem.max_usage_in_bytes      memory.pressure_level
memory.kmem.slabinfo                memory.soft_limit_in_bytes
memory.kmem.tcp.failcnt             memory.stat
memory.kmem.tcp.limit_in_bytes      memory.swappiness
memory.kmem.tcp.max_usage_in_bytes  memory.usage_in_bytes
memory.kmem.tcp.usage_in_bytes      memory.use_hierarchy
memory.kmem.usage_in_bytes          notify_on_release
memory.limit_in_bytes               tasks
memory.max_usage_in_bytes

[root@su1 ~]# python
Python 2.7.5 (default, Feb 20 2018, 09:19:12) 
[GCC 4.8.5 20150623 (Red Hat 4.8.5-28)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 256 * 1024 *1024 ##256兆换算为字节
268435456

[root@su1 x2]# cat memory.limit_in_bytes
9223372036854771712
[root@su1 x2]# cat  memory.memsw.limit_in_bytes
9223372036854771712
[root@su1 x2]# echo 268435456 > memory.limit_in_bytes
[root@su1 x2]# cat memory.limit_in_bytes
268435456

测压工具

[root@su1 x2]# yum install -y libcgroup-tools-0.41-15.el7.x86_64
[root@su1 x2]# cd /dev/shm  该目录中的会被直接写入内存中
[root@su1 shm]# ls
[root@su1 shm]# free -m
              total        used        free      shared  buff/cache   available
Mem:            991         208         324           7         459         607
Swap:          2047           0        2047
[root@su1 shm]# dd if=/dev/zero of=bigfile bs=1M count=100
100+0 records in
100+0 records out
104857600 bytes (105 MB) copied, 0.0396777 s, 2.6 GB/s
[root@su1 shm]# free -m
              total        used        free      shared  buff/cache   available
Mem:            991         208         223         107         559         507
Swap:          2047           0        2047
[root@su1 shm]# dd if=/dev/zero of=bigfile bs=1M count=300 ##没有限制的情况下
300+0 records in
300+0 records out
314572800 bytes (315 MB) copied, 0.203411 s, 1.5 GB/s


[root@su1 shm]# cgexec -g memory:x2 dd if=/dev/zero of=bigfile bs=1M count=100
100+0 records in
100+0 records out
104857600 bytes (105 MB) copied, 0.035836 s, 2.9 GB/s
[root@su1 shm]# cgexec -g memory:x2 dd if=/dev/zero of=bigfile bs=1M count=300
300+0 records in
300+0 records out
314572800 bytes (315 MB) copied, 0.214675 s, 1.5 GB/s

编辑文件做内存限制
[root@su1 ~]# cd /sys/fs/cgroup/memory/x2/
[root@su1 x2]# echo 268435456 >memory.memsw.limit_in_bytes
-bash: echo: write error: Device or resource busy
[root@su1 shm]# ls
bigfile
[root@su1 shm]# rm -fr bigfile 
[root@su1 x2]# echo 268435456 >memory.memsw.limit_in_bytes
[root@su1 shm]# cgexec -g memory:x2 dd if=/dev/zero of=bigfile bs=1M count=300
Killed

docker中对内存的控制

[root@su1 ~]# docker run --help | grep memory
      --kernel-memory bytes            Kernel memory limit
  -m, --memory bytes                   Memory limit
      --memory-reservation bytes       Memory soft limit
      --memory-swap bytes              Swap limit equal to memory plus swap:
      --memory-swappiness int          Tune container memory swappiness (0 to
[root@su1 ~]# docker run -it --memory 256M --memory-swap=256M ubuntu
root@ac0a9a612910:/# 

[root@su1 memory]# cd docker/
[root@su1 docker]# ls
84dc63ea61d595ac8863018a6133bd6178122f22ee2cbcee7c78cf2e29f378ee
90a979cdd1e326175923f450f7966731ba1fd9bd718bb6fd5a50667878e9ca24
ac0a9a6129106cdaec596bdf926f419984994d8898fa53322a22b1710078de38
cgroup.clone_children
cgroup.event_control
cgroup.procs
edc582852d08a74371c36b223476b9d9fdb031381b705700887d6e7fcc6e2677
memory.failcnt
memory.force_empty
memory.kmem.failcnt
memory.kmem.limit_in_bytes
memory.kmem.max_usage_in_bytes
memory.kmem.slabinfo
memory.kmem.tcp.failcnt
memory.kmem.tcp.limit_in_bytes
memory.kmem.tcp.max_usage_in_bytes
memory.kmem.tcp.usage_in_bytes
memory.kmem.usage_in_bytes
memory.limit_in_bytes
memory.max_usage_in_bytes
memory.memsw.failcnt
memory.memsw.limit_in_bytes
memory.memsw.max_usage_in_bytes
memory.memsw.usage_in_bytes
memory.move_charge_at_immigrate
memory.numa_stat
memory.oom_control
memory.pressure_level
memory.soft_limit_in_bytes
memory.stat
memory.swappiness
memory.usage_in_bytes
memory.use_hierarchy
notify_on_release
tasks
[root@su1 docker ]# docker ps 
CONTAINER ID        IMAGE               COMMAND              CREATED              STATUS              PORTS                   NAMES
ac0a9a612910        ubuntu              "/bin/bash"          About a minute ago   Up About a minute                           stoic_meitner
edc582852d08        httpd               "httpd-foreground"   2 hours ago          Up 2 hours          0.0.0.0:32772->80/tcp   musing_herschel
84dc63ea61d5        httpd               "httpd-foreground"   2 hours ago          Up 2 hours          0.0.0.0:32771->80/tcp   web2
90a979cdd1e3        httpd               "httpd-foreground"   2 hours ago          Up 2 hours          0.0.0.0:32770->80/tcp   web1

[root@su1 docker]# cd ac0a9a6129106cdaec596bdf926f419984994d8898fa53322a22b1710078de38
[root@su1 ac0a9a6129106cdaec596bdf926f419984994d8898fa53322a22b1710078de38]# cat memory.limit_in_bytes
268435456
[root@su1 ac0a9a6129106cdaec596bdf926f419984994d8898fa53322a22b1710078de38]# cat memory.memsw.limit_in_bytes 
268435456

一个测试容器，可以使用该容器进行测试
在这里插入图片描述
限制用户读写内存速度

[root@su1 x3]# vi /etc/resolv.conf
[root@su1 x3]# cd /etc/sysconfig/network-scripts/
[root@su1 network-scripts]# vi ifcfg-eth0
[root@su1 network-scripts]# cd
[root@su1 ~]# vi /etc/cgrules.conf
[root@su1 ~]# systemctl start cgred

[root@su1 ~]# useradd dd
[root@su1 ~]# su - dd
[dd@su1 ~]$ cd /dev/shm
[dd@su1 shm]$ dd if=/dev/zero of=dd bs=1M count=200
200+0 records in
200+0 records out
209715200 bytes (210 MB) copied, 0.483075 s, 434 MB/s
[dd@su1 shm]$ dd if=/dev/zero of=dd bs=1M count=400
dd: error writing ‘dd’: No space left on device
241+0 records in
240+0 records out
252686336 bytes (253 MB) copied, 0.46849 s, 539 MB/s

限制磁盘写入速度

划分磁盘 格式化磁盘

[root@su1 ~]# mkfs.xfs /dev/vda
meta-data=/dev/vda               isize=512    agcount=4, agsize=1310720 blks
         =                       sectsz=512   attr=2, projid32bit=1
         =                       crc=1        finobt=0, sparse=0
data     =                       bsize=4096   blocks=5242880, imaxpct=25
         =                       sunit=0      swidth=0 blks
naming   =version 2              bsize=4096   ascii-ci=0 ftype=1
log      =internal log           bsize=4096   blocks=2560, version=2
         =                       sectsz=512   sunit=0 blks, lazy-count=1
realtime =none                   extsz=4096   blocks=0, rtextents=0
[root@su1 ~]# mount /dev/vda /mnt/


[root@su1 ~]# cd /sys/fs/cgroup/blkio/
[root@su1 blkio]# ls
blkio.io_merged                   blkio.throttle.read_bps_device
blkio.io_merged_recursive         blkio.throttle.read_iops_device
blkio.io_queued                   blkio.throttle.write_bps_device
blkio.io_queued_recursive         blkio.throttle.write_iops_device
blkio.io_service_bytes            blkio.time
blkio.io_service_bytes_recursive  blkio.time_recursive
blkio.io_serviced                 blkio.weight
blkio.io_serviced_recursive       blkio.weight_device
blkio.io_service_time             cgroup.clone_children
blkio.io_service_time_recursive   cgroup.event_control
blkio.io_wait_time                cgroup.procs
blkio.io_wait_time_recursive      cgroup.sane_behavior
blkio.leaf_weight                 docker
blkio.leaf_weight_device          notify_on_release
blkio.reset_stats                 release_agent
blkio.sectors                     system.slice
blkio.sectors_recursive           tasks
blkio.throttle.io_service_bytes   user.slice
blkio.throttle.io_serviced
[root@su1 blkio]# mkdir x3
[root@su1 blkio]# cd x3/
[root@su1 x3]# ll /dev/vda ##查看设备号
brw-rw----. 1 root disk 252, 0 11月 10 00:08 /dev/vda
[root@su1 x3]# ls
blkio.io_merged                   blkio.sectors_recursive
blkio.io_merged_recursive         blkio.throttle.io_service_bytes
blkio.io_queued                   blkio.throttle.io_serviced
blkio.io_queued_recursive         blkio.throttle.read_bps_device
blkio.io_service_bytes            blkio.throttle.read_iops_device
blkio.io_service_bytes_recursive  blkio.throttle.write_bps_device
blkio.io_serviced                 blkio.throttle.write_iops_device
blkio.io_serviced_recursive       blkio.time
blkio.io_service_time             blkio.time_recursive
blkio.io_service_time_recursive   blkio.weight
blkio.io_wait_time                blkio.weight_device
blkio.io_wait_time_recursive      cgroup.clone_children
blkio.leaf_weight                 cgroup.event_control
blkio.leaf_weight_device          cgroup.procs
blkio.reset_stats                 notify_on_release
blkio.sectors                     tasks
[root@su1 x3]# python
Python 2.7.5 (default, Feb 20 2018, 09:19:12)
[GCC 4.8.5 20150623 (Red Hat 4.8.5-28)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 1024 * 1024
1048576
>>>
[root@su1 x3]#  echo "252:0 1048576" > blkio.throttle.write_bps_device


[root@su1 x3]# cat blkio.throttle.write_bps_device
252:0 1048576
[root@su1 x3]# cgexec -g blkio:x3 dd if=/dev/zero of=/mnt/testfile bs=1M count=10
10+0 records in
10+0 records out
10485760 bytes (10 MB) copied, 0.00510456 s, 2.1 GB/s ##写入缓存的
[root@su1 x3]# cgexec -g blkio:x3 dd if=/dev/zero of=/mnt/testfile bs=1M count=10 oflag=direct 当前block io限制只对direct io 有效（不适用文件系统缓存）将跳过内存缓存oflag=direct
10+0 records in
10+0 records out
10485760 bytes (10 MB) copied, 10.0021 s, 1.0 MB/s ##实现了速度控制

docker中对磁盘写入速度的控制

[root@docker blkio]# docker run --help |grep device
      --blkio-weight-device list       Block IO weight (relative device
      --device list                    Add a host device to the container
      --device-cgroup-rule list        Add a rule to the cgroup allowed
                                       devices list
      --device-read-bps list           Limit read rate (bytes per second)
                                       from a device (default [])
      --device-read-iops list          Limit read rate (IO per second)
                                       from a device (default [])
      --device-write-bps list          Limit write rate (bytes per
                                       second) to a device (default [])
      --device-write-iops list         Limit write rate (IO per second)
                                       to a device (default [])

[root@su1 x3]# docker run -it --name vm3 --device-write-bps /dev/vda:1MB ubuntu
root@21c508ac3bc2:/#dd if=/dev/zero of=westos bs=1M count=10 oflag=direct 
10+0 records in
10+0 records out
10485760 bytes (10 MB) copied, 10.0021 s, 1.0 MB/s

[root@su1 blkio]# cd docker/
[root@su1 docker]# ls
21c508ac3bc245a798d62f55618d50f321484d9bad5345b284c312b15efa5842
84dc63ea61d595ac8863018a6133bd6178122f22ee2cbcee7c78cf2e29f378ee
90a979cdd1e326175923f450f7966731ba1fd9bd718bb6fd5a50667878e9ca24
blkio.io_merged
blkio.io_merged_recursive
blkio.io_queued
blkio.io_queued_recursive
blkio.io_service_bytes
blkio.io_service_bytes_recursive
blkio.io_serviced
blkio.io_serviced_recursive
blkio.io_service_time
blkio.io_service_time_recursive
blkio.io_wait_time
blkio.io_wait_time_recursive
blkio.leaf_weight
blkio.leaf_weight_device
blkio.reset_stats
blkio.sectors
blkio.sectors_recursive
blkio.throttle.io_service_bytes
blkio.throttle.io_serviced
blkio.throttle.read_bps_device
blkio.throttle.read_iops_device
blkio.throttle.write_bps_device
blkio.throttle.write_iops_device
blkio.time
blkio.time_recursive
blkio.weight
blkio.weight_device
cgroup.clone_children
cgroup.event_control
cgroup.procs
edc582852d08a74371c36b223476b9d9fdb031381b705700887d6e7fcc6e2677
notify_on_release
tasks
[root@su1 docker]# docker ps
CONTAINER ID        IMAGE               COMMAND              CREATED              STATUS              PORTS                   NAMES
21c508ac3bc2        ubuntu              "/bin/bash"          About a minute ago   Up About a minute                           vm3
edc582852d08        httpd               "httpd-foreground"   4 hours ago          Up 4 hours          0.0.0.0:32772->80/tcp   musing_herschel
84dc63ea61d5        httpd               "httpd-foreground"   4 hours ago          Up 4 hours          0.0.0.0:32771->80/tcp   web2
90a979cdd1e3        httpd               "httpd-foreground"   4 hours ago          Up 4 hours          0.0.0.0:32770->80/tcp   web1
[root@su1 docker]# cd 21c508ac3bc245a798d62f55618d50f321484d9bad5345b284c312b15efa5842
[root@su1 21c508ac3bc245a798d62f55618d50f321484d9bad5345b284c312b15efa5842]# ls
blkio.io_merged                   blkio.sectors_recursive
blkio.io_merged_recursive         blkio.throttle.io_service_bytes
blkio.io_queued                   blkio.throttle.io_serviced
blkio.io_queued_recursive         blkio.throttle.read_bps_device
blkio.io_service_bytes            blkio.throttle.read_iops_device
blkio.io_service_bytes_recursive  blkio.throttle.write_bps_device
blkio.io_serviced                 blkio.throttle.write_iops_device
blkio.io_serviced_recursive       blkio.time
blkio.io_service_time             blkio.time_recursive
blkio.io_service_time_recursive   blkio.weight
blkio.io_wait_time                blkio.weight_device
blkio.io_wait_time_recursive      cgroup.clone_children
blkio.leaf_weight                 cgroup.event_control
blkio.leaf_weight_device          cgroup.procs
blkio.reset_stats                 notify_on_release
blkio.sectors                     tasks
[root@su1 21c508ac3bc245a798d62f55618d50f321484d9bad5345b284c312b15efa5842]# cat  blkio.throttle.write_bps_device
252:0 1048576
qq_44658961
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Docker容器之私有仓库建立和Cgroup资源限制
Wan_JF的博客
12-03 584
引言 一、私有仓库建立 1、创建私有仓库 docker pull registry vim /etc/docker/daemon.json { "insecure-registries": ["192.168.32.11:5000"], "registry-mirrors": ["阿里云加速地址"] } systemctl restart docker.service docker create -it registry /bin/bash docker ps -a docker sta
docker资源限制——cgroup
wangwei1110a的博客
01-19 1236
docker资源限制——cgroup 一、介绍 Docker通过cgoup来控制容器使用的资源配额，包括cpu、内存、磁盘三大方面，基本覆盖了常见的资源配额和使用量控制。 cgroup是control groups的缩写，是Linux 内核提供的一个特性，用于限制和隔离一组进程对系统资源的使用。对不同资源的具体管理是由各个子系统分工完成的。 二、cpu资源控制 1.对cpu使用率控制 linux通过CFS来调度各个进程对cpu的使用。CFS默认的调度周期是100ms。我们可以设置每个容器进程的调度周期，以
解决Fedora31上docker启动报错 open /sys/fs/cgroup/docker/cpuset.cpus.effective: no such file or directory
登上庐山
12-01 916
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/hknaruto/article/details/103032203 $ sudo dnf install -y grubby $ sudo grubby --update-kernel=ALL --args="systemd.unifie...
运维专题.Docker功能权限（Capabilities）管理和查看
最新发布
jclee95的个人博客
05-27 1661
本文介绍Docker中功能权限（Capabilities）管理和查看。
Docker 资源限制 Cgroup
nnn717的博客
07-08 547
_cgroups，是一个非常强大的linux内核工具，他不仅可以限制被namespace隔离起来的资源,还可以为资源设置权重、计算使用量、操控进程启停等等。所以cgroups (Control groups) 实现了对资源的配额和度量。cgroups有四大功能:资源限制:可以对任务使用的资源总额进行限制；先级分配:通过分配的cpu时间片数量以及磁盘I0带宽大小，实际上相当于控制了任务运行优先级；资源统计:可以统计系统的资源使用量，如cpu时长， 内存用量等；任务控制: cgroup可以对任务执行挂起、恢复等
docker安全（权限设置）、cgroup方式设置限制权限
dandan
08-21 3453
给docker一个root权限 docker run -it --name vm2 ubuntu ip link set down eth0 # 失败 docker run -it --name vm2 --privileged ubuntu ip link set down eth0 ip addr docker run –rm -it –name vm4 -m 100M ...
docker之cgroup的权限限制
wzt888的博客
03-26 1000
[root@foundation78 ~]# mount -t cgroup
docker cgroup 资源监控的详解
09-30
Docker Cgroup资源监控详解主要涉及对Docker容器资源管理与监控的技术细节，本文内容将详细阐述如何通过Cgroups实现对Docker容器资源使用的限制和监控。 首先需要了解的是cgroup（control group）的概念。cgroup是...
Docker守护进程安全配置项目详解
09-29
10. 限制容器权限提升（no-new-privileges: true） 11. 自定义cgroup父节点（cgroup-parent: /foobar） 12. 使用Seccomp进行安全配置文件限制（seccomp-pro***） 13. 启用TLS验证（tlsverify: true） 14. 配置TLS...
李泽帆：Cgroup的过去、现状和开发计划
09-02
cgroups之所以能被接受，是因为它借鉴了之前CKRM（class-based kernel resource management system）和Beancounters等项目的经验，将它们进行了整合和发展。 cgroups包含多个子系统，它们负责不同的资源管理方面。...
Linux 离线安装docker的过程（一键式安装）
09-14
在Linux环境中，有时由于网络限制或者服务器安全策略，无法直接在线安装Docker。这时，离线安装成为一种必要的选择。本文将详细介绍如何在Linux上进行Docker的一键式离线安装。 首先，我们需要准备Docker的离线...
容器云安全.docx
05-08
- Docker通过Namespace实现了隔离性，通过Cgroup实现了资源配额限制。 - Capabilities机制提供了细粒度的权限控制，增强安全性。 **2. 容器镜像安全：** - 使用安全的镜像源，定期更新容器镜像以修复已知的安全...
linux c生成文件权限,Linux Cgroup系列（02）：创建并管理cgroup
weixin_39828859的博客
04-30 222
本文将创建并挂载一颗不和任何subsystem绑定的cgroup树，用来演示怎么创建、删除子cgroup，以及如何往cgroup中添加和删除进程。由于不和任何subsystem绑定，所以这棵树没有任何实际的功能，但这不影响我们的演示，还有一个好处就是我们不会受subsystem功能的影响，可以将精力集中在cgroup树上。本篇所有例子都在ubuntu-server-x86_64 16.04下执行通...
Docker LXC及Cgroup及容器文件系统
番茄炒蛋君的博客
10-15 520
目录： 容器生产环境配置 如何分配磁盘、内存和CPU资源 容器生产环境配置 生产环境中，启动Docker容器的话，通常用Guest OS方式启动，便于管理和维护，不会直接启动APP（nginx，tomcat，redis）容器 启动容器是，通常会设定每个容器的资源配置：例如CPU、MEM、DISK、NET CPU，核心数设定：2C、4C、8C、16C、32C； MEM，内存容量：4G、...
Operation not allowed after ResultSet closed,ResultSet is from UPDATE. No Data和Column 'xx' not found
zinbin的博客
04-01 2908
Operation not allowed after ResultSet closed，ResultSet is from UPDATE. No Data和Column ‘xxx’ not found报错的解决方法 1. Operation not allowed after ResultSet closed的解决方法 报错原因： Operation not allowed after Resu...
centos7.4 上面 docker 启动 cAdvisor 报错问题解决
创新是灵魂，执行是生命。
02-01 4759
docker 启动 cAdvisor，操作系统CentOS7.4。 docker run \ --volume=/:/rootfs:ro \ --volume=/var/run:/var/run:rw \ --volume=/sys:/sys:ro \ --volume=/var/lib/docker/:/var/lib/docker:ro \ --publish=8080:
linux c 绑定cpu,Linux Cgroup系列（05）：限制cgroup的CPU使用（subsystem之cpu）
weixin_29887801的博客
05-12 305
在cgroup里面，跟CPU相关的子系统有cpusets、cpuacct和cpu。其中cpuset主要用于设置CPU的亲和性，可以限制cgroup中的进程只能在指定的CPU上运行，或者不能在指定的CPU上运行，同时cpuset还能设置内存的亲和性。设置亲和性一般只在比较特殊的情况才用得着，所以这里不做介绍。cpuacct包含当前cgroup所使用的CPU的统计信息，信息量较少，有兴趣可以去看看它的...
ubuntu 14升级之后 docker 启动失败
i.lufei space
08-11 2258
docker start 失败 System error: open /sys/fs/cgroup/cpu,cpuacct/init.scope/system.slice/docker-c44478b6b**.scope/cpu.shares: no such file or directory
linux cgroup 死循环,Linux CGroup 基础
weixin_30474823的博客
05-14 746
CGroup V11. CGroup 概念Task: 任务，也就是进程，但这里的进程和我们通常意义上的 OS 进程有些区别，在后面会提到。CGroup: 控制组，一个 CGroup 就是一组按照某种标准划分的Tasks。这里的标准就是 Subsystem 配置。换句话说，同一个CGroup 的 Tasks 在一个或多个 Subsystem 上使用同样的配置。Hierarchy: 树形结构的 CGr...
Docker容器安全实践：限制权限与iOS11设计规范
包括限制默认网桥上容器间的网络通信，设置日志级别，允许Docker修改iptables规则，不使用不安全的镜像仓库，避免aufs存储驱动，配置TLS身份验证，设置合适的ulimit，启用用户命名空间，使用默认的cgroup，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值