docker安全

冷不防 2022-01-11 11:01 338阅读 0赞

docker内部的隔离机制是通过namespace来做的，但是在Linux系统里面很多东西是不能通过namespace来隔离的，比如：时间。
容器的资源控制，而namespace把容器在我们的linux系统网络成为独立个体，并不能做资源限制，很可能一个容器上面跑了一个java程序，但是这个容器把我们的内存占用完了，那么这是不合理的。

所以一定要对docker容器的配额进行限额，资源限制。

docker内部通过Cgroup直接进行资源限制，我们可以在run建立容器时加参数进行控制。

Docker容器的安全性,很大程度上依赖于Linux系统自身,评估Docker的安全性时,主要考虑以下几个方面:

  • Linux内核的命名空间机制提供的容器隔离安全
  • Linux控制组机制对容器资源的控制能力安全。
  • Linux内核的能力机制所带来的操作权限安全
  • Docker程序(特别是服务端)本身的抗攻击性。
  • 其他安全增强机制对容器安全性的影响。

命名空间隔离的安全

  • 当docker run启动一个容器时,Docker将在后台为容器创建一个独立的命名空间。命名空间提供了最基础也最直接的隔离。
  • 与虚拟机方式相比,通过Linux namespace来实现的隔离不是那么彻底。
  • 容器只是运行在宿主机上的一种特殊的进程,那么多个容器之间使用的就还是同一个宿主机的操作系统内核。
  • 在 Linux 内核中,有很多资源和对象是不能被 Namespace 化的,比如:时间

控制组资源控制的安全

  • 当docker run启动一个容器时,Docker将在后台为容器创建一个独立的控制组策略集合。
  • Linux Cgroups提供了很多有用的特性,确保各容器可以公平地分享主机的内存、CPU、磁盘IO等资源。
  • 确保当发生在容器内的资源压力不会影响到本地主机系统和其他
  • 容器,它在防止拒绝服务攻击(DDoS)方面必不可少。

今天我们主要讲一下cgroup机制对容器资源的控制能力。

首先了解一下几个控制器：

  • blkio： 这个subsystem可以为块设备设定输入/输出限制，比如物理驱动设备（包括磁盘、固态硬盘、USB等）。
  • cpu： 这个subsystem使用调度程序控制task对CPU的使用。
  • cpuacct： 这个subsystem自动生成cgroup中task对CPU资源使用情况的报告。
  • cpuset： 这个subsystem可以为cgroup中的task分配独立的CPU（此处针对多处理器系统）和内存。
  • devices： 这个subsystem可以开启或关闭cgroup中task对设备的访问。
  • freezer： 这个subsystem可以挂起或恢复cgroup中的task。
  • memory： 这个subsystem可以设定cgroup中task对内存使用量的限定，并且自动生成这些task对内存资源使用情况的报告。
  • perf_event： 这个subsystem使用后使得cgroup中的task可以进行统一的性能测试。
  • net_cls： 这个subsystem Docker没有直接使用，它通过使用等级识别符（classid）标记网络数据包，从而允许 Linux 流量。

一、实验环境

  • RHEL7.3
  • selinux和firewalld为disabled
  • docker1 : 172.25.70.1

二、设定 内存+交换分区 <=200M
1、针对系统中的某个进程

<1> 安装cgroup服务，可以提供cgexec命令

  1. [root@docker1 ~]# yum install -y libcgroup-tools.x86_64
  2. [root@docker1 ~]# mount -t cgroup
  3. [root@docker1 ~]# cd /sys/fs/cgroup/memory/
  4. [root@docker1 memory]# cat memory.limit_in_bytes 
  5. 9223372036854771712
  6. [root@docker1 memory]# cat memory.memsw.limit_in_bytes 
  7. 9223372036854771712

在这里插入图片描述

<2>设定资源限制参数：内存+交换分区<=200M

  1. [root@docker1 memory]# pwd
  2. /sys/fs/cgroup/memory
  3. #创建目录redhat,该目录的名字随意给。在/sys/fs/cgroup/memory目录中创建的目录,自动继承/sys/fs/cgroup/memory目录中的内容。
  4. [root@docker1 memory]# mkdir redhat
  5. #创建该目录的目的是(1)为了演示容器的运行过程。因为一旦运行容器,就会在该目录下,生成一个docker目录,docker目录中会生成容器ID对应的目录,目录中memory目录下的内容继承于/sys/fs/cgroup/memeory目录下的内容。(2)直接修改/sys/fs/cgroup/memory中的文件的内容,会报错。
  6. #设定最大占用内存为200M(209715200=200*1024*1024。209715200的单位为B)
  7. [root@docker1 memory]# cd redhat/
  8. [root@docker1 redhat]# echo 209715200 > memory.limit_in_bytes 
  9. #因为最大占用内存数和最大占用swap分区的内存数一样。表明最大可用内存为200M,可用swap为0M。即限制了内存+交换分区<=200M
  10. [root@docker1 redhat]# echo 209715200 > memory.memsw.limit_in_bytes
  11. [root@docker1 redhat]# cat memory.limit_in_bytes 
  12. 209715200
  13. [root@docker1 redhat]# cat memory.memsw.limit_in_bytes 
  14. 209715200
  15. 值得注意的是：/sys/fs/cgroup/memory目录中的文件，不能用vim进行编辑，利用vim进行编辑，无法进行保存退出（即使使用"wq!"，也不能保存退出。）

在这里插入图片描述
现在的内存可用available：667M

  1. [root@docker1 redhat]# free -m

在这里插入图片描述
3、<测试>

  1. #值得注意的是：在该目录下进行操作，相当于直接占用内存。
  2. [root@docker1 ~]# cd /dev/shm/
  3. [root@docker1 shm]# cgexec -g memory:redhat dd if=/dev/zero of=bigfile bs=1M count=100
  4. #内存可用少了100M
  5. [root@docker1 shm]# free -m
  6. ===============================================
  7. #因为指定的文件的大小为300M超过了限制,所以显示Killed
  8. [root@docker1 shm]# cgexec -g memory:redhat dd if=/dev/zero of=bigfile bs=1M count=300
  9. #dd命令最多只能占用内存200M
  10. [root@docker1 shm]# free -m

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
补充内容：

如果不对内存和swap分区进行限制，即不修改/sys/fs/cgroup/memory/memory.limit_in_bytes和/sys/fs/cgroup/memory/memory.memsw.limit_in_bytes文件中的内容。那么不管要生成的bigfile文件的大小为多少，dd命令永远会成功。

如果只是对内存进行限制（限制为200M），而没有对交换f分区进行限制，即只修改/sys/fs/cgroup/memory/memory.limit_in_bytes文件中的内容，而并没有修改/sys/fs/cgroup/memory/memory.memsw.limit_in_bytes文件中的内容。那么如果要生成的bigfile文件的大小大于200M，dd命令会成功，但是只有200M是取自内存，剩余的取自交换分区。

2、针对docker容器

<1>指定内存和交换分区的大小，运行容器

  1. #利用ubuntu镜像运行容器vm1,指定内存+交换分区<200M。并使用Ctrl+p+q退出,即不要让容器停掉。
  2. [root@docker1 ~]# docker run -it --name vm1 --memory 209715200 --memory-swap 209715200 ubuntu

<2>查看设置是否生效

  1. [root@docker1 ~]# cd /sys/fs/cgroup/memory/docker/3b5f02d2b207166ccedbbf81feefa5a2adbdccb137785eed00065788fbfae89e/
  2. [root@docker1 3b5f02d2b207166ccedbbf81feefa5a2adbdccb137785eed00065788fbfae89e]# cat memory.limit_in_bytes 
  3. 209715200
  4. [root@docker1 3b5f02d2b207166ccedbbf81feefa5a2adbdccb137785eed00065788fbfae89e]# cat memory.memsw.limit_in_bytes 
  5. 209715200

在这里插入图片描述
查看容器vm1的容器ID号

  1. [root@docker1 ~]# docker ps

在这里插入图片描述
查看容器vm1的Pid号

  1. [root@docker1 ~]# docker inspect vm1 | grep Pid

在这里插入图片描述
值得注意的是：因为容器的隔离性并不是很好，所以在容器内使用命令”free -m”看到的内容与宿主机上使用命令”free -m”看到的内容相同。所以如果要看是否限制成功，需要进入容器对应的目录中进行查看。

补充内容：

–memory可以单独使用,但是–memory-swap是必须要与–memory一起使用的

正常情况下,–memory-swap的值包含容器可用内存和可用swap,所以–memory=“300m” —memory-swap=”1g”的含义为:容器可以使用300M的物理内存,并且可以使用700M(1G-300M)的swap。–memory-swap 是容器可以使用的物理内存和可以使用的swap之和!
把–memory-swap设置为0和不设置是一样的,此时如果设置了–memory,则容器可以使用两倍–memory容量的swap。–memory=“300m”,–memory-swap没有设置,相当于可以使用300m内存+600m的swap
如果–memory-swap的值和–memory相同,则容器不能使用swap。
如果–memory-swap设置为-1,相当于不限制swap的容量,但是会受host主机的swap容量
在容器内部,free看到的swap是host的swap,并不是容器可用的swap容量。
–oom-kill-disable 当OOM(Out Of Memory)发生的时候,内核会kill掉容器内的进程,为了改变这种行为,可以在设置–memory的时候,同时设置–oom-kill-disable。如果没有设置–oom-kill-disable,则host可能会OOM,这时候内核会kill host的系统进程来释放memory。

三、针对cpu的限制
1、针对系统的某一个进程

<1>对cpu.cfs_quota_us写入整数值可以控制占用的cpu的大小

  1. [root@docker1 cpu]# mkdir redhat2
  2. [root@docker1 cpu]# cd redhat2/
  3. #占用"20000/100000=20%"的CPU
  4. [root@docker1 redhat2]# echo 20000 > cpu.cfs_quota_us
  5. [root@docker1 redhat2]# cat cpu.cfs_quota_us 
  6. 20000
  7. 值得注意的是：/sys/fs/cgroup/cpu目录中的文件，不能用vim进行编辑，利用vim进行编辑，无法进行保存退出（即使使用"wq!"，也不能保存退出。）

<2>测试

  1. [root@docker1 ~]# dd if=/dev/zero of=/dev/null &
  2. [1] 7333
  3. [root@docker1 ~]# top
  4.  7333 root      20   0  107940    608    516 R 99.3  0.1   0:18.22 dd  
  5. [root@docker1 ~]# cd /sys/fs/cgroup/cpu/redhat2/
  6. [root@docker1 redhat2]# cat tasks
  7. [root@docker1 redhat2]# echo 7333 > tasks 
  8. [root@docker1 redhat2]# cat tasks 
  9. 7333
  10. [root@docker1 redhat2]# top
  11.   PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND     
  12.  7333 root      20   0  107940    608    516 R  7.7  0.1   2:22.14 dd 
  13. [root@docker1 redhat2]# kill -9 7333
  14. [root@docker1 redhat2]# cat tasks 
  15. [1]+  Killed                  dd if=/dev/zero of=/dev/null  (wd: ~)
  16. (wd now: /sys/fs/cgroup/cpu/redhat2)

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

补充：

  • 如果不对cpu进行限制，即不修改/sys/fs/cgroup/cpu/cpu.cfs_quota_us（文件内容默认是-1，表示不限制）文件中的内容。那么执行命令”dd if=/dev/zero of=/dev/null &”时，会占用100%的cpu。
  • cpu.cfs_period_us：cpu分配的周期(微秒），默认为100000。
  • cpu.cfs_quota_us：表示该control group限制占用的时间（微秒），默认为-1，表示不限制。如果设为50000，表示占用50000/100000=50%的CPU。

2、针对docker容器

<1>指定占用的cpu的大小，运行容器

  1. [root@docker1 redhat2]# docker run -it --name vm2 --cpu-quota 20000 ubuntu
  2. root@f198176c0826:/# dd if=/dev/zero of=/dev/null &
  3. [1] 15
  4. root@f198176c0826:/#

<2>测试

  1. [root@docker1 ~]# top
  2.   PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND     
  3.  7442 root      20   0    4368    360    280 R 20.0  0.0   0:06.28 dd 
  4. [root@docker1 ~]# cd /sys/fs/cgroup/cpu
  5. [root@docker1 cpu]# cd docker/
  6. [root@docker1 docker]# ls
  7. [root@docker1 docker]# docker ps
  8. [root@docker1 docker]# cd f198176c082662ba7d11ac2678ec76a7b8bb5f16fa7f0cfbc2860ec102628453/
  9. [root@docker1 f198176c082662ba7d11ac2678ec76a7b8bb5f16fa7f0cfbc2860ec102628453]# cat cpu.cfs_quota_us 
  10. 20000
  11. [root@docker1 f198176c082662ba7d11ac2678ec76a7b8bb5f16fa7f0cfbc2860ec102628453]# cat tasks 
  12. 7398

在这里插入图片描述
在这里插入图片描述
查看容器vm2的容器Pid

  1. [root@docker1 ~]# docker inspect vm2 | grep Pid

在这里插入图片描述
补充内容

如果在运行容器时，不对cpu进行限制，那么在容器内执行命令”dd if=/dev/zero of=/dev/null”，cpu的占有率会接近100%

四、 针对写速率的限制
针对docker容器

<1>赋予全部的权限运行容器（因为直接运行容器的话，是以普通用户的身份进行登录的，会没有权限），查看容器内的磁盘名称

首先不做任何操作运行容器：(普通用户身份)

  1. [root@docker1 ~]# docker run -it --name vm1 ubuntu
  2. root@807d018f920e:/# fdisk -l

在这里插入图片描述
全部的权限运行容器：

  1. [root@docker1 ~]# docker run -it --rm --privileged=true ubuntu
  2. root@3d3b14ed2270:/# fdisk -l

在这里插入图片描述

<2>限制写入的速率，运行容器，并进行测试

  1. #以写入速率为20M/s的限制运行容器
  2. [root@docker1 ~]# docker run -it --rm --device-write-bps /dev/sda:20MB ubuntu
  3. #截取300M的名为file的文件。其中参数oflag=direct表示跳过内存缓存
  4. root@e52dd3422916:/# dd if=/dev/zero of=file bs=1M count=300 oflag=direct
  5. #看到速率为18.0 MB/s,表示配置成功

在这里插入图片描述
五、Block IO限制

我们首先查看我们的memory控制器是否存在：

  1. [root@docker1 redhat]# cd /sys/fs/cgroup/memory/redhat
  2. [root@docker1 redhat]# echo 314572800 > memory.limit_in_bytes 
  3. [root@docker1 redhat]# echo 314572800 > memory.memsw.limit_in_bytes 
  4. [root@docker1 redhat]# cat memory.memsw.limit_in_bytes 
  5. 314572800

建立一个测试用户：

  1. [root@docker1 redhat]# useradd ma

编辑文件，配置

  1. [root@docker1 redhat]# vim /etc/cgrules.conf 
  2. [root@docker1 redhat]# cat /etc/cgrules.conf 
  3. =============================================
  4. ma    memory    redhat/

启动服务：

  1. [root@docker1 redhat2]# systemctl start cgred.service
  2. [root@docker1 redhat2]# systemctl status cgred.service

在这里插入图片描述

发表评论

表情：
评论列表 （有 0 条评论，338人围观）

还没有评论，来说两句吧...

相关阅读

    相关 docker是否安全？

    ocker本身是共享操作系统的进程，不存在不安全一说。如果说docker不安全，那么所有的Linux程序就都是不安全的，而目前全球90%以上的网站都是运行在Linux上的...

    悠悠悠悠/ 0 赞/ 85 阅读

    相关 docker(11):安全

    1.内核名字空间 Docker 容器和 LXC 容器很相似，所提供的安全特性也差不多。当用 docker run 启动一个容器时，在后台 Docker 为容器创建了一个独

    快来打我*快来打我*/ 0 赞/ 208 阅读

    相关 docker安全

    docker内部的隔离机制是通过namespace来做的，但是在Linux系统里面很多东西是不能通过namespace来隔离的，比如：时间。 容器的资源控制，而namesp

    冷不防冷不防/ 0 赞/ 339 阅读

    相关 Docker的安全管理

             Docker安全是Docker团队和广大使用者都极为关注的话题，Docker能否在生产环境和公有云环境中普及，在于Docker能否提供安全可靠的运行环境。目前

    短命女短命女/ 0 赞/ 380 阅读

    相关 Docker 安全

    由内核的命名空间和控制组机制提供的容器内在安全 Docker 程序（特别是服务端）本身的抗攻击性

    朱雀朱雀/ 0 赞/ 2020 阅读