Docker#Docker容器进阶操作

最新推荐文章于 2022-08-30 12:06:34 发布
最新推荐文章于 2022-08-30 12:06:34 发布
阅读量337 收藏
点赞数 2
分类专栏： DockerDockerComposs+Kubernetes
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kakaops_qing/article/details/109144511
版权

容器进阶

一：Docker资源限制

1.系统压力测试工具

stress
是一个linux下的压力测试工具，专门为那些想要测试自己的系统，完全高负荷和监督这些设备运行的用户。
安装

[root@xingdian ~]# yum install stress -y

测试场景举例

测试CPU负荷
[root@xingdian ~]# stress –c 4
增加4个cpu进程，处理sqrt()函数函数，以提高系统CPU负荷
内存测试
[root@xingdian ~]# stress –i 4 --vm 10 --vm-bytes 1G --vm-hang 100 --timeout 100s
新增4个io进程，10个内存分配进程，每次分配大小1G，分配后不释放，测试100S
磁盘I/O测试
# stress –d 1 --hdd-bytes 3G
新增1个写进程，每次写3G文件块
硬盘测试（不删除）
# stress -i 1 -d 10 --hdd-bytes 3G –hdd-noclean
新增1个IO进程，10个写进程，每次写入3G文件块，且不清除，会逐步将硬盘耗尽。

stress各主用参数说明（-表示后接一个中划线，–表示后接2个中划线，均可用于stress后接参数，不同表达方式）：

--help 显示帮助信息
--version 显示软件版本信息
-t secs:
--timeout secs指定运行多少秒
-c forks:
--cpu forks 产生多个处理sqrt()函数的CPU进程
-m forks
--vm forks:产生多个处理malloc()内存分配函数的进程，后接进程数量
-i forks
--io forks:产生多个处理sync()函数的磁盘I/O进程
--vm-bytes bytes：指定内存的byte数，默认值是1
--vm-hang:表示malloc分配的内存多少时间后在free()释放掉
-d :
--hdd:写进程，写入固定大小，通过mkstemp()函数写入当前目录
--hdd-bytes bytes:指定写的byte数，默认1G
--hdd-noclean:不要将写入随机ascii数据的文件unlink，则写入的文件不删除，会保留在硬盘空间。

2.限制CPU share
·CPU 资源
主机上的进程会通过时间分片机制使用 CPU，CPU 的量化单位是频率，也就是每秒钟能执行的运算次数。为容器限制 CPU 资源并不能改变 CPU 的运行频率，而是改变每个容器能使用的 CPU 时间片。理想状态下，CPU 应该一直处于运算状态（并且进程需要的计算量不会超过 CPU 的处理能力）。
docker 限制 CPU Share
什么是cpu share:
docker 允许用户为每个容器设置一个数字，代表容器的 CPU share，默认情况下每个容器的 share 是 1024。这个 share 是相对的，本身并不能代表任何确定的意义。当主机上有多个容器运行时，每个容器占用的 CPU 时间比例为它的 share 在总额中的比例。docker 会根据主机上运行的容器和进程动态调整每个容器使用 CPU 的时间比例。
例子：
如果主机上有两个一直使用 CPU 的容器（为了简化理解，不考虑主机上其他进程），其 CPU share 都是 1024，那么两个容器 CPU 使用率都是 50%；如果把其中一个容器的 share 设置为 512，那么两者 CPU 的使用率分别为 67% 和 33%；如果删除 share 为 1024 的容器，剩下来容器的 CPU 使用率将会是 100%。
好处：
能保证 CPU 尽可能处于运行状态，充分利用 CPU 资源，而且保证所有容器的相对公平；
缺点：
无法指定容器使用 CPU 的确定值。
设置 CPU share 的参数：
-c --cpu-shares，它的值是一个整数。
我的机器是 4 核 CPU，因此运行一个stress容器,使用 stress 启动 4 个进程来产生计算压力：

# docker pull progrium/stress
# yum install htop -y
# docker run --rm -it progrium/stress --cpu 4 
stress: info: [1] dispatching hogs: 4 cpu, 0 io, 0 vm, 0 hdd
stress: dbug: [1] using backoff sleep of 12000us
stress: dbug: [1] --> hogcpu worker 4 [7] forked
stress: dbug: [1] using backoff sleep of 9000us
stress: dbug: [1] --> hogcpu worker 3 [8] forked
stress: dbug: [1] using backoff sleep of 6000us
stress: dbug: [1] --> hogcpu worker 2 [9] forked
stress: dbug: [1] using backoff sleep of 3000us
stress: dbug: [1] --> hogcpu worker 1 [10] forked

在另外一个 terminal 使用 htop 查看资源的使用情况：
在这里插入图片描述

上图中看到，CPU 四个核资源都达到了 100%。四个 stress 进程 CPU 使用率没有达到 100% 是因为系统中还有其他机器在运行。
为了比较，另外启动一个 share 为 512 的容器：

# docker run --rm -it -c 512 progrium/stress --cpu 4 
stress: info: [1] dispatching hogs: 4 cpu, 0 io, 0 vm, 0 hdd
stress: dbug: [1] using backoff sleep of 12000us
stress: dbug: [1] --> hogcpu worker 4 [6] forked
stress: dbug: [1] using backoff sleep of 9000us
stress: dbug: [1] --> hogcpu worker 3 [7] forked
stress: dbug: [1] using backoff sleep of 6000us
stress: dbug: [1] --> hogcpu worker 2 [8] forked
stress: dbug: [1] using backoff sleep of 3000us
stress: dbug: [1] --> hogcpu worker 1 [9] forked

因为默认情况下，容器的 CPU share 为 1024，所以这两个容器的 CPU 使用率应该大致为 2：1，下面是启动第二个容器之后的监控截图：
在这里插入图片描述

两个容器分别启动了四个 stress 进程，第一个容器 stress 进程 CPU 使用率都在 54% 左右，第二个容器 stress 进程 CPU 使用率在 25% 左右，比例关系大致为 2：1，符合之前的预期。
3.限制容器能使用的 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.5 progrium/stress --cpu 3 
stress: info: [1] dispatching hogs: 3 cpu, 0 io, 0 vm, 0 hdd
stress: dbug: [1] using backoff sleep of 9000us
stress: dbug: [1] --> hogcpu worker 3 [7] forked
stress: dbug: [1] using backoff sleep of 6000us
stress: dbug: [1] --> hogcpu worker 2 [8] forked
stress: dbug: [1] using backoff sleep of 3000us
stress: 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 8 progrium/stress --cpu 3 
docker: Error response from daemon: Range of CPUs is from 0.01 to 4.00, as there are only 4 CPUs available.
See 'docker run --help'.

如果多个容器都设置了 --cpus ，并且它们之和超过主机的 CPU 核数，并不会导致容器失败或者退出，这些容器之间会竞争使用 CPU，具体分配的 CPU 数量取决于主机运行情况和容器的 CPU share 值。也就是说 --cpus 只能保证在 CPU 资源充足的情况下容器最多能使用的 CPU 数，docker 并不能保证在任何情况下容器都能使用这么多的 CPU（因为这根本是不可能的）。
4.内存资源
默认情况下，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 progrium/stress --vm 1 --vm-bytes 64M --vm-hang 0
WARNING: Your kernel does not support swap limit capabilities or the cgroup is not mounted. Memory limited without swap.
stress: info: [1] dispatching hogs: 0 cpu, 0 io, 1 vm, 0 hdd
stress: dbug: [1] using backoff sleep of 3000us
stress: dbug: [1] --> hogvm worker 1 [7] forked
stress: dbug: [7] allocating 67108864 bytes ...
stress: dbug: [7] touching bytes in strides of 4096 bytes ...
stress: dbug: [7] sleeping forever with allocated memory
.....

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

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

5.IO资源
对于磁盘来说，考量的参数是容量和读写速度，因此对容器的磁盘限制也应该从这两个维度出发。目前 docker 支持对磁盘的读写速度进行限制，但是并没有方法能限制容器能使用的磁盘容量（一旦磁盘 mount 到容器里，容器就能够使用磁盘的所有容量）。
限制磁盘的读写速率，docker 允许你直接限制磁盘的读写速率，对应的参数有：
–device-read-bps：磁盘每秒最多可以读多少比特（bytes）
–device-write-bps：磁盘每秒最多可以写多少比特（bytes）
上面两个参数的值都是磁盘以及对应的速率，限制 limit 为正整数，单位可以是 kb、mb 和 gb。
比如可以把设备的读速率限制在 1mb：

# docker run -it --device /dev/sda:/dev/sda --device-read-bps /dev/sda:1mb ubuntu:16.04 bash 

root@6c048edef769:/# cat /sys/fs/cgroup/blkio/blkio.throttle.read_bps_device 
8:0 1048576

root@6c048edef769:/# dd iflag=direct,nonblock if=/dev/sda of=/dev/null bs=5M count=10
10+0 records in
10+0 records out
52428800 bytes (52 MB) copied, 50.0154 s, 1.0 MB/s

从磁盘中读取 50m 花费了 50s 左右，说明磁盘速率限制起了作用。
另外两个参数可以限制磁盘读写频率（每秒能执行多少次读写操作）：
–device-read-iops：磁盘每秒最多可以执行多少 IO 读操作
–device-write-iops：磁盘每秒最多可以执行多少 IO 写操作
上面两个参数的值都是磁盘以及对应的 IO 上限。
比如，可以让磁盘每秒最多读 100 次：

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

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

二：容器端口转发

容器：172.16.0.2 5000
client----->eth0:10.18.45.197------->172.16.0.2:5000
5000
使用端口转发解决容器端口访问问题
-p:
创建应用容器的时候，一般会做端口映射，这样是为了让外部能够访问这些容器里的应用。可以用多个-p指定多个端口映射关系。
mysql应用端口转发：

查看本地地址：
[root@xingdian ~]# ip a
    ens33: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000
    link/ether 00:0c:29:0a:5b:8b brd ff:ff:ff:ff:ff:ff
    inet 192.168.245.134/24 brd 192.168.245.255 scope global dynamic ens33
       valid_lft 1444sec preferred_lft 1444sec

运行容器：使用-p作端口转发，把本地3307转发到容器的3306，其他参数需要查看发布容器的页面提示

[root@xingdian ~]# docker run --name mysql1 -p 3307:3306  -e MYSQL_ROOT_PASSWORD=123 daocloud.io/library/mysql

通过本地IP：192.168.245.134的3307端口访问容器mysql1内的数据库，出现如下提示恭喜你

[root@xingdian /]# mysql -u root -p123 -h 192.168.245.134 -P3307
Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MySQL connection id is 3
Server version: 5.7.18 MySQL Community Server (GPL)

Copyright (c) 2000, 2016, Oracle, MariaDB Corporation Ab and others.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

MySQL [(none)]>

三：部署私有仓库

仓库镜像，Docker hub官方已提供容器镜像registry,用于搭建私有仓库
拉取镜像：

[root@xingdian ~]# docker pull daocloud.io/library/registry:latest

运行容器：

[root@xingdian ~]# docker run --restart=always -d -p 5000:5000 daocloud.io/library/registry

注：如果创建容器不成功，报错防火墙，解决方案如下

[root@xingdian ~]# systemctl stop firewalld
[root@xingdian ~]# systemctl restart docker

查看运行的容器：

[root@xingdian ~]# docker ps
CONTAINER ID  IMAGE  COMMAND   CREATED  STATUS    PORTS    NAMES
1f444285bed8        daocloud.io/library/registry   "/entrypoint.sh /etc/"   23 seconds ago      Up 21 seconds       0.0.0.0:5000->5000/tcp   elegant_rosalind

连接容器查看端口状态：

[root@xingdian ~]# docker exec -it  1f444285bed8  /bin/sh      //这里是sh 不是bash
/ # netstat -antpl  //查看5000端口是否开启(容器内查看)
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name    
tcp        0      0 :::5000                 :::*                    LISTEN      1/registry
Active UNIX domain sockets (only servers)
Proto RefCnt Flags       Type       State         I-Node PID/Program name    Path

在本机查看能否访问该私有仓库, 看看状态码是不是200

[root@xingdian registry]# curl  -I  127.0.0.1:5000
HTTP/1.1 200 OK
Cache-Control: no-cache
Date: Thu, 08 Oct 2020 05:34:32 GMT

为了方便，下载1个比较小的镜像,buysbox

[root@xingdian registry]# docker pull busybox

上传前必须给镜像打tag 注明ip和端口：

[root@xingdian ~]# docker tag busybox  本机IP：端口/busybox

这是直接从官方拉的镜像，很慢：

[root@xingdian ~]# docker tag busybox 192.168.245.136:5000/busybox

下面这个Mysql是我测试的第二个镜像，从daocloud拉取的：

[root@xingdian ~]# docker tag daocloud.io/library/mysql 192.168.245.136:5000/daocloud.io/library/mysql

注：tag后面可以使用镜像名称也可以使用id,我这里使用的镜像名称，如果使用官方的镜像，不需要加前缀，但是daocloud.io的得加前缀
修改请求方式为http:

默认为https，不改会报以下错误:
Get https://master.up.com:5000/v1/_ping: http: server gave HTTP response to HTTPS client
[root@xingdian ~]# vim /etc/docker/daemon.json
    { "insecure-registries":["192.168.245.136:5000"] }
重启docker:
[root@xingdian ~]# systemctl restart docker

上传镜像到私有仓库：

[root@xingdian ~]# docker push 192.168.245.136:5000/busybox
[root@xingdian ~]# docker push 192.168.245.136:5000/daocloud.io/library/mysql

查看私有仓库里的所有镜像：

 [root@xingdian ~]# curl 192.168.245.130:5000/v2/_catalog
        {"repositories":["busybox"]

四：部署centos7容器应用

systemd 整合:
因为 systemd 要求 CAPSYSADMIN 权限，从而得到了读取到宿主机 cgroup 的能力，CentOS7 中已经用 fakesystemd 代替了 systemd 来解决依赖问题。 如果仍然希望使用 systemd，可用参考下面的 Dockerfile：

[root@xingdian ~]# vim Dockerfile
FROM daocloud.io/library/centos:7
MAINTAINER "xingdian"  xingdian@qq.com
ENV container docker
RUN yum -y swap -- remove fakesystemd -- install systemd systemd-libs
RUN yum -y update; yum clean all; \
(cd /lib/systemd/system/sysinit.target.wants/; for i in *; do [ $i == systemd-tmpfiles-setup.service ] || rm -f $i; done); \
rm -f /lib/systemd/system/multi-user.target.wants/*;\
rm -f /etc/systemd/system/*.wants/*;\
rm -f /lib/systemd/system/local-fs.target.wants/*; \
rm -f /lib/systemd/system/sockets.target.wants/*udev*; \
rm -f /lib/systemd/system/sockets.target.wants/*initctl*; \
rm -f /lib/systemd/system/basic.target.wants/*;\
rm -f /lib/systemd/system/anaconda.target.wants/*;
VOLUME [ "/sys/fs/cgroup" ]
CMD ["/usr/sbin/init"]

这个Dockerfile删除fakesystemd 并安装了 systemd。
然后再构建基础镜像:

[root@xingdian ~]# docker build --rm -t local/c7-systemd .

为了使用像上面那样包含 systemd 的容器，需要创建一个类似下面的Dockerfile：

[root@xingdian ~]# vim Dockerfile
FROM local/c7-systemd
RUN yum -y install httpd; yum clean all; systemctl enable httpd.service
EXPOSE 80
CMD ["/usr/sbin/init"]

构建镜像:

[root@xingdian ~]# docker build --rm -t local/c7-systemd-httpd .

运行包含 systemd 的应用容器:
为了运行一个包含 systemd 的容器，需要使用–privileged选项， 并且挂载主机的 cgroups 文件夹。 下面是运行包含 systemd 的 httpd 容器的示例命令：

[root@xingdian ~]# docker run --privileged -ti -v /sys/fs/cgroup:/sys/fs/cgroup:ro -p 80:80 local/c7-systemd-httpd

注意：上条命令不能添加/bin/bash，添加了会导致服务不可用，而且有些服务可能会发现之前提到的权限不够的问题，但是如果不加会运行在前台(没有用-d)，可以用ctrl+p+q放到后台去
测试可用：

# elinks --dump http://docker       //下面为apache默认页面
                Testing 123..
   This page is used to test the proper operation of the [1]Apache HTTP
   server after it has been installed. If you can read this page it means
   that this site is working properly. This server is powered by [2]CentOS.

四：固定容器IP
docker安装后，默认会创建三种网络类型，bridge、host和none
显示当前网络：

[root@xingdian ~]# docker network list
NETWORK ID          NAME                DRIVER              SCOPE
90b22f633d2f        bridge              bridge              local
e0b365da7fd2        host                host                local
da7b7a090837        none                null                local

bridge:网络桥接
默认情况下启动、创建容器都是用该模式，所以每次docker容器重启时会按照顺序获取对应ip地址，这就导致容器每次重启，ip都发生变化
none：无指定网络
启动容器时，可以通过network=none,docker容器不会分配局域网ip
host：主机网络
docker容器的网络会附属在主机上，两者是互通的。
创建固定ip容器
1、创建自定义网络类型，并且指定网段

[root@xingdian ~]# docker network create --subnet=192.168.0.0/16 staticnet

通过docker network ls可以查看到网络类型中多了一个staticnet
2、使用新的网络类型创建并启动容器

[root@xingdian ~]# docker run -it --name userserver --net staticnet --ip 192.168.0.2 centos:6 /bin/bash

通过docker inspect可以查看容器ip为192.168.0.2，关闭容器并重启，发现容器ip并未发生改变

kakaops
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Docker容器之Docker Compose
hxy090的博客
09-11 280
Docker容器之Docker ComposeDocker Compose概述新的改变 Docker Compose概述 Compose项目是Docker官方的开源项目，是一个用于定义和运行多个Docker容器应用的工具。负责实现对Docker容器集群的快速编排，其前身是开源项目Fig。它允许用户通过一个单独的docker-compose.yml模板文件来定义一组相关联的应用容器为一个项目。 Co...
Docker进阶-Docker Compose
qq_47815451的博客
08-12 138
Docker进阶-Docker Compose 官方文档：https://docs.docker.com/compose/ 简介 Docker DockerFile -> bulid（形成镜像）-> run Docker Compose 就可以轻松搞笑的来管理这些容器。以及定义和运行容器 官方介绍 定义运行多个容器 YAML file 配置文件 single command 简单命令 有哪些？ Compose is a tool for defining and running multi-co
Docker 8：Docker 资源（内存/CPU）限制实验
学渣角鹿白的博客
02-26 5988
八：Docker 资源限制 【参考】 - Runtime options with Memory, CPUs, and GPUs 官方文档：https://docs.docker.com/config/containers/resource_constraints/ By default, a container has no resource constraints and can use as much of a given resource as the host’s kernel schedule
使用 docker 对容器资源进行限制
探索世界，改变世界
09-30 8951
在使用 docker 运行容器时，一台主机上可能会运行几百个容器，这些容器虽然互相隔离，但是底层却使用着相同的 CPU、内存和磁盘资源。如果不对容器使用的资源进行限制，那么容器之间会互相影响，小的来说会导致容器资源使用不公平；大的来说，可能会导致主机和集群资源耗尽，服务完全不可用。 docker 作为容器的管理者，自然提供了控制容器资源的功能。正如使用内核的 namespace 来做容器之间的隔...
实时查看Docker容器占用的CPU，内存状态
liuzhang6966的博客
04-26 8061
ctop 就像 linux 的 top 命令一样，top 用来查看进程的实时状态，而 ctop 用来查看系统中各个容器的实时状态 可以看到当期系统中有哪些容器，通过前面的指示灯可以看出是否在运行状态，还有他们的 CPU、内存、网络、IO 这些重要指标 2. 安装 Linux下安装方法： wgethttps://github.com/bcicen/ctop/releases/download/v0...
查看docker应用CPU、内存占用情况
hjseo_seg的博客
08-30 6950
每1秒刷新一次，按C，可显示具体docker名字。1、查看每个docker的CPU、内存情况。2、查看某个docker的CPU、内存情况。
查看docker容器的基本信息
进击的豌豆的博客
12-28 4623
第一种：使用docker exec 命令 1、获取容器的hostname：docker exec 容器id或者容器name hostname 2、获取容器ip地址：docker exec 容器id或者容器name ip addr 3、获取容器环境变量：docker exec 容器id或者容器name env 第二种：使用docker inspect命令 docker inspect 容器id或者容器name ...
Docker 系统性入门+进阶实践视频教程.zip
07-13
目录网盘文件永久链接 第1章 Docker的安装和介绍 试看 第2章 容器快速上手 第3章 镜像的创建管理和发布 第4章 Dockerfile完全指南 第5章 Docker的存储 第6章 Docker的网络 ...第13章 课程内容回顾与进阶建议
Docker容器配置进阶
最新发布
04-27
Docker容器配置进阶
艾编程：Docker容器技术入门与进阶实战教程.pdf
01-03
Docker 容器是一个开源的应用容器引擎，让开发者可以以统一的方式打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何安装了docker引擎的服务器上（包括流行的Linux机器、windows机器），也可以实现虚拟...
从Docker到Kubernetes进阶课程
12-28
从Docker到Kubernetes进阶课程，对于零基础或者有docker基础，想对k8s更上一层楼的童鞋，无疑是必备书籍。
Docker基本管理 1
weixin_62466637的博客
03-08 1032
一、Docker 概述 1.1 Docke的简介 是一个开源的应用容器引擎，基于go语言并发并遵循了apache2.0协议开源 是在Linux容器里运行应用的开源工具●是一种轻量级的“虚拟机" Docker的容器技术可以在一台主机上轻松为任何应用创建一个轻量级的、可移植的、自给自足的容器。 Docker的Logo设计为蓝色鲸鱼，拖着许多集装箱。鲸鱼可看作为宿主机，集装箱可理解为相互隔离的容器，每个集装箱中都包含自己的应用程序（沙箱）。 Docker的设计宗旨：Build，ship and.
Docker(十九)-Docker监控容器资源的占用情况
weixin_30608131的博客
09-30 1037
启动一个容器并限制资源 启动一个centos容器，限制其内存为1G ，可用cpu数为2 [root@localhost ~]# docker run --name os1 -it -m 1g --cpus=2 centos:latest bash 启动容器后，可以使用docker 的监控指令查看容器的运行状态 docker top 容器名： 查看容器的进程，不加容器名即查看所...
top命令输出信息详解
weixin_43696020的博客
09-14 1491
介绍： top命令是Linux下常用的性能分析工具，能够实时显示系统中各个进程的资源占用状况，类似于Windows的任务管理器 可以直接使用top命令后，查看%MEM的内容。可以选择按进程查看或者按用户查看，如想查看oracle用户的进程内存使用情况的话可以使用如下的命令： $ top -u oracle 内容解释： PID：进程的ID USER：进程所有者 PR：进程的优先级别，越小越优先被执行 NInice：值 VIRT：进程占用的虚拟内存 RES：进程占用的物理内存 S
Docker下使用stress进行压力测试
weixin_34253126的博客
03-29 809
1、下载一个stress压力工具的镜像[root@docker~]#dockerpulljoedval/stress Pullingrepositoryjoedval/stress 7eb627cb08a2:Downloadcomplete b0082ba983ef:Downloadcomplete 109b72e23ca5:Downloadcom...
在容器里使用镜像stress进行压力测试——以及不能超内存的弥补方法
s2421458535的博客
06-14 2641
镜像名称：polinux/stress 压测指令： 压满一个cpu，执行10分钟： stress --cpu 1 --timeout 600 压满1G内存，执行10分钟： stress --vm 10 --vm-bytes 100m --vm-hang 100 --timeout 600s –vm-bytes 表示malloc分配多少内存 –vm-hang 表示malloc分配...
亲测小白系列之-stress docker cpu 内存 压测
yacsdnay的博客
01-30 1948
stress压测 #先安装一些基础工具 yum install wget gcc gcc-c++ make -y wget http://people.seas.harvard.edu/~apw/stress/stress-1.0.4.tar.gz tar zxf stress-1.0.4.tar.gz cd stress-1.0.4 ./configure make make install ...
第3天-Docker容器进阶
qq_43812373的博客
11-23 102
第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
Range of CPUs is from 0.01 to 1.00, as there are only 1 CPUs available
深海微澜
04-23 1395
在使用Docker运行容器时，一台主机上可能会运行几百个容器，这些容器虽然互相隔离，但是底层却使用着相同的cpu、内存和磁盘资源。 为了限制容器能使用的 CPU 核数，docker 提供了 --cpus 参数可以限定容器能使用的 CPU 核数。这个功能可以让我们更精确地设置容器 CPU 使用量，是一种更容易理解也因此更常用的手段。 --cpus 后面跟着一个浮点数，代表容器最多使用的核数，可以精...
第三章：Docker容器进阶--创建镜像、数据管理、网络、存储类型 (2)1
08-08
"本章节主要介绍了Docker容器的高级用法，包括如何创建镜像、管理数据、设置网络以及理解不同的存储类型。详细讲解了三种创建Docker镜像的方法：基于已有镜像、基于本地模板以及使用Dockerfile。此外，还提到了构建...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值