如何使用 Docker 来限制 CPU、内存和 IO等资源? 

CPU资源控制 cgroups(control groups)是一个非常强大的linux内核工具,他不仅可以限制被namespace隔离起来的资源, 还可以为等等。。 阅读详情

 

2017-08-18 07:32

在使用 Docker 运行容器时,一台主机上可能会运行几百个容器,这些容器虽然互相隔离,但是底层却使用着相同的 CPU、内存和磁盘资源。如果不对容器使用的资源进行限制,那么容器之间会互相影响,小的来说会导致容器资源使用不公平;大的来说,可能会导致主机和集群资源耗尽,服务完全不可用。

Docker 作为容器的管理者,自然提供了控制容器资源的功能。正如使用内核的 namespace 来做容器之间的隔离,Docker 也是通过内核的 cgroups 来做容器的资源限制。这篇文章就介绍如何使用 docker 来限制 CPU、内存和 IO,以及对应的 cgroups 文件。

NOTE:如果想要了解 Cgroups 的更多信息,可以参考 Kernel 文档 或者其他资源。

我本地测试的 Docker 版本是 17.03.0 社区版:

使用的是 ubuntu 16.04 系统,内核版本是 4.10.0:

➜ ~ uname -aLinux cizixs-ThinkPad-T450 4.10.0- 28-generic #32~16.04.2-Ubuntu SMP Thu Jul 2010:19:48UTC 2017x86_64 x86_64 x86_64 GNU/Linux

NOTE: 不同版本和系统的功能会有差异,具体的使用方法和功能解释请以具体版本的 Docker 官方文档为准。

我们使用 stress 容器来产生 CPU、内存和 IO 的压力,具体的使用请参考它的帮助文档。

1.CPU资源

主机上的进程会通过时间分片机制使用 CPU,CPU 的量化单位是频率,也就是每秒钟能执行的运算次数。为容器限制 CPU 资源并不能改变 CPU 的运行频率,而是改变每个容器能使用的 CPU 时间片。理想状态下,CPU 应该一直处于运算状态(并且进程需要的计算量不会超过 CPU 的处理能力)。

Docker 限制 CPU Share

Docker 允许用户为每个容器设置一个数字,代表容器的 CPU share,默认情况下每个容器的 share 是 1024。要注意,这个 share 是相对的,本身并不能代表任何确定的意义。当主机上有多个容器运行时,每个容器占用的 CPU 时间比例为它的 share 在总额中的比例。举个例子,如果主机上有两个一直使用 CPU 的容器(为了简化理解,不考虑主机上其他进程),其 CPU share 都是 1024,那么两个容器 CPU 使用率都是 50%;如果把其中一个容器的 share 设置为 512,那么两者 CPU 的使用率分别为 67% 和 33%;如果删除 share 为 1024 的容器,剩下来容器的 CPU 使用率将会是 100%。

总结下来,这种情况下,Docker 会根据主机上运行的容器和进程动态调整每个容器使用 CPU 的时间比例。这样的好处是能保证 CPU 尽可能处于运行状态,充分利用 CPU 资源,而且保证所有容器的相对公平;缺点是无法指定容器使用 CPU 的确定值。

Docker 为容器设置 CPU share 的参数是 -c --cpu-shares,它的值是一个整数。

我的机器是 4 核 CPU,因此使用 stress 启动 4 个进程来产生计算压力:

➜ stress docker run --rm -it stress --cpu 4stress: info: [ 1] dispatching hogs: 4cpu, 0io, 0vm, 0hddstress: dbug: [ 1] usingbackoff sleep of 12000usstress: dbug: [ 1] --> hogcpu worker 4[ 7] forkedstress: dbug: [ 1] usingbackoff sleep of 9000usstress: dbug: [ 1] --> hogcpu worker 3[ 8] forkedstress: dbug: [ 1] usingbackoff sleep of 6000usstress: dbug: [ 1] --> hogcpu worker 2[ 9] forkedstress: dbug: [ 1] usingbackoff sleep of 3000usstress: dbug: [ 1] --> hogcpu worker 1[ 10] forked

在另外一个 terminal 使用 htop 查看资源的使用情况:

从上图中可以看到,CPU 四个核资源都达到了 100%。四个 stress 进程 CPU 使用率没有达到 100% 是因为系统中还有其他机器在运行。

为了比较,我另外启动一个 share 为 512 的容器:

➜ stress docker run --rm -it -c 512stress --cpu 4stress: info: [ 1] dispatching hogs: 4cpu, 0io, 0vm, 0hddstress: dbug: [ 1] usingbackoff sleep of 12000usstress: dbug: [ 1] --> hogcpu worker 4[ 6] forkedstress: dbug: [ 1] usingbackoff sleep of 9000usstress: dbug: [ 1] --> hogcpu worker 3[ 7] forkedstress: dbug: [ 1] usingbackoff sleep of 6000usstress: dbug: [ 1] --> hogcpu worker 2[ 8] forkedstress: dbug: [ 1] usingbackoff sleep of 3000usstress: dbug: [ 1] --> hogcpu worker 1[ 9] forked

因为默认情况下,容器的 CPU share 为 1024,所以这两个容器的 CPU 使用率应该大致为 2:1,下面是启动第二个容器之后的监控截图:

两个容器分别启动了四个 stress 进程,第一个容器 stress 进程 CPU 使用率都在 54% 左右,第二个容器 stress 进程 CPU 使用率在 25% 左右,比例关系大致为 2:1,符合之前的预期。

限制容器能使用的 CPU 核数

上面讲述的 -c --cpu-shares 参数只能限制容器使用 CPU 的比例,或者说优先级,无法确定地限制容器使用 CPU 的具体核数;从 1.13 版本之后,docker 提供了 --cpus 参数可以限定容器能使用的 CPU 核数。这个功能可以让我们更精确地设置容器 CPU 使用量,是一种更容易理解也因此更常用的手段。

--cpus 后面跟着一个浮点数,代表容器最多使用的核数,可以精确到小数点二位,也就是说容器最小可以使用 0.01 核 CPU。比如,我们可以限制容器只能使用 1.5 核数 CPU:

➜ ~ docker run --rm -it --cpus 1.5stress --cpu 3stress: info: [ 1] dispatching hogs: 3cpu, 0io, 0vm, 0hddstress: dbug: [ 1] usingbackoff sleep of 9000usstress: dbug: [ 1] --> hogcpu worker 3[ 7] forkedstress: dbug: [ 1] usingbackoff sleep of 6000usstress: dbug: [ 1] --> hogcpu worker 2[ 8] forkedstress: dbug: [ 1] usingbackoff sleep of 3000usstress: dbug: [ 1] --> hogcpu worker 1[ 9] forked

在容器里启动三个 stress 来跑 CPU 压力,如果不加限制,这个容器会导致 CPU 的使用率为 300% 左右(也就是说会占用三个核的计算能力)。实际的监控如下图:

可以看到,每个 stress 进程 CPU 使用率大约在 50%,总共的使用率为 150%,符合 1.5 核的设置。

如果设置的 --cpus 值大于主机的 CPU 核数,docker 会直接报错:

➜ ~ docker run --rm -it --cpus 8stress --cpu 3docker: Error response fromdaemon: Range of CPUs isfrom0.01to 4.00, asthere are only 4CPUs available.See 'docker run --help'.

如果多个容器都设置了 --cpus ,并且它们之和超过主机的 CPU 核数,并不会导致容器失败或者退出,这些容器之间会竞争使用 CPU,具体分配的 CPU 数量取决于主机运行情况和容器的 CPU share 值。也就是说 --cpus 只能保证在 CPU 资源充足的情况下容器最多能使用的 CPU 数,docker 并不能保证在任何情况下容器都能使用这么多的 CPU(因为这根本是不可能的)。

限制容器运行在某些 CPU 核

现在的笔记本和服务器都会有多个 CPU,docker 也允许调度的时候限定容器运行在哪个 CPU 上。比如,我的主机上有 4 个核,可以通过 --cpuset 参数让容器只运行在前两个核上:

➜ ~ docker run --rm -it --cpuset-cpus= 0, 1stress --cpu 2stress: info: [ 1] dispatching hogs: 2cpu, 0io, 0vm, 0hddstress: dbug: [ 1] usingbackoff sleep of 6000usstress: dbug: [ 1] --> hogcpu worker 2[ 7] forkedstress: dbug: [ 1] usingbackoff sleep of 3000usstress: dbug: [ 1] --> hogcpu worker 1[ 8] forked

这样,监控中可以看到只有前面两个核 CPU 达到了 100% 使用率。

--cpuset-cpus 参数可以和 -c --cpu-shares 一起使用,限制容器只能运行在某些 CPU 核上,并且配置了使用率。

限制容器运行在哪些核上并不是一个很好的做法,因为它需要实现知道主机上有多少 CPU 核,而且非常不灵活。除非有特别的需求,一般并不推荐在生产中这样使用。

CPU 信息的 cgroup 文件

所有和容器 CPU share 有关的配置都在 /sys/fs/cgroup/cpu/docker/《docker_id》/ 目录下面,其中 cpu.shares 保存了 CPU share 的值(其他文件的意义可以查看 cgroups 的官方文档):

➜ ~ ls /sys/fs/cgroup/cpu/docker/d93c9a660f4a13789d995d56024f160e2267f2dc26ce676daa66ea6435473f6f/ cgroup.clone_children cpuacct. statcpuacct.usage_all cpuacct.usage_percpu_sys cpuacct.usage_sys cpu.cfs_period_us cpu.shares notify_on_releasecgroup.procs cpuacct.usage cpuacct.usage_percpu cpuacct.usage_percpu_user cpuacct.usage_user cpu.cfs_quota_us cpu. stattasks➜ ~ cat /sys/fs/cgroup/cpu/docker/d93c9a660f4a13789d995d56024f160e2267f2dc26ce676daa66ea6435473f6f/cpu.shares 1024

和 cpuset(限制 CPU 核)有关的文件在 /sys/fs/cgroup/cpuset/docker/《docker_id》 目录下,其中 cpuset.cpus 保存了当前容器能使用的 CPU 核:

--cpus 限制 CPU 核数并不像上面两个参数一样有对应的文件对应,它是由 cpu.cfs_period_us 和 cpu.cfs_quota_us 两个文件控制的。如果容器的 --cpus 设置为 3,其对应的这两个文件值为:

➜ ~ cat /sys/fs/cgroup/cpu/docker/233a38cc641f2e4a1bec3434d88744517a2214aff9d8297e908fa13b9aa12e02/cpu.cfs_period_us

100000

➜ ~ cat /sys/fs/cgroup/cpu/docker/233a38cc641f2e4a1bec3434d88744517a2214aff9d8297e908fa13b9aa12e02/cpu.cfs_quota_us

300000

其实在 1.12 以及之前的版本,都是通过 --cpu-period 和 --cpu-quota 这两个参数控制容器能使用的 CPU 核数的。前者表示 CPU 的周期数,默认是 100000,单位是微秒,也就是 1s,一般不需要修改;后者表示容器的在上述 CPU 周期里能使用的 quota,真正能使用的 CPU 核数就是 cpu-quota / cpu-period,因此对于 3 核的容器,对应的 cpu-quota 值为 300000。

2. 内存资源

默认情况下,Docker 并没有对容器内存进行限制,也就是说容器可以使用主机提供的所有内存。这当然是非常危险的事情,如果某个容器运行了恶意的内存消耗软件,或者代码有内存泄露,很可能会导致主机内存耗尽,因此导致服务不可用。对于这种情况,Docker 会设置 docker daemon 的 OOM(out of memory) 值,使其在内存不足的时候被杀死的优先级降低。另外,就是你可以为每个容器设置内存使用的上限,一旦超过这个上限,容器会被杀死,而不是耗尽主机的内存。

限制内存上限虽然能保护主机,但是也可能会伤害到容器里的服务。如果为服务设置的内存上限太小,会导致服务还在正常工作的时候就被 OOM 杀死;如果设置的过大,会因为调度器算法浪费内存。因此,合理的做法包括:

为应用做内存压力测试,理解正常业务需求下使用的内存情况,然后才能进入生产环境使用。

一定要限制容器的内存使用上限

尽量保证主机的资源充足,一旦通过监控发现资源不足,就进行扩容或者对容器进行迁移。

如果可以(内存资源充足的情况),尽量不要使用 swap,swap 的使用会导致内存计算复杂,对调度器非常不友好。

Docker 限制容器内存使用量

在 Docker 启动参数中,和内存限制有关的包括(参数的值一般是内存大小,也就是一个正数,后面跟着内存单位 b、k、m、g,分别对应 bytes、KB、MB、和 GB):

-m --memory:容器能使用的最大内存大小,最小值为 4m。

--memory-swap:容器能够使用的 swap 大小。

--memory-swappiness:默认情况下,主机可以把容器使用的匿名页(anonymous page)swap 出来,你可以设置一个 0-100 之间的值,代表允许 swap 出来的比例。

--memory-reservation:设置一个内存使用的 soft limit,如果 docker 发现主机内存不足,会执行 OOM 操作。这个值必须小于 --memory 设置的值。

--kernel-memory:容器能够使用的 kernel memory 大小,最小值为 4m。

--oom-kill-disable:是否运行 OOM 的时候杀死容器。只有设置了 -m,才可以把这个选项设置为 false,否则容器会耗尽主机内存,而且导致主机应用被杀死

关于 --memory-swap 的设置必须解释一下,--memory-swap 必须在 --memory 也配置的情况下才能有用。

如果 --memory-swap 的值大于 --memory,那么容器能使用的总内存(内存 + swap)为 --memory-swap 的值,能使用的 swap 值为 --memory-swap 减去 --memory 的值。

如果 --memory-swap 为 0,或者和 --memory 的值相同,那么容器能使用两倍于内存的 swap 大小,如果 --memory 对应的值是 200M,那么容器可以使用 400M swap。

如果 --memory-swap 的值为 -1,那么不限制 swap 的使用,也就是说主机有多少 swap,容器都可以使用。

如果限制容器的内存使用为 64M,在申请 64M 资源的情况下,容器运行正常(如果主机上内存非常紧张,并不一定能保证这一点):

➜ docker run --rm -it -m 64m stress --vm 1--vm-bytes 64M --vm-hang 0WARNING: Your kernel does not support swap limit capabilities or the cgroup is not mounted. Memory limited without swap.stress: info: [1] dispatching hogs: 0cpu, 0io, 1vm, 0hddstress: dbug: [1] usingbackoff sleep of 3000usstress: dbug: [1] --> hogvm worker 1[7] forkedstress: dbug: [7] allocating 67108864bytes ...stress: dbug: [7] touching bytes in strides of 4096bytes ...stress: dbug: [7] sleeping forever with allocated memory.....

而如果申请 100M 内存,会发现容器里的进程被 kill 掉了(worker 7 got signal 9,signal 9 就是 kill 信号)

➜ docker run --rm -it -m 64m stress --vm 1--vm-bytes 100M --vm-hang 0WARNING: Your kernel does not support swap limit capabilities or the cgroup is not mounted. Memory limited without swap.stress: info: [ 1] dispatching hogs: 0cpu, 0io, 1vm, 0hddstress: dbug: [ 1] usingbackoff sleep of 3000usstress: dbug: [ 1] --> hogvm worker 1[ 7] forkedstress: dbug: [ 7] allocating 104857600bytes ...stress: dbug: [ 7] touching bytes in strides of 4096bytes ...stress: FAIL: [ 1] ( 415) <-- worker 7got signal 9stress: WARN: [ 1] ( 417) now reaping child worker processesstress: FAIL: [ 1] ( 421) kill error: No such processstress: FAIL: [ 1] ( 451) failed run completed in 0s

关于 swap 和 Kernel memory 的限制就不在这里过多解释了,感兴趣的可以查看官方的文档。

内存信息的 cgroups 文件

对于 Docker 来说,它的内存限制也是存放在 cgroups 文件系统的。对于某个容器,你可以在 sys/fs/cgroup/memory/docker/《container_id》 目录下看到容器内存相关的文件:

➜ ls /sys/fs/cgroup/memory/docker/b067fa0c58dcdd4fa856177fac0112655b605fcc9a0fe07e36950f0086f62f46 cgroup.clone_children memory.kmem.failcnt memory.kmem.tcp.limit_ in_bytes memory.max_usage_ in_bytes memory.soft_ limit_ in_bytes notify_on_releasecgroup.event_control memory.kmem.limit_ in_bytes memory.kmem.tcp.max_usage_ in_bytes memory.move_charge_at_immigrate memory.stat taskscgroup.procs memory.kmem.max_usage_ in_bytes memory.kmem.tcp.usage_ in_bytes memory.numa_ statmemory.swappinessmemory.failcnt memory.kmem.slabinfo memory.kmem.usage_ in_bytes memory.oom_control memory.usage_ in_bytesmemory.force_empty memory.kmem.tcp.failcnt memory.limit_ in_bytes

而上面的内存限制对应的文件是 memory.limit_in_bytes:

➜ cat /sys/fs/cgroup/memory/docker/b067fa0c58dcdd4fa856177fac0112655b605fcc9a0fe07e36950f0086f62f46/memory.limit_ in_bytes 67108864memory.force_empty memory.kmem.tcp.failcnt memory.limit_ in_bytes

3. IO 资源(磁盘)

对于磁盘来说,考量的参数是容量和读写速度,因此对容器的磁盘限制也应该从这两个维度出发。目前Docker 支持对磁盘的读写速度进行限制,但是并没有方法能限制容器能使用的磁盘容量(一旦磁盘 mount 到容器里,容器就能够使用磁盘的所有容量)。

➜ ~ docker run -it --rm ubuntu: 16.04bashroot@ 5229f756523c:/ # time $(dd if=/dev/zero of=/tmp/test.data bs=10M count=100&& sync)100+ 0records in 100+ 0records out 1048576000bytes ( 1.0GB) copied, 3.82859s, 274MB/sreal 0m4 .124suser 0m0 .000ssys 0m1 .812smemory.force_empty memory.kmem.tcp.failcnt memory.limit_ in_bytes

限制磁盘的权重

通过 --blkio-weight 参数可以设置 block 的权重,这个权重和 --cpu-shares 类似,它是一个相对值,取值范围是 10-1000,当多个 block 去屑磁盘的时候,其读写速度和权重成反比。

不过在我的环境中,--blkio-weight 参数虽然设置了对应的 cgroups 值,但是并没有作用,不同 weight 容器的读写速度还是一样的。github 上有一个对应的 issue,但是没有详细的解答。

--blkio-weight-device 可以设置某个设备的权重值,测试下来虽然两个容器同时读的速度不同,但是并没有按照对应的比例来限制。

限制磁盘的读写速率

除了权重之外,Docker 还允许你直接限制磁盘的读写速率,对应的参数有:

--device-read-bps:磁盘每秒最多可以读多少比特(bytes)

--device-write-bps:磁盘每秒最多可以写多少比特(bytes)

上面两个参数的值都是磁盘以及对应的速率,格式为 《device-path》:《limit》[unit],device-path 表示磁盘所在的位置,限制 limit 为正整数,单位可以是 kb、mb 和 gb。

比如可以把设备的度速率限制在 1mb:

➜ $ docker run -it --device /dev/sda:/dev/sda --device-read-bps /dev/sda: 1mb ubuntu: 16.04bashroot@ 6c048edef769:/ # cat /sys/fs/cgroup/blkio/blkio.throttle.read_bps_device 8: 01048576root@ 6c048edef769:/ # dd iflag=direct,nonblock if=/dev/sda of=/dev/null bs=5M count=1010+ 0records in 10+ 0records out 52428800bytes ( 52MB) copied, 50.0154s, 1.0MB/s

从磁盘中读取 50m 花费了 50s 左右,说明磁盘速率限制起了作用。

另外两个参数可以限制磁盘读写频率(每秒能执行多少次读写操作):

--device-read-iops:磁盘每秒最多可以执行多少 IO 读操作

--device-write-iops:磁盘每秒最多可以执行多少 IO 写操作

上面两个参数的值都是磁盘以及对应的 IO 上限,格式为 《device-path》:《limit》,limit 为正整数,表示磁盘 IO 上限数。

比如,我们可以让磁盘每秒最多读 100 次:

➜ ~ docker run -it --device /dev/sda:/dev/sda --device-read-iops /dev/sda: 100ubuntu: 16.04bashroot@ 2e3026e9ccd2:/ # dd iflag=direct,nonblock if=/dev/sda of=/dev/null bs=1k count=10001000+ 0records in 1000+ 0records out 1024000bytes ( 1.0MB) copied, 9.9159s, 103kB/s

从测试中可以看出,容器设置了读操作的 iops 为 100,在容器内部从 block 中读取 1m 数据(每次 1k,一共要读 1000 次),共计耗时约 10s,换算起来就是 100 iops/s,符合预期结果。

写操作 bps 和 iops 与读类似,这里就不再重复了,感兴趣的可以自己实验。

磁盘信息的 cgroups 文件

容器中磁盘限制的 cgroups 文件位于 /sys/fs/cgroup/blkio/docker/《docker_id》 目录:

➜ ~ ls /sys/fs/cgroup/blkio/docker/ 1402c1682cba743b4d80f638da3d4272b2ebdb6dc6c2111acfe9c7f7aeb72917/ blkio.io_merged blkio.io_serviced blkio.leaf_weight blkio.throttle.io_serviced blkio.time_recursive tasksblkio.io_merged_recursive blkio.io_serviced_recursive blkio.leaf_weight_device blkio.throttle.read_bps_device blkio.weightblkio.io_queued blkio.io_service_time blkio.reset_stats blkio.throttle.read_iops_device blkio.weight_deviceblkio.io_queued_recursive blkio.io_service_time_recursive blkio.sectors blkio.throttle.write_bps_device cgroup.clone_childrenblkio.io_service_bytes blkio.io_ wait_time blkio.sectors_recursive blkio.throttle.write_iops_device cgroup.procsblkio.io_service_bytes_recursive blkio.io_ wait_time_recursive blkio.throttle.io_service_bytes blkio.time notify_on_release

其中 blkio.throttle.read_iops_device 对应了设备的读 IOPS,前面一列是设备的编号,可以通过 cat /proc/partitions 查看设备和分区的设备号;后面是 IOPS 上限值:

➜ ~ cat /sys/fs/cgroup/blkio/docker/ 1402c1682cba743b4d80f638da3d4272b2ebdb6dc6c2111acfe9c7f7aeb72917/blkio.throttle.read_iops_device 8: 0100

blkio.throttle.read_bps_device 对应了设备的读速率,格式和 IOPS 类似,只是第二列的值为 bps:

➜ ~ cat /sys/fs/cgroup/blkio/docker/ 9de94493f1ab4437d9c2c42fab818f12c7e82dddc576f356c555a2db7bc61e21/blkio.throttle.read_bps_device 8: 01048576

总结

从上面的实验可以看出来,CPU 和内存的资源限制已经是比较成熟和易用,能够满足大部分用户的需求。磁盘限制也是不错的,虽然现在无法动态地限制容量,但是限制磁盘读写速度也能应对很多场景。

至于网络,Docker 现在并没有给出网络限制的方案,也不会在可见的未来做这件事情,因为目前网络是通过插件来实现的,和容器本身的功能相对独立,不是很容易实现,扩展性也很差。docker 社区已经有很多呼声,也有 issue 是关于网络流量限制的: issue 26767、issue 37、issue 4763。

资源限制一方面可以让我们为容器(应用)设置合理的 CPU、内存等资源,方便管理;另外一方面也能有效地预防恶意的攻击和异常,对容器来说是非常重要的功能。如果你需要在生产环境使用容器,请务必要花时间去做这件事情。

参考资料

Docker docs: Limit a container’s resources

Resource management in Docker

Docker资源管理探秘:Docker背后的内核Cgroups机制

本文作者:Cizixs

Docker Compose 里的 PUID 和 PGID 到底是什么?一篇文章彻底搞懂!(docker-compose.yml如何设置权限) 阅读详情

相关推荐

新手必看:CiscoPacket Tracer从零搭建局域网(含ARP协议详解)

本文为网络新手提供了一份使用Cisco Packet Tracer从零搭建局域网的详细指南。通过构建基础网络拓扑、配置IP地址,并深入剖析ARP协议的工作原理,帮助读者理解IP地址与MAC地址的映射关系,掌握局域网通信的核心机制。

weixin_29275257的博客 205

Range of CPUs is from 0.01 to 1.00, as there are only 1 CPUs available

在使用Docker运行容器时,一台主机上可能会运行几百个容器,这些容器虽然互相隔离,但是底层却使用着相同的cpu、内存和磁盘资源。 为了限制容器能使用的 CPU 核数,docker 提供了 --cpus 参数可以限定容器能使用的 CPU 核数。这个功能可以让我们更精确地设置容器 CPU 使用量,是一种更容易理解也因此更常用的手段。 --cpus 后面跟着一个浮点数,代表容器最多使用的核数,可以精...

深海微澜 1880

GEE开发之ERA5(气温、降水、压力、风速等)数据获取和分析

前言:ERA5主要提供DAILY和MONTHLY两大类别数据,其中主要包括气温、降水、压力、风速等。

等待着冬天的风的博客 3万+

docker搭建Minetest

Minetest 是一款开源的沙盒游戏,它允许玩家在一个由区块组成的3D世界中探索、建造和进行冒险。Minetest Docker 镜像是将 Minetest 游戏服务器封装在 Docker 容器中的版本,使得部署和管理 Minetest 服务器变得更加简便和灵活。

LogicLancer的博客 620

Kindle电子书DRM破解全攻略:从下载到转换的完整流程(含最新DeDRM插件配置)

本文详细介绍了如何合法移除个人购买的Kindle电子书的DRM保护,实现跨设备阅读与备份。核心内容包括使用最新DeDRM插件(如noDRM分支)配合Calibre进行配置,并针对亚马逊最新的KFX加密格式提供了密钥提取与实战操作指南。文章强调该方法仅适用于个人合理使用,旨在帮助读者真正掌控自己的数字资产。

delta的博客 578

淘宝扫码登录避坑指南:如何避免异地登录风控并稳定获取Cookie(附Python代码)

本文深入解析了淘宝扫码登录的风控机制,提供了从环境仿真到代码实现的完整避坑指南。通过精细化伪装请求头、管理会话与IP策略,并附上Python示例代码,帮助开发者稳定获取Cookie,有效避免异地登录风控,实现自动化流程的可靠集成。

l6m7n8的博客 595

第3天-Docker容器进阶

第3天 Docker容器进阶 一、Docker私有仓库 1、仓库镜像 Docker hub官方已提供容器镜像registry,用于搭建私有仓库 拉取镜像 [root@qfedu.com ~]# docker pull daocloud.io/library/registry:latest 2、运行容器 [root@qfedu.com ~]# docker run --name "pri_registry" --restart=always -d -p 5000:5000 daocloud.io/libra

qq_43812373的博客 241

深度学习优化算法解析(Momentum, RMSProp, Adam)

之前看了很多人介绍网络的优化器optimizer,无奈很多都把简单的东西讲的复杂化了,不容易让人懂,恰好之前看过吴恩达老师的最新的课程,这里结合老师讲的和个人想法写一下,方便别人同时也为自己以后回顾吧。 深度学习的优化算法主要有GD,SGD,Momentum,RMSProp和Adam算法吧,还有诸如Adagrad算法,不过大同小异,理解了前面几个,后面的也就引刃而解了。GD算法,SGD算法以及m

willduan的博客 12万+

docker(十五)资源限制

文章目录docker资源限制OOM 优先级机制:容器的内存限制:内存限制参数:swap 限制:内存限制验证:内存大小硬限制内存大小软限制:关闭 OOM 机制交换分区限制容器的 CPU 限制参数:测试 CPU 限制 docker资源限制 官网:https://docs.docker.com/config/containers/resource_constraints/ 默认情况下, 容器没有资源...

Not Found 404 1279

YOLO11改进大全:卷积层、轻量化、注意力机制、损失函数、Backbone、SPPF、Neck、检测头全方位优化汇总

YOLOv11改进大全:卷积层、轻量化、注意力机制、损失函数、Backbone、SPPF、Neck、检测头全方位优化汇总

魔改工程师的博客 4550

windows在使用ping 127.0.0.1时出现一般故障的解决方案

本文主要介绍了windows在使用ping 127.0.0.1时出现一般故障的解决方案,希望能对使用windows的同学们有所帮助。 文章目录 1. 问题描述 2. 解决方案

weixin_43178406的博客 7万+

如何使用 Docker 来限制 CPU、内存和 IO等资源?

如何使用 Docker 来限制 CPU、内存和 IO等资源?http://www.sohu.com/a/165506573_609513 转载于:https://www.cnblogs.com/rgqancy/p/10478681.html

weixin_30348519的博客 305

FFTW3库在Windows中的安装和使用

Windows 32位平台下载:FFTW Installation on Windows。

weixin_45397344的博客 952

docker资源限制与compose

docker资源限制与compose

Drw_Dcm的博客 8612

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

Docker的Cgroup资源限制

因此,无法单纯根据某个容器的 CPU 份额来确定有多少 CPU 资源分配给它,资源分配结果取决于同时运行的其他容器的 CPU 分配和容器中进程运行情况。所以 -m 300m --memory-swap=1g 的含义为:容器可以使用 300M 的物理内存,并且可以使用 700M(1G - 300)的 swap。使用 --cpu-period 即可设置调度周期,使用 --cpu-quota 即可设置在每个周期内容器能使用的CPU时间。设置 -1,表示不限制swap的值,宿主机有多少容器即可使用多少。

weixin_72625764的博客 1323

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

docker的资源控制(网络、CPU、内存、IO)

文章目录一、前言二、docker网络资源控制2.1、docker网络详解2.1.1、host模式2.1.2、Container模式2.1.3、none模式2.1.4、Bridge 模式2.2、网络空间2.3、docker网络管理命令三、docker的CPU、内存、IO资源控制3.1、CPU使用率控制3.2、内存使用限制3.2、磁盘I/O读写的优化 一、前言 一台主机可以放多个容器,默认的情况下,...

qq_28361541的博客 2754

Docker资源控制

文章目录一、网络资源控制1、查看docker网络信息2、配置docker网络① bridge自动给分配② 自定义网络(手动指定固定IP)二、CPU资源控制1、CPU使用率上限控制2、多任务按比例分享CPU3、限制容器使用指定的CPU内核三、内存资源控制1、创建容器并限制内存使用2、验证四、IO资源控制blkio限制示例 一、网络资源控制 firewalld防火墙中自带nat地址转换功能,所以不要关...

ML908的博客 503

docker的资源控制

资源控制和限制

小小byg 1204

[docker] Docker资源管理

设置单个容器进程能够使用的CPU使用率上限针对新建的容器:docker run --cpu-period 单个CPU调度周期时间(1000~1000000) --cpu-quota 容器进程能够使用的最大CPU时间(>=1000)针对已存在的容器:修改 /sys/fs/cgroup/cpu/docker/容器ID/ 目录下的 cpu.cfs_period_us(单个CPU调度周期时间) cpu.cfs_quota_us(容器进程能够使用的最大CPU时间) 文件的值。

热心网友 1547

Docker容器 ---- 资源控制篇

文章目录前言:一、Docker CPU控制1.1 Cpu资源资源查询目录1.2 cpu使用率限制1.3 设置容器的权重1.4 指定容器使用的CPU二、docker MEM内存使用限制三、docker IO限制总结 前言: cgroup是control group的简写,是Linux内核提供的一种限制所使用物理资源的机制,这些资源主要包括CPU、内存、blkio。Docker就是采用cgroup来控...

weixin_45726050的博客 661

强力的应用容器引擎---------Docker的资源控制

如果 --memory-swap 值为 -1,它表示容器程序使用的内存受限,而可以使用的 swap 空间使用不受限制(宿主机有多少 swap 容器就可以使用多少)所以 -m 300m --memory-swap=1g 的含义为:容器可以使用 300M 的物理内存,并且可以使用 700M(1G - 300)的 swap。使用 --cpu-period 即可设置调度周期,使用 --cpu-quota 即可设置在每个周期内容器能使用的CPU时间。-m(--memory=) 选项用于限制容器可以使用的最大内存。

zzzxxx520369的博客 1348

Docker的资源控制管理——Cgroups

cgroup是一个非常强大的linux内核工具,它不仅可以限制被namespace隔离起来的资源,还可以为资源设置权重,计算使用量,操控进程启停等等。所以cgroup实现了对资源的配额和度量。

rmh0713的博客 1542

cgroup 资源控制介绍

cgroups,是一个非常强大的linux内核工具,他不仅可以限制被 namespace 隔离起来的资源, 还可以为资源设置权重、计算使用量、操控进程启停等等。所以 cgroups(Control groups)实现了对资源的配额和度量。Cgroup(Control Groups)是一个Linux内核的特性,通过内核来限制记录和隔离进程组的系统资源使用(CPU/内存/磁盘I/O等)

wyq2070857323的博客 1911

Docker设置容器CPU、memory、磁盘IO资源限制

Docker设置容器CPU、memory、磁盘IO资源限制

cbmljs的博客 5611

【docker系列】最通俗易懂的详解Docker容器设置cpu,memory等资源限制

背景 在使用 docker 运行容器时,默认的情况下,docker没有对容器进行硬件资源的限制,当一台主机上运行几百个容器,这些容器虽然互相隔离,但是底层却使用着相同的 CPU、内存和磁盘资源。如果不对容器使用的资源进行限制,那么容器之间会互相影响,小的来说会导致容器资源使用不公平;大的来说,可能会导致主机和集群资源耗尽,服务完全不可用。 docker 作为容器的管理者,自然提供了控制容器资源...

seowen的开发 小本子 2298

Docker资源(CPU/内存/磁盘IO/GPU)限制与分配指南

cgroups其名称源自控制组群(control groups)的简写,是Linux内核的一个功能,用来限制、控制与分离一个进程组(如CPU、内存、磁盘输入输出等)。默认情况下,Docker容器是没有资源限制的,它会尽可能地使用宿主机能够分配给它的资源。如果不对容器资源进行限制,容器之间就会相互影响,一些占用硬件资源较高的容器会吞噬掉所有的硬件资源,从而导致其它容器无硬件资源可用,发生停服状态。

天涯的浪子 4027
上一篇: Kafka压力测试(写入MQ消息压测和消费MQ消息压测)
下一篇: PostgreSQL配置优化
王树民
博客等级 码龄10年 912粉丝 560原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值