方舟环境容器调度

发表于 2017-03-24 更新于 2025-11-16 分类于 docker

方舟环境容器调度

主要功能

恢复宿主机死机或者断网后上面需要调度的所有容器
恢复非正常的容器状态到正常
调度的容器能够支持vlan网络和Host模式
调度容器本身通过Leader-Follower的模式保证高可用性
调度容器支持cron定时任务（精确到秒级）
查询哪个节点是Leader
停止或者打开调度（方便容器维护、正常启停）

通过 ark-schedule 镜像启动调度

必须在swarm manager节点上以 docker 容器的方式来启动，下面的 -e 参数对应后面的 export 参数和作用注释

docker run -d --restart=always --name=ark-schedule -e ACS_CLUSTER_SECURITY_GROUP=false -e ACS_CLUSTER_SCHEME=tcp -e ACS_CLUSTER_ENDPOINT=11.239.155.112:3376 -e ACS_NETWORK_NAME=vlan701 -e ACS_CRONTAB="7 * * * * *" -e ACS_PORT=3375 -e ACS_ADVERTISE=11.239.155.112:3375 -e ACS_NETWORK_STORE_CLUSTER=zk://11.239.155.112:2181,11.239.155.103:2181,11.239.155.97:2181/Cluster -e affinity:container==swarm-manager --net=host reg.docker.alibaba-inc.com/ark/ark-schedule:0.6-20180530-68e7bed /ark-schedule/ark-schedule --debug start

如果需要调度容器本身高可以用，需要在不同的宿主机上启动多个 ark-schedule 容器，同时可以给调度容器自己增加调度标签

环境变量参数说明

export ACS_CLUSTER_ENDPOINT=10.125.14.238:3376; //跟自己在同一台宿主机的swarm-manager
export ACS_NETWORK_NAME=vlan192;  //方舟网络名称 docker network ls 看到vlan开头的名字
export ACS_NETWORK_STORE_CLUSTER=zk://10.125.26.108:2181,10.125.14.238:2181,10.125.1.45:2181/Cluster; //方舟zk集群，同部署的ark.properties中的
export ACS_CRONTAB="*/7 * * * * *" 
export ACS_PORT="3375" //schedule 自身api暴露端口
export ACS_ADVERTISE="10.125.14.238:3375" //宿主机ip+自身api暴露端口 多个schedule容器唯一
./ark-schedule --debug start

ark-schedule 容器默认占用3375端口，如果要用别的端口需要通过 -e ACS_PORT 参数传入

-e ACS_CRONTAB="7 * * * * *" （秒分时天月星期）

这个参数如果没有，那么需要外部来触发调度API（见下面）

ACS_ADVERTISE=”10.125.26.108:3375” 这个参数是多容器选举用的，每个容器用自己的IP+PORT来标识

容器日志主要在 /root/logs/ark-schedule-container-2017-12-12.log 中，可以映射到宿主机上，查看更方便

镜像版本

0.1 带cron功能，自动定时扫描并恢复容器
0.2-election 有多个ark-schedule节点选举功能，抢到主的开始cron，没有抢到或者失去主的stop cron
0.3-election 在0.2的基础上修复了docker/libkv的bug，能够在弱网络、断网的条件下正常运行
0.4-switch 增加查询leader节点和cron是否开始的API，增加对Leader的cron启停的API
0.5-labels 增加对restart/recreate 标签的支持
0.6 去掉了对多个zk的支持，简化启动参数
0.7 修复了重复endpoint导致的容器的域名不通、inspect notfound（集群多个同名容器的时候）等各种问题

所有需要调度的容器增加调度标志标签

在docker run中增加一个标签： –label “ark.labels.schedule=haproxy”

详细命令：

1	sudo docker update --label-add="ark.labels.schedule=haproxy" --label-add="ark.enable_restart=true" --label-add="ark.enable_recreate=true" 容器名1 容器名2

上述命令不需要重启容器，但是要重新调snapshot API 做一次快照，让他们生效

ark-schedule容器在调度容器的时候，先检查快照中的容器，如果容器不见了或者状态不是up，又包含如上标签，就会重新在其它机器上把这个容器拉起来

ark.enable_restart
是否允许通过重启来恢复容器（默认是true）。true为可以，false不可以
ark.enable_recreate
是否允许将消失的容器在其他宿主机重建（默认是true）。true为可以，false不可以

API （如下ip：10.125.14.238 在现场换成客户物理机IP）

中间件部署完毕，并检查无误，调用： curl -v “http://10.125.14.238:3375/schedule/snapshot“ 对中间件做快照，将来会按快照的状态来进行恢复，执行一次就可以
手动恢复容器不见了，调用 curl -v “http://10.125.14.238:3375/schedule/snapshot/restore“ 会将所有异常容器恢复回来
schedule 容器本身的健康检查接口 curl http://10.125.14.238:3375/schedule/leader http code 值是 200,说明schedule容器是健康的
查询哪个节点是Leader curl 以及是否是停止调度（维护时）： “http://10.125.14.238:3375/schedule/leader“
停止调度，先查询谁是leader，然后调： “http://leader-ip:3375/schedule/stop“

维护状态

通过调度容器API停止调度，所有容器都不再被调度了，维护完毕再调snapshot、start API恢复调度。

如果只想对某个容器进行维护，其它容器还是希望被调度监控、调度可以通过下面的方式来实现：

docker update --label-rm="ark.labels.schedule=haproxy" 容器1 容器2 //还可以跟多个容器名
然后调 snapshot API让刚刚的update生效

运维完毕，恢复运维后的容器进入可以调度状态，具体命令如下：

docker update --label-add="ark.labels.schedule=haproxy" 容器1 容器2 //还可以跟多个容器名

然后调 snapshot API让刚刚的update生效

升级ark-schedule步骤：

下载并导入新镜像

下载镜像：http://fzpackages.oss-cn-shanghai.aliyuncs.com/ark%2Fpatch%2Fark-schedule-0.6-20180530-68e7bed.tgz
sudo docker load -i ark-schedule-0.6-20180530-68e7bed.tgz

停止原来的ark-schedule

停止两个crontab(新的ark-schedule自带crontab，每分钟执行一次调度)

停止两个ark-schedule容器

启动新的ark-schdule

在停止的两个ark-schedule的两台机器上启动两个新的ark-schedule容器，启动参数需要修改参考前面的描述(用现场环境信息替换下面的信息)

export ACS_CLUSTER_ENDPOINT=10.125.14.238:3376; //跟自己在同一台宿主机的swarm-manager
export ACS_NETWORK_NAME=vlan192;  //方舟网络名称 docker network ls 看到vlan开头的名字
export ACS_NETWORK_STORE_CLUSTER=zk://10.125.26.108:2181,10.125.14.238:2181,10.125.1.45:2181/Cluster; //方舟zk集群，同部署的ark.properties中的
export ACS_CRONTAB="*/7 * * * * *"  ----不需要改
export ACS_PORT="3375" //schedule 自身api暴露端口----不需要改
export ACS_ADVERTISE="10.125.14.238:3375" //宿主机ip+自身api暴露端口 多个schedule容器唯一
./ark-schedule --debug start //----不需要改

检查调度日志

检查两个ark-schedule 谁是主： curl http://ark-schedule所在的宿主机-ip:3375/schedule/leader

进到是主的ark-schedule容器中看日志：cat /root/logs/ark-schedule-2018-日期.log

参考资料

如何打标签 http://panama.alibaba-inc.com/qa/faq?id=1124

物理机磁盘空间都去哪里了

发表于 2017-03-24 更新于 2025-11-16 分类于 Linux

磁盘爆掉的几种情况

系统磁盘没有空间，解决办法：删掉 /var/log/ 下边的带日期的日志，清空 /var/log/messages 内容
容器使用的大磁盘空间不够，又有三个地方会使用大量的磁盘
- 容器内部日志非常大，处理办法见方法一
- 容器内部产生非常多或者非常大的文件，但是这个文件的位置又通过volume 挂载到了物理机上，处理办法见方法二
- 对特别老的部署环境，还有可能是容器的系统日志没有限制大小，处理办法见方法三

现场的同学按如下方法依次检查

方法零：检查系统根目录下每个文件夹的大小

sudo du / -lh --max-depth=1 --exclude=overlay --exclude=proc

看看除了容器之外有没有其它目录使用磁盘特别大，如果有那么一层层进去通过du命令来查看，比如：

#sudo du / -lh --max-depth=1 --exclude=overlay --exclude=proc
16K	/dev
16K	/lost+found
4.0K	/media
17G	/home
136M	/boot
832K	/run
1.9G	/usr
75M	/tmp
12K	/log
8.5G	/var
4.0K	/srv
0	/proc
22M	/etc
84G	/root
4.0K	/mnt
508M	/opt
0	/sys
112G	/

那么这个案例中应该查看 /root下为什么用掉了84G（总共用了112G），先 cd /root 然后执行： sudo du . -lh –max-depth=1 –exclude=overlay 进一步查看 /root 目录下每个文件夹的大小

如果方法零没找到占用特别大的磁盘文件，那么一般来说是容器日志占用太多的磁盘空间，请看方法一

方法一：容器内部日志非常大（请确保先按方法零检查过了）

在磁盘不够的物理机上执行如下脚本：

sudo docker ps -a -q >containers.list

sudo cat containers.list | xargs sudo docker inspect $1 | grep merged | awk -F \" '{ print $4 }' | sed 's/\/merged//g' | xargs sudo du  --max-depth=0 $1 >containers.size 

sudo paste containers.list containers.size | awk '{ print $1, $2 }'  | sort -nk2 >real_size.log

sudo tail -10 real_size.log  | awk 'BEGIN {print "\tcontainer     size\tunit"} { print NR":\t" $0"\t kB" }'

执行完后会输出如下格式：

   	container     size	unit
1:	22690f16822f 3769980	 kb
2:	82b4ae98eeed 4869324	 kb
3:	572a1b7c8ef6 10370404	 kb
4:	9f9250d98df6 10566776	 kb
5:	7fab70481929 13745648	 kb
6:	4a14b58e3732 29873504	 kb
7:	8a01418b6df2 30432068	 kb
8:	83dc85caaa5c 31010960	 kb
9:	433e51df88b1 35647052	 kb
10:	4b42818a8148 61962416	 kb

第二列是容器id，第三列是磁盘大小，第四列是单位，占用最大的排在最后面

然后进到容器后通过 du / –max-depth=2 快速发现大文件

方法二：容器使用的volume使用过大

$sudo du -l /data/lib/docker/defaultVolumes --max-depth=1 | sort -rn
456012884	/data/lib/docker/defaultVolumes
42608332	/data/lib/docker/defaultVolumes/task_3477_g0_ark-metadb_miniDBPaaS-MetaDB_1
32322220	/data/lib/docker/defaultVolumes/task_3477_g0_dbpaas-metadb_dbpaas_1
27461120	/data/lib/docker/defaultVolumes/task_3001_g0_ark-metadb_miniDBPaaS-MetaDB_1
27319360	/data/lib/docker/defaultVolumes/task_36000_g0_ark-metadb_miniDBPaaS-MetaDB
27313836	/data/lib/docker/defaultVolumes/task_3600_g0_dbpaas-metadb_minidbpaas
27278692	/data/lib/docker/defaultVolumes/task_3604_g0_ark-metadb_miniDBPaaS-MetaDB_1
27277004	/data/lib/docker/defaultVolumes/task_3603_g0_ark-metadb_miniDBPaaS-MetaDB_1
27275736	/data/lib/docker/defaultVolumes/task_3542_g0_ark-metadb_miniDBPaaS-MetaDB
27271428	/data/lib/docker/defaultVolumes/task_3597_g0_ark-metadb_miniDBPaaS-MetaDB
27270840	/data/lib/docker/defaultVolumes/task_3603_g0_dbpaas-metadb_minidbpaas_1
27270492	/data/lib/docker/defaultVolumes/task_3603_g0_dbpaas-metadb_minidbpaas
27270468	/data/lib/docker/defaultVolumes/task_3600_g0_ark-metadb_miniDBPaaS-MetaDB
27270252	/data/lib/docker/defaultVolumes/task_3535_g0_ark-metadb_miniDBPaaS-MetaDB
27270244	/data/lib/docker/defaultVolumes/task_3538_g0_ark-metadb_miniDBPaaS-MetaDB
27270244	/data/lib/docker/defaultVolumes/task_3536_g0_ark-metadb_miniDBPaaS-MetaDB
25312404	/data/lib/docker/defaultVolumes/task_3477_g0_dncs-server_middleware-dncs_2

/data/lib/docker/defaultVolumes 参数是方舟默认volume存放的目录（一般是docker的存储路径下 –graph=/data/lib/docker) ，第一列是大小，后面是容器名

volume路径在物理机上也有可能是 /var/lib/docker 或者 /mw/mvdocker/ 之类的路径下，这个要依据安装参数来确定，可以用如下命令来找到这个路径：

sudo systemctl status docker -l | grep --color graph

结果如下，红色参数后面的路径就是docker 安装目录，到里面去找带volume的字眼：

找到 volume很大的文件件后同样可以进到这个文件夹中执行如下命令快速发现大文件：

du . --max-depth=2

方法三容器的系统日志没有限制大小

这种情况只针对2017年上半年之前的部署环境，后面部署的环境默认都控制了这些日志不会超过150M

按照方法二的描述先找到docker 安装目录，cd 进去，然后：

du ./containers --max-depth=2

就很快找到那个大json格式的日志文件了,然后执行清空这个大文件的内容：

echo '' | sudo tee 大文件名

一些其他可能占用空间的地方

机器上镜像太多，可以删掉一些没用的： sudo docker images -q | xargs sudo docker rmi
机器上残留的volume太多，删：sudo docker volume ls -q | xargs sudo docker volume rm
物理文件被删了，但是还有进程占用这个文件句柄，导致文件对应的磁盘空间没有释放，检查： lsof |　grep deleted 如果这个文件非常大的话，只能通过重启这个进程来真正释放磁盘空间

检查是否restart能支持只重启deamon，容器还能正常运行：

1
2
3

$sudo docker info | grep Restore
Live Restore Enabled: true

通过分析tcp包来确认服务调用的响应时间

发表于 2017-01-14 更新于 2025-11-16 分类于 TCP

通过分析tcp包来确认服务调用的响应时间

不需要在应用中打点，不限定于具体语言（php、cpp、java都可以）, 分析服务调用的响应时间

案例

当时的问题，客户现场不管怎么样增加应用机器，tps就是上不去，同时增加应用机器后，增加的机器CPU还都能被用完，但是tps没有变化（这点比较奇怪，也就是cpu用的更多了，tps没变化），客户感觉 整体服务调用慢，数据库没有慢查询，不知道到具体时间花在哪里，各个环节都尝试过增加服务器（或提升配置），但是问题一直得不到解决

原因

数据库服务器网卡中断瓶颈导致rtt非常高，进一步导致每个Query的ResponseTime非常高（图中左边都是出问题、右边都是问题解决后的响应时间）

通过程序把每个请求、响应时间等数据分析出来并存入数据库中（缺一个图形展示界面，有图形展示界面后会更直观）

图一中是每一秒中的平均 rtt 时间（round trip time）

问题修复后数据库每个查询的平均响应时间从47毫秒下降到了4.5毫秒

图中的每一行都是是一个查询的数据库执行时间

从wireshark中也可以看到类似的rtt不正常（超过150ms的比较多）

从wireshark中也可以看到类似的rtt正常(99%都在10ms以内）

总结

实际上通过抓包发现所有发往后面的SQL查询(请求链路：app -> slb -> drds -> slb ->rds) ，在app上抓包发现每个请求发出去到收到结果平均需要差不多100ms（无论SQL复杂与否），通过统计网络往返时间（rtt）发现rtt非常高，好多都是50ms以上。
降低压力比较rtt，发现rtt降到了20ms以内，同时SQL响应时间也相应地减短了。
已经排除了drds到rds响应慢的问题，问题应该在slb或者drds上，进一步发现drds（16Core 16GMem）绑定网卡中断的cpu用到了95%以上，尝试绑定到多个cpu内核，似乎ecs不支持，接下来将配置，增加多个低配置的drds来解决问题。

简单来说ecs默认网卡中断只能用到一个核，如果ecs配置太高，网卡中断会成为瓶颈，导致rtt变高、不稳定

最牛B的Linux Shell命令

发表于 2017-01-01 更新于 2025-11-16 分类于 Linux

最牛B的Linux Shell命令

引言

Shell作为Unix系操作系统当中最有魅力且不可或缺的组件，经过数十载的洗礼不仅没有被淘汰，而且愈加变得成熟稳健，究其原因，大概因为它是个非常稳固的粘合剂，能够把大量功能强大的组件任意配搭，总能很好很快地完成用户的任务。

本文的一些命令很可能看起来是“雕虫小技”，我们只好仰慕一下Shell大牛了，但是有些细节我会稍加发掘加以说明，遇到有趣的地方希望能博您一笑了。

1.以sudo运行上条命令

1	$ sudo !!

大家应该都知sudo，不解释。但通常出现的情况是，敲完命令执行后报错才发现忘了sudo。这时候，新手用户就会：按上箭头，按左箭头，盯着光标回到开始处，输入sudo，回车；高手用户就蛋定多了，按Ctrl-p，按Ctrl-a，输入sudo，回车。

这里介绍这个是天外飞仙级别的，对，就直接sudo !!。

当然这几种解决方式效果是完全一样的，只是款不一样，嗯，不解释。

两个感叹号其实是bash的一个特性，称为事件引用符（event designators）。!!其实相当于!-1，引用前一条命令，当然也可以!-2，!-50。默认情况下bash会在~/.bash_history文件内记录用户执行的最近500条命令，history命令可以显示这些命令。

关于事件引用符的更多用法可以深入阅读The Definitive Guide to Bash Command Line History。

2.以HTTP方式共享当前文件夹的文件

1	$ python -m SimpleHTTPServer 8080

这命令启动了Python的SimpleHTTPServer模块，考虑到Python在绝大多数的Linux发行版当中都默认安装，所以这个命令很可能是最简单的跨平台传文件的方法。

命令执行后将在本机8000端口开放HTTP服务，在其他能访问本机的机器的浏览器打开ttp://ip:8000即打开一个目录列表，点击即可下载。

python3的话

1	python3 -m http.server 8080

find

#最近一天修改的md文档
find . -maxdepth 1 -type f -mtime -1 -name "*.md" -not -name "template.md" -not -name "temp.md" -exec ls -lh "{}" \;

find . -size 0  -type f -exec ls -lh "{}" \;

find . -maxdepth 1 -type f -mtime -2 -name "*margin*" -exec mv "{}" /tmp/img/ \;

#clean the big file, but exclude spill dir
sudo find /home/admin/ -not -path "*/spill/*" -type f -size +3G -exec cp /dev/null {} \;
sudo find /home/admin/ -type f -name "*.hprof" -mtime +1 -exec rm -f {} \;
#clean the spill temp file which before 7 days ago
sudo find /home/admin/ -type f -mtime +7 -exec cp /dev/null {} \;
sudo find /home/admin/logs/ -type f -mtime +7 -exec rm -f {} \;
sudo find /var/log/ -type f -size +500M -exec cp /dev/null {} \;

// -mindepth 1 可以忽略当前目录的"." 
find . -mindepth 1 -maxdepth 1 -type d -mtime -50

#备份匹配的文件
find . -name '*.ibd' | grep tpcc1000 | grep -v mysql_global | xargs -I{} cp --path {} /tmp/bak/

#将yaml 备份，保留目录结构
find . -name '*.yaml' | xargs -I{} cp --path {} /tmp/


find $srcDir -maxdepth 1 -type f -mtime -$1 -name "*.md" -not -name "template.md" -not -name "temp.md" -exec ls -lh "{}" \;

find $srcDir -maxdepth 1 -type f -mtime -$1 -name "*.md" -not -name "template.md" -not -name "temp.md" -exec cp "{}" ./source/_posts/ \;

#sudo find /media/sf_D_DRIVE/case/ -maxdepth 1 -type f -mtime -$1 -name "*.md" -not -name "template.md" -print -exec cp "{}" ./source/_posts/ \;

cat的时候输出文件名：
find . -type f -print -exec cat {} \;

xargs 参数：

-I [replace-str]：将xargs的输出每一项参数，单独赋值给后面的命令，参数需要用指定的代替字符串replace-str代替，也就是说replace-str不可缺省，必须显示指明，可以使用{} $ @等符号，其主要作用是当xargs command后有多个参数时，调整参数位置

top

默认配置文件：/.toprc （on Ubuntu, it is */.config/procps/toprc*）

增加列：f (此时可以调整用 → 选择列并调整位置，此时也有4个窗口可以选择)

按node展示cpu：2(3 选择需要展示的node)

按core展示cpu: 1

切换颜色：z (有4个窗口可以选择，按 g 可以选择1-4)

配置颜色: Z

V 切换成森林视图，也就是展示进程父子关系

保存配置: W

dG9wJ3MgQ29uZmlnIEZpbGUgKExpbnV4IHByb2Nlc3NlcyB3aXRoIHdpbmRvd3MpCklkOmksIE1vZGVfYWx0c2NyPTAsIE1vZGVfaXJpeHBzPTEsIERlbGF5X3RpbWU9My4wLCBDdXJ3aW49MApDcHUJZmllbGRzY3VyPaWmqLWztLu9wMS3urg5xScpKissLS4vMDEyNjw+P0FCQ0ZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWoKCXdpbmZsYWdzPTE5NTM4MCwgc29ydGluZHg9MTgsIG1heHRhc2tzPTAsIGdyYXBoX2NwdXM9MCwgZ3JhcGhfbWVtcz0wCglzdW1tY2xyPTQsIG1zZ3NjbHI9MSwgaGVhZGNscj0zLCB0YXNrY2xyPTQKTWVtCWZpZWxkc2N1cj2lu73AvMPBws3OJjk3uigzNEQnxSkqKywtLi8wMTI1Njg+P0ZHSElKS0xPUFFSU1RVVldYWVpbXF1eX2BhYmNkZWZnaGlqCgl3aW5mbGFncz0xOTUzODAsIHNvcnRpbmR4PTIxLCBtYXh0YXNrcz0wLCBncmFwaF9jcHVzPTAsIGdyYXBoX21lbXM9MAoJc3VtbWNscj02LCBtc2dzY2xyPTYsIGhlYWRjbHI9MywgdGFza2Nscj02ClNjaAlmaWVsZHNjdXI9pTo7PD0+P0BBTUJOQ7WztMfEtre5xcYmJygpKissLS4vMDEyOEhJSktMT1BRUlNUVVZXWFlaW1xdXl9gYWJjZGVmZ2hpagoJd2luZmxhZ3M9MTk0ODY4LCBzb3J0aW5keD0wLCBtYXh0YXNrcz0wLCBncmFwaF9jcHVzPTAsIGdyYXBoX21lbXM9MAoJc3VtbWNscj01LCBtc2dzY2xyPTUsIGhlYWRjbHI9MywgdGFza2Nscj01CkNncAlmaWVsZHNjdXI9paanqCowOTc6RCkrLC0uLzEyMzQ1Njg7PD0+P0BBQkNGR8hJSktMTU5P0NHS09TVxVZXWFlaW1xdXl9gYWJjZGVmZ2hpagoJd2luZmxhZ3M9MTk0ODY4LCBzb3J0aW5keD0wLCBtYXh0YXNrcz0wLCBncmFwaF9jcHVzPTAsIGdyYXBoX21lbXM9MAoJc3VtbWNscj0yLCBtc2dzY2xyPTMsIGhlYWRjbHI9MywgdGFza2Nscj0yCkZpeGVkX3dpZGVzdD0wLCBTdW1tX21zY2FsZT0wLCBUYXNrX21zY2FsZT0wLCBaZXJvX3N1cHByZXNzPTAKCnBpcGUJTmV0RmlsZXMJbHNvZiAtYSAtbCAtbiAtUCAtaTQgLXAgJWQgMj4mMQpwaXBlCU9wZW5GaWxlcwlsc29mIC1hIC1sIC1uIC1QIC1wICVkIDI+JjEKZmlsZQlOVU1BSW5mbwkvcHJvYy8lZC9udW1hX21hcHMK

xargs 传参数

ls /xx | xargs -t -I{} cp {} /tmp/{}

-t ：打印内容，去掉\n之后的字符串

-I : 后面定义占位符，上例子是{} ，后面命令行中可以多次使用占位符

挂载多台苹果的例子

idevice_id -l|xargs -t -I{} mkdir {};idevice_id -l |xargs -t -I{} ifuse {} {}

批量执行docker exec

1	ansible -i host.ini all -m shell -a "docker ps -a \| grep tpcc \| grep dn \| cut -d ' ' -f 1 \| xargs -I{} docker exec {} bash -c \"myc -e 'shutdown'\""

批量推送镜像

1	docker images \|grep "docker.io:5000" \| awk '{ print $1":"$2 }' \| xargs -I {} docker push {}

非贪婪匹配

vim中默认匹配：abc.*d 是贪婪匹配，也就是尽可能长地匹配，改用 abc.{-}d 匹配到第一个 d字符就结束

贪婪模式是: .*

非贪婪模式是: .\{-}

\{n,m} Matches n to m of the preceding atom, as many as possible
\{n} Matches n of the preceding atom
\{n,} Matches at least n of the preceding atom, as many as possible
\{,m} Matches 0 to m of the preceding atom, as many as possible
\{} Matches 0 or more of the preceding atom, as many as possible (like *)
*/\{-*
\{-n,m} matches n to m of the preceding atom, as few as possible
\{-n} matches n of the preceding atom
\{-n,} matches at least n of the preceding atom, as few as possible
\{-,m} matches 0 to m of the preceding atom, as few as possible
\{-} matches 0 or more of the preceding atom, as few as possibles

grep 非贪婪匹配

1
2
3

grep --color -P "agHost.*?," test.table  //匹配 agHost后带有多个任意字符直到第一个 逗号 结束，-P表示用 perl 的匹配语法，而perl默认是不支持贪婪的

grep --color -o -P "agHost.*?," test.table  //-o 只打印匹配部分

匹配数字至少4次

1 2	grep -E ",rows=[0-9]{4,}" grep -E "[0-9]{4,}ms" mongod.log

macOS sed 删除行

//查找匹配的行：|      |                               |
grep -E "\| [[:space:]]*\| [[:space:]]*\|" top_linux_commands.md -B3

//删除行 -i ".bak"是直接操作文件并添加.bak作为备份文件名称，如果不需要备份文件，则使用-i ""
sed -i '' -e  '/\| [[:space:]]*\| [[:space:]]*\|/d'  top_linux_commands.md

//先备份文件为.bak, 再删除行 -i ".bak"是添加.bak作为备份文件名称
sed -i '.bak' 's/\| [[:space:]]*\| [[:space:]]*\|/d'  top_linux_commands.md

ps 查看进程

1	ps -Tfp pid // -T 展开进程下的线程 -f full -p pid

循环按行处理

1	while read i ; do echo $i ; done <./prometheus.list

3.在以普通用户打开的vim当中保存一个root用户文件

1	:w !sudo tee %

这题目读起来纠结，其实是很常见的，常常忘记了sudo就直接用vim编辑/etc内的文件，（不过也不一定，vim发现保存的文件无法保存时候会提示）等编辑好了，保存时候才发现没权限。曲线方法是先保存个临时文件，退出后再sudo cp回去。不过实际上在vim里面可以直接完成这个过程的，命令就是如此。

查阅vim的文档（输入:help :w），会提到命令:w!{cmd}，让vim执行一个外部命令{cmd}，然后把当前缓冲区的内容从stdin传入。

tee是一个把stdin保存到文件的小工具。

而%，是vim当中一个只读寄存器的名字，总保存着当前编辑文件的文件路径。

所以执行这个命令，就相当于从vim外部修改了当前编辑的文件，好完工。

4.切换回上一个目录

1	$ cd -

应该不少人都知道这个，横杆-代表上一个目录的路径。

实际上cd -就是cd $OLDPWD的简写，bash的固定变量$OLDPWD总保存着之前一个目录的路径。

相对地，$PWD总保存着当前目录的路径。这些变量在编写shell脚本时候相当有用。

5.替换上一条命令中的一个短语

1	$ ^foo^bar^

又是另外一个事件引用符（event designator），可以把上一条命令当中的foo替换成bar。

在需要重复运行调试一道长长的命令，需要测试某个参数时候，用这个命令会比较实用；但多数人会首先选择按上箭头提出上道命令，再移动光标去修改某参数，这样更直观，但效率上就不够使用引用符高，而且在脚本中用这个方法可以简化很多。

这道命令的原始样式应该是这样的:

1	!!:s/foo/bar/

本文一开始介绍过!!，后面的一段大家应该很熟悉，vim、sed的替换操作都是这样的语法。

关于事件引用符的更多用法可以深入阅读The Definitive Guide to Bash Command Line History

6.快速备份一个文件

1	$ cp filename{,.bak}

这道命令把filename文件拷贝成filename.bak，大家应该在一些比较复杂的安装教程里面见过这样的用法。其原理就在于bash对大括号的展开操作，filename{,.bak}这一段会被展开成filename filename.bak再传给cp，于是就有了备份的命令了。

大括号在bash里面是一个排列的意义，可以试试这个：

1	$ echo {a,b,c}{a,b,c}{a,b,c}

将输出三个集合的全排列:

aaa aab aac aba abb abc aca acb acc

baa bab bac bba bbb bbc bca bcb bcc

caa cab cac cba cbb cbc cca ccb ccc

关于shell当中的集合操作，可深入阅读“Set Operations in the Unix Shell”

7.免密码ssh登录主机

1	$ ssh-copy-id remote-machine

这个命令把当前用户的公钥串写入到远程主机的~/.ssh/authorized_keys内，这样下次使用ssh登录的时候，远程主机就直接根据这串密钥完成身份校验，不再询问密码了。前提是你当前用户有生成了公钥，默认是没有的，先执行ssh-keygen试试吧！

这个命令如果用手工完成，是这样的：

1 2 3	your-machine$ scp ~/.ssh/identity.pub remote-machine: your-machine$ ssh remote-machine remote-machine$ cat identity.pub >> ~/.ssh/authorized_keys

如果你想删掉远程主机上的密钥，直接打开authorized_keys，搜索你的用户名，删除那行，即可。

8.抓取Linux桌面的视频

1	$ ffmpeg -f x11grab -s wxga -r 25 -i :0.0 -sameq /tmp/out.mpg

我们在一些视频网站上看到别人的3D桌面怎么怎么酷的视频，通常就是这么来的，ffmpeg可以直接解码X11的图形，并转换到相应输出格式。

ffmpeg的通常用法是，根据一堆参数，输出一个文件，输出文件通常放最后，下面解析下几个参数：

-f x11grab 指定输入类型。因为x11的缓冲区不是普通的视频文件可以侦测格式，必须指定后ffmpeg才知道如何获得输入。

-s wxga 设置抓取区域的大小。wxga是1366*768的标准说法，也可以换成-s 800×600的写法。

-r 25 设置帧率，即每秒抓取的画面数。

-i :0.0 设置输入源，本地X默认在0.0

-sameq 保持跟输入流一样的图像质量，以用来后期处理。

至于其他ffmpeg的用法，可以参考下面两篇文章：

· How to Extract Audio Tracks from YouTube Videos

· Converting YouTube Flash Videos to a Better Format with ffmpeg

后记

说Shell是一种编程语言，可能有些尴尬，虽然很多人每天都在用Shell，但从来没见它荣登TIOBE编程语言排行榜之类的，可以说毫无名分，因为很多用户没意识到它是一种语言，只当做这是一个能够很好完成任务的工具，基本得理所当然，就好像GUI程序的菜单、按钮一样。

掌握Shell，通常能够让任务在数秒钟内完成，这就让Shell跟C、Perl、Python这些语言区别开来，没人否认后者更能胜任更多的任务，但是他们是在不同的层面上去做，Shell依赖大量的系统组件黏合调用，而后者依赖各种库，各所擅长不同的应用领域，比喻就是，Shell是混凝土，可以很方便地粘合一些建筑组件而成为稳固的高楼大厦；但同样是粘合剂，粘玻璃窗、粘书报、粘皮鞋，混凝土是绝对不合适的，Shell并不擅长一些细致操作，比如它连浮点运算都不支持，更别提什么图形运算什么的。但这并不妨碍Shell来帮我们完成很多粗重任务。

Shell的工作方式，大多数入门用户会觉得枯燥难学，而所谓的经典教材也离不开《Advanced Bash-Scripting》、《Bash Guide for Beginners》，但类似本文这样的一些“雕虫小技”因为难登大雅之堂绝不会收录进去。这情况如果象国外一些unix用户比较多的地方会有很好改善，即使是新手，偶尔看看别人的操作都能“偷师”一手，我编译本系列文章其实也就希望稍微改善一下这个状况。

1.用你最喜欢的编辑器来敲命令

1	command <CTRL-x CTRL-e>

在已经敲完的命令后按，会打开一个你指定的编辑器（比如vim，通过环境变量$EDITOR指定），里面就是你刚输入的命令，然后爱怎么编辑就怎么编辑吧，特别是那些参数异常复杂的程序，比如mencoder/ffmpeg，一个命令动辄3、4行的，要修改其中的参数，这个方法最合适不过了，保存退出后自动执行这个程序。

实际上这是readline库的功能，在默认情况下，bash使用的是emacs模式的命令行操作方式，是调用这个功能的一个绑定。如果你习惯使用vi模式，按可以实现同样功能。

如果你喜欢别的编辑器，可以在~/.bashrc里面放上比如export EDITOR=nano的命令。

另外一个修改命令的方法是使用fc命令（Fix Command），在编辑器里面打开上一句命令。我们的第一辑连载提过一个^foo^bar^命令可以用fc来实现：fc -s foo=bar。

2.清空或创建一个文件

1	> file.txt

>在shell里面是标准输出重定向符，即把（前部个命令的）命令行输出转往一个文件内，但这里没有“前部命令”，输出为空，于是就覆盖（或创建）成一个空文件了。

有些脚本的写法是:>file.txt，因为:是bash默认存在的空函数。

单纯创建文件也可以用$touch file.txt，touch本来是用作修改文件的时间戳，但如果文件不存在，就自动创建了。

3.用ssh创建端口转发通道

1	ssh -N -L2001:remotehost:80 user@somemachine

这个命令在本机打开了2001端口，对本机2001端口的请求通过somemachine作为跳板，转到remotehost的80端口上。

实现效果跟术语反向代理是相似的，实际上就是端口转发，注意上面的描述涉及了3台主机，但当然somemachine可以变成localhost。

这个命令比较抽象，但有时候是很有用的，比如因为众所周知的原因国内的IP的80端口无法使用，又或者公司的防火墙只给外网开了ssh端口，需要访问内部服务器一个web应用，以及需要访问某些限定了来源IP的服务，就可以用上这个方法了。

举一个具体例子，运行：

1 2	ssh -f -N -L 0.0.0.0:443:twitter.com:443 shell.cjb.net ssh -f -N -L 0.0.0.0:80:twitter.com:80 shell.cjb.net

然后在/etc/hosts里面添加127.0.0.1 twitter.com，好吧剩下的你懂的。

当然通常做这个功能的反向代理，应该要用squid、nginx之类，ssh就算是轻量级的尝试吧！

4.重置终端

1	reset

如果你试过不小心cat了某个二进制文件，很可能整个终端就傻掉了，可能不会换行，没法回显，大堆乱码之类的，这时候敲入reset回车，不管命令有没有显示，就能回复正常了。

实际上reset命令只是输出了一些特殊字符，我们看BusyBox里面最简单的reset程序的实现：

1	printf(“\033c\033(K\033[J\033[0m\033[?25h”);

输出的这些字符对Shell是有特殊意义的：

· \033c: “ESC c” – 发送重置命令;

· \033(K: “ESC ( K” – 重载终端的字符映射;

· \033[J: “ESC [ J” – 清空终端内容;

· \033[0m: “ESC [ 0 m” – 初始化字符显示属性;

· \033[?25h: “ESC [ ? 25 h” – 让光标可见;

其中字符显示属性经常用来设定打印字符的颜色等，可参考这个博文。

5.在午夜的时候执行某命令

1	echo cmd \| at midnight

说的就是at这个组件，通常跟cron相提并论，不过at主要用于定时一次性任务，而cron定时周期性任务。

at的参数比较人性化，跟英语语法一样，可以tomorrow, next week之类的，详细的查看手册man at。

6.远程传送麦克风语音

1	dd if=/dev/dsp \| ssh username@host dd of=/dev/dsp

没错就是实现一个喊话器的功能。

/dev/dsp是Linux下声卡的文件映射（Digital Signal Proccessor），从其中读数据就是录音，往里面写数据就是播放，相当简单！

dd是常用的数据拷贝程序，如果不同时指定if、of，就直接使用stdin/stdout来传输。

如果你没有远程主机，可以试试这样：

1	dd if=/dev/dsp of=/dev/dsp

直接回放麦克风的声音，只是有一点延时。

但是如果有别的程序正在使用声卡，这个方法就不凑效了，因为一般的声卡都不允许多个音频流同时处理，可以借用alsa组件的工具，arecord跟aplay:

1	arecord \| ssh username@host aplay

本地回放就是：

1	arecord \| aplay

如果你想吓吓别人：

1	cat /dev/urandom \| ssh username@host aplay

7.映射一个内存目录

1	mount -t tmpfs -o size=1024m tmpfs /mnt/ram

这个命令开了一块1G内存来当目录用。不过放心，如果里面没文件，是不会占用内存的，用多少占多少。

不过一般来说没必要手动挂载，因为多数发行版都会在fstab内预留了一个内存目录，挂载在/dev/shm，直接使用即可；

最常见的用途是用内存空间来放Firefox的配置，可以让慢吞吞的FF快很多，参见Shellex的博文：用tmpfs让Firefox在内存中飞驰，以及后来的改进：用tmpfs让Firefox在内存中飞驰II，其中提到的脚本来自speeding up firefox with tmpfs and automatic rsync。

那个破烂LinuxQQ也可以用这个方法，减少因为大量磁盘IO导致的问题。

8.用diff对比远程文件跟本地文件

1	ssh user@host cat /path/to/remotefile \| diff /path/to/localfile -

diff通常的用法是从参数读入两个文件，而命令里面的-则是指从stdin读入了。

善用ssh可以让web开发减少很多繁琐，还有比如sshfs，可以从编辑**-上传-编辑-**上传的人工循环里面解脱出来。

9.查看系统中占用端口的进程

1	netstat -tulnp

Netstat是很常用的用来查看Linux网络系统的工具之一，这个参数可以背下来：

· -t: 显示TCP链接信息

· -u: 显示UDP链接信息

· -l: 显示监听状态的端口

· -n: 直接显示ip，不做名称转换

· -p: 显示相应的进程PID以及名称（要root权限）

如果要查看关于sockets更详细占用信息等，可以使用lsof工具。

1. 更友好的显示当前挂载的文件系统

| 1 | **mount** **|** column -t |
| —- | ————————— |

这条命令适用于任何文件系统，column 用于把输出结果进行列表格式化操作，这里最主要的目的是让大家熟悉一下 columnt 的用法。下面是单单使用 mount 命令的结果：

1``2``3``4``5	$ mount`` ``/dev/root on / type ext3 (rw)``/proc on /proc type proc (rw)``/dev/mapper/lvmraid-home on /home type ext3 (rw,noatime)

而加了 column -t 命令后就成为这样了：

| 1``2``3``4``5 | $ **mount** **|** column -t`` ``**/**dev**/**root on **/** **type** ext3 **(**rw**)**``**/**proc on **/**proc **type** proc **(**rw**)**``**/**dev**/**mapper**/**lvmraid-home on **/**home **type** ext3 **(**rw,noatime**)** |
| ————— | ———————————————————— |

另外你可加上列名称来改善输出结果

| 1``2``3``4``5``6 | $ **(echo** "DEVICE - PATH - TYPE FLAGS" **&&** **mount)** **|** column -t`` ``DEVICE - PATH - TYPE FLAGS``**/**dev**/**root on **/** **type** ext3 **(**rw**)**``**/**proc on **/**proc **type** proc **(**rw**)**``**/**dev**/**mapper**/**lvmraid-home on **/**home **type** ext3 **(**rw,noatime**)** |
| —————— | ———————————————————— |

列2和列4并不是很友好，我们可以用 awk 来再处理一下

| 1``2``3``4``5``6 | $ **(echo** "DEVICE PATH TYPE FLAGS" **&&** **mount** **|** **awk** '$2=$4="";1'**)** **|** column -t`` ``DEVICE PATH TYPE FLAGS``**/**dev**/**root **/** ext3 **(**rw**)**``**/**proc **/**proc proc **(**rw**)**``**/**dev**/**mapper**/**lvmraid-home **/**home ext3 **(**rw,noatime**)** |
| —————— | ———————————————————— |

最后我们可以设置一个别名，为 nicemount

| 1 | $ nicemount**()** **{** **(echo** "DEVICE PATH TYPE FLAGS" **&&** **mount** **|** **awk** '$2=$4="";1'**)** **|** column -t; **}** |
| —- | ———————————————————— |

试一下

1``2``3``4``5``6	$ nicemount`` ``DEVICE PATH TYPE FLAGS``/dev/root / ext3 (rw)``/proc /proc proc (rw)``/dev/mapper/lvmraid-home /home ext3 (rw,noatime)

2. 运行前一个 Shell 命令，同时用 “bar” 替换掉命令行中的每一个 “foo”

`1`	`!!:gs/foo/bar`

!! 表示重复执行上一条命令，并用 :gs/foo/bar 进行替换操作。关于 !! 这个用法在前一篇文章中已有详细的介绍。

3. 实时某个目录下查看最新改动过的文件

`1`	`watch -d -n 1 'df; ls -FlAt /path'`

watch 是实时监控工具，-d 参数会高亮显示变化的区域，-n 1 参数表示刷新间隔为 1 秒。 df; ls -FlAt /path 运行了两条命令，df 是输出磁盘使用情况，ls -FlAt 则列出 /path 下面的所有文件。 ls -FlAt 的参数详解：

· -F 在文件后面加一个文件符号表示文件类型，共有 /=>@| 这几种类型， 表示可执行文件，/ 表示目录，= 表示接口( sockets) ，> 表示门， @ 表示符号链接， | 表示管道。

· -l 以列表方式显示

· -A 显示 . 和 ..

· -t 根据时间排序文件

4. 通过 SSH 挂载远程主机上的文件夹

`1`	`sshfs name@server:/path/to/folder /path/to/mount/point`

这条命令可以让你通过 SSH 加载远程主机上的文件系统为本地磁盘，前提是你需要安装 FUSE 及 sshfs 这两个软件。 译者注：关于 sshfs 实际上我之前写过一篇文章介绍过，详见在 Ubuntu 上使用 sshfs 映射远程 ssh 文件系统为本地磁盘。卸载的话使用 fusermount 或 umount 命令：

1``2	$ fusermount -u /path/to/mount/point``# umount /path/to/mount/point

5. 通过 DNS 来读取 Wikipedia 的词条

`1`	`dig +short txt .wp.dg.cx`

这也许是最有趣的一条技巧了，David Leadbeater 创建了一个 DNS 服务器，通过它当你查询一个 TXT 记录类型时，会返回一条来自于 Wikipedia 的简短的词条文字，这是他的介绍。这里有一个样例，来查询 “hacker” 的含义：

1``2``3``4``5``6``7``8 $ **dig** +short txt hacker.wp.dg.cx`` ``"Hacker may refer to: Hacker (computer security), someone involved``in computer security/insecurity, Hacker (programmer subculture), a``programmer subculture originating in the US academia in the 1960s,``which is nowadays mainly notable for the free software/” “open``source movement, Hacker (hobbyist), an enthusiastic home computer``hobbyist http://a.vu/w:Hacker"

这里使用了 dig 命令，这是标准的用来查询 DNS 的系统管理工具，+short 参数是让其仅仅返回文字响应，txt 则是指定查询 TXT 记录类型。更简单的做法是你可以为这个技巧创建一个函数：

1``2``3``4``5	wiki() { dig +short txt $1.wp.dg.cx; }``#然后试试吧：``wiki hacker`` ``"Hacker may refer to: Hacker (computer security), …"

如果你不想用 dig ，也可以用 host 命令：

`1`	`host -t txt hacker.wp.dg.cx`

另外在Twitter上看过某人的创意，用普通的dns来作为程序版本更新的查询服务器：设定域名software-version-check.example.com的A记录为1.2.40.3，对比自己的版本号，嗯，有更新了！

6. 用 Wget 的递归方式下载整个网站

1	nohup wget --random-wait -nc -q -r -l 0 --reject=html -np -e robots=off -U Mozilla www.example.com &

参数解释： –random-wait 等待 0.5 到 1.5 秒的时间来进行下一次请求 -r 开启递归检索 -e robots=off 忽略 robots.txt -U Mozilla 设置 User-Agent 头为 Mozilla 其它一些有用的参数：

· –limit-rate=20K 限制下载速度为 20K

· -o logfile.txt 记录下载日志

· -l 0 删除深度（默认为5）

· -wait=1h 每下载一个文件后等待1小时

-np 不下载父目录

–reject=html 不下载html

-nc 本地已有的不再下载

7. 复制最后使用的命令中的参数

1 2	Ctrl + . or ESC + . command + . //macOS

这个快捷键只能工作于 shell 的 emacs 编辑模式，它可以从最后使用的命令行中复制参数到当前命令行中，下面是一个样例：

1``2``3``4``5	$ echo a b c``a b c`` ``$ echo``$ echo c

你可以重复执行该快捷键，以便获取自已需要的参数，以下是样例：

1``2``3``4``5``6``7``8``9``10	$ echo 1 2 3``1 2 3``$ echo a b c``a b c`` ``$ echo``$ echo c`` ``$ echo again``$ echo 3

另外，假如你想指定第1个或第2个，或者是第 n 个参数的话，可以按 ALT + 1 (或 ESC + 1) 或 ALT + 2 (或 ESC +2) 这样形式的快捷键。以下是样例：

1``2``3``4``5``6``7``8``9``10	$ echo a b c``a b c`` ``$ echo``$ echo a``a`` ``$ echo``$ echo b``b

查看Emacs Editing Mode Keyboard Shortcuts一文获取更多类似的快捷键。

8. 执行一条命令但不保存到 history 中

`1`	`$ command`

这条命令可运行于最新的 Bash shell 里，在其它 shell 中没测试过。通过在命令行前面添加一个空格，就可以阻止这条命令被保存到 bash history (~/.bash_history) 文件中，这个行为可以通过 $HISTIGNORE shell 变量来控制。我的设置是 HISTIGNORE=”&:[ ]*” ，表示不保存重复的命令到 history 中，并且不保存以空格开头的命令行。$HISTIGNORE 中的值以冒号分隔。如果你的命令内包含密码，比如mysqladmin，不把它记录在历史当中是好主义。深入了解的话，可进一步看此文The Definitive Guide to Bash Command Line History

9. 显示当前目录中所有子目录的大小 du

sudo du –max-depth=1 -BG //单位 block-size G; or -BM MB	du -h –max-depth=1

–max-depth=1 参数可以让 du 命令显示当前目录下 1 级子目录的统计信息，当然你也可以把 1 改为 2 ，进一步显示 2 级子目录的统计信息，可以灵活运用。而 -h 参数则是以 Mb 、G 这样的单位来显示大小。 译者注：在此推荐一个小工具 ncdu ，可以更方便的达到此效果。

按单位大小排序

#du -sh * | sort -hr | head
1.8T	anolis_yum
1.6T	u02
1.5T	os
45G	drds_image
23G	polarx
8.3G	src
7.9G	drds.pcap
7.8G	root
4.3G	core.24086
3.5G	core.112462

10. 显示消耗内存最多的 10 个运行中的进程，以内存使用量排序

| 1 | **ps** aux **|** **sort** -nk +4 **|** **tail** |
| —- | ————————————————- |

显然这并不是最好的方法，但它确实用起还不错。这是一个典型的管道应用，通过 ps aux 来输出到 sort 命令，并用 sort 排序列出 4 栏，再进一步转到 tail 命令，最终输出 10 行显示使用内存最多的进程情况。假如想要发现哪个进程使用了大量内存的话，我通常会使用 htop 或 top 而非 ps 。

11. 用 python 快速开启一个 SMTP 服务

`1`	`python -m smtpd -n -c DebuggingServer localhost:1025`

这是一个用 Python 标准库 smtpd （用 -m smtpd 指定) 实现在简易 SMTP 服务，运行于 1025 端口。另外三个参数的解释： -n 参数让 Python 不要进行 setuid ( 改变用户）为 “nobody” ，也就是说直接用你的帐号来运行 -c DebuggingServer 参数是让 Python 运行时在屏幕上输出调试及运行信息 * localhost:1025 参数则是让 Python 在本地的 1025 端口上开启 SMTP 服务另外，假如你想让程序运行于标准的 25 的端口上的话，你必须使用 sudo 命令，因为只有 root 才能在 1-1024 端口上开启服务。如下：

`1`	`sudo python -m smtpd -n -c DebuggingServer localhost:25`

1.查看ascii码表

1	man 7 ascii

很多人初学编程都会接触到ascii码的概念，有时候为了查某个符号的ascii值，可能还得翻箱倒柜找出当年的课本？Linux Manpage里面其实包含了很多类似的实用资料，上述命令就能很详细的方式解释ascii编码，当然这里还有在线版。

man命令的第二个参数是区域码，用来区分索引词的范围，比如printf，在C标准库里面的printf跟bash当中的printf是不同的，前者的查询是man 3 printf，后者是man 1 printf。如果这个区域码省略，就会从1开始搜索，直到找到为止。

命令man man可以看到详细的解释。

manpages里面还有一些有趣而且实用的资料，可能鲜为人知：

· man 1 intro – 一篇对从未接触过Linux的用户的简明教程。

· man 2 syscalls – 内核系统请求的列表，按内核版本注释分类，系统编程必备。

· man 2 select_tut – 关于select()系统请求的教程。

· man 3 string – 在头文件内的所有函数。

· man 3 stdio – 关于头文件的使用，标准输入/输出库的说明。

· man 3 errno – 所有errorno的取值及说明。（C语言内类似其他语言的异常告知机制）

· man 4 console_codes – Linux的终端控制码及其使用解释。

· man 4 full – 介绍/dev/full这个总是处于“满”状态的磁盘。（对应/dev/null这个总是空的设备）

· man 5 proc – 介绍/proc下的文件系统。

· man 5 filesystems – 各种Linux文件系统。

第7区里面的资料通常最酷：

· man 7 bootparam – 详细解释内核启动参数。

· man 7 charsets – 解释各种语言的编码集。（gbk，gb2312等）

· man 7 glob – 解释glob文件名管理机制的工作过程。

· man 7 hier – 解释Linux文件系统结构各个部分的作用。

· man 7 operator – C语言的运算符的列表。

· man 7 regex – 介绍正则表达式。

· man 7 suffixes – 常见文件后缀名的列表跟解释。

· man 7 time – Linux的时钟机制解释。

· man 7 units – 数值单位及其数值的解释。

· man 7 utf8 – 描述UTF-8编码。

· man 7 url – 解释URL、URI、URN等的标准。

2.简易计时器

1	time read

运行命令开始算起，到结束时按一下Enter，就显示出整个过程的时间，精确到ms级别。

time是用来计算一个进程在运行到结束过程耗费多少时间的程序，它的输出通常有三项：

1 2 3 4 5	$ time ls /opt … real 0m0.008s user 0m0.003s sys 0m0.007s

real指整个程序对真实世界而言运行所需时间，user指程序在用户空间运行的时间，sys指程序对系统调用锁占用时间。

read本来是一个读取用户输入的命令，常见用法是read LINE，用户输入并回车后，键入的内容就被保存到$LINE变量内，但在键入回车前，这个命令是一直阻塞的。

可见time read这命令灵活地利用了操作系统的阻塞。用这个命令来测试一壶水多久煮滚应该是不错的。

3.远程关掉一台Windows机器

1	net rpc shutdown -I IP_ADDRESS -U username%password

Windows平台上的net命令是比较强大的，因为其后台是一个RPC类的系统服务，大家应该看过win下用net use \ip\ipc$ *这样一个命令建立IPC空连接，入侵主机的事情。

Linux下的net命令是samba组件的程序，通常包含在smbclient内，可以跟windows主机的文件、打印机共享等服务进行通讯，但是也支持rpc命令。

上述命令就是在远程Windows主机上执行了shutdown命令。当然这不一定成功，关系到win主机上面的安全设置。net命令能够控制到win主机就是了。

4.在一个子shell中运行一个命令

1	(cd /tmp && ls)

当然这只是演示，要查看目录当然可以ls /tmp。

好处就是不会改变当前shell的目录，以及如果命令中设计环境变量，也不会对当前shell有任何修改。

在Shell编程中还有很多使用上引号来括住一个命令：ls /tmp，这也是子shell过程。可是上引号的方法无法嵌套，而使用小括号的方法可以，一个比较纠结的例子是：

1	echo $(echo -e \x$(printf “%x” 65))

5.利用中间管道嵌套使用SSH

1	ssh -t host_A ssh host_B

如果目标机器host_B处于比较复杂的网络环境，本机无法直接访问，但另外一台host_A能够访问到host_B，而且也能被本机访问到，那上述命令就解决了方便登录host_B的问题。

但理论上这个过程是可以无限嵌套的，比如：

1	ssh -t host1 ssh -t host2 ssh -t host3 ssh -t host4 …

嗯那神马FBI CIA的，有本事来捉我吧～

6.清空屏幕

1	<CTRL+l>;

这个跟之前介绍的reset命令重置终端的作用有些类似，其实都只是发送一段控制序列，让终端的显示复位。

还可以这样运行：

1	tput clear

tput是专门用来控制终端的一个小工具，也挺强大的，详细信息运行man tput查看。

7.我想知道一台服务器什么时候重启完

1	ping -a IP

系统管理员最常做的事情是重启系统。但是服务器的重启过程往往得花上好几分钟，什么你的服务器4个scsi卡？16个硬盘？系统是Redhat？还完全安装所有组件？好吧，它重启的时间都够你吃顿饭了，所以我很想知道它什么时候回来。

ping命令有个audible ping参数，-a，当它终于ping通你的服务器时会让小喇叭叫起来。

8.列出你最常用的10条命令

1	history \| awk ‘{a[$2]++}END{for(i in a){print a[i] “ “ i}}’ \| sort -rn \| head

这行命令组合得很妙：

history输出用户了命令历史；awk统计并输出列表；sort排序；head截出前10行。

9.检查Gmail新邮件

1 2 3 4 5 6

curl -u you**@**gmail.com –silent “https://mail.google.com/mail/feed/atom“ | perl -ne \ ‘ print “Subject: $1 “ if /(.+?)</title>/ && $title++; print “(from $1)\n” if /<email>(.+?)</email>/; ‘</th> </tr> </thead> </table> Gmail的一个特色是支持Atom feed输出邮件列表，所以总是见到很多Gmail邮件提醒器之类的，因为开发特简单，atom很方便。 这里只是利用了perl的正则来解析atom（sed/awk也能做到）。 <h2 id="10-用Telnet看《星球大战》"><a href="#10-用Telnet看《星球大战》" class="headerlink" title="10.用Telnet看《星球大战》"></a>10.用Telnet看《星球大战》</h2><table> <thead> <tr> <th>1</th> <th>telnet towel.blinkenlights.nl</th> </tr> </thead> </table> 没什么好解释的，就是ASCII艺术之一。如果你有ipv6连接，还能看到彩色版的。牛吧？ </div> <footer class="post-footer"> <div class="post-eof"></div> </footer> </article> </div> <div class="post-block"> <article itemscope itemtype="http://schema.org/Article" class="post-content" lang=""> <link itemprop="mainEntityOfPage" href="https://plantegg.github.io/2016/10/12/ss%E7%94%A8%E6%B3%95%E5%A4%A7%E5%85%A8/"> <meta itemprop="image" content="/images/avatar.gif"> <meta itemprop="name" content="twitter @plantegg"> <meta itemprop="name" content="plantegg"> <meta itemprop="description" content="java mysql tcp performance network docker Linux"> <meta itemprop="name" content=" | plantegg"> <meta itemprop="description" content=""> <header class="post-header"> <h2 class="post-title" itemprop="name headline"> <a href="/2016/10/12/ss%E7%94%A8%E6%B3%95%E5%A4%A7%E5%85%A8/" class="post-title-link" itemprop="url">就是要你懂网络监控--ss用法大全</a> </h2> <div class="post-meta-container"> <div class="post-meta"> 发表于 <time title="创建时间：2016-10-12 15:30:03" itemprop="dateCreated datePublished" datetime="2016-10-12T15:30:03+08:00">2016-10-12</time> 更新于 <time title="修改时间：2025-11-29 15:11:18" itemprop="dateModified" datetime="2025-11-29T15:11:18+08:00">2025-11-29</time> 分类于 <a href="/categories/network/" itemprop="url" rel="index">network</a> </div> </div> </header> <div class="post-body" itemprop="articleBody"> <h1 id="就是要你懂网络监控–ss用法大全"><a href="#就是要你懂网络监控–ss用法大全" class="headerlink" title="就是要你懂网络监控–ss用法大全"></a>就是要你懂网络监控–ss用法大全</h1>ss是Socket Statistics的缩写。 netstat命令大家肯定已经很熟悉了，但是在2001年的时候netstat 1.42版本之后就没更新了，之后取代的工具是ss命令，是iproute2 package的一员。 <blockquote> rpm -ql iproute | grep ss /usr/sbin/ss </blockquote> netstat的替代工具是nstat，当然netstat的大部分功能ss也可以替代 ss可以显示跟netstat类似的信息，但是速度却比netstat快很多，netstat是基于/proc/net/tcp获取 TCP socket 的相关统计信息，用strace跟踪一下netstat查询tcp的连接，会看到他open的是/proc/net/tcp的信息。ss快的秘密就在于它利用的是TCP协议的tcp_diag模块，而且是从内核直接读取信息，当内核不支持 tcp_diag 内核模块时，会回退到 /proc/net/tcp 模式。 /proc/net/snmp 存放的是系统启动以来的累加值，netstat -s 读取它 /proc/net/tcp 是存放目前活跃的tcp连接的统计值，连接断开统计值清空， ss -it 读取它 <h2 id="ss-查看Buffer窗口"><a href="#ss-查看Buffer窗口" class="headerlink" title="ss 查看Buffer窗口"></a><a target="_blank" rel="noopener" href="https://access.redhat.com/discussions/3624151">ss 查看Buffer窗口</a></h2>ss参数说明<a target="_blank" rel="noopener" href="https://man7.org/linux/man-pages/man8/ss.8.html">权威参考</a> <figure class="highlight shell"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 </pre></td><td class="code"><pre>-m, --memory //查看每个连接的buffer使用情况 Show socket memory usage. The output format is: skmem:(r<rmem_alloc>,rb<rcv_buf>,t<wmem_alloc>,tb<snd_buf>, f<fwd_alloc>,w<wmem_queued>,o<opt_mem>, bl<back_log>,d<sock_drop>) <rmem_alloc> the memory allocated for receiving packet <rcv_buf> the total memory can be allocated for receiving packet <wmem_alloc> the memory used for sending packet (which has been sent to layer 3) <snd_buf> the total memory can be allocated for sending packet <fwd_alloc> the memory allocated by the socket as cache, but not used for receiving/sending packet yet. If need memory to send/receive packet, the memory in this cache will be used before allocate additional memory. <wmem_queued> The memory allocated for sending packet (which has not been sent to layer 3) <ropt_mem> The memory used for storing socket option, e.g., the key for TCP MD5 signature <back_log> The memory used for the sk backlog queue. On a process context, if the process is receiving packet, and a new packet is received, it will be put into the sk backlog queue, so it can be received by the process immediately <sock_drop> the number of packets dropped before they are de- multiplexed into the socket </pre></td></tr></table></figure> The entire print format of <code>ss -m</code> is given in the source: <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 </pre></td><td class="code"><pre> printf(" skmem:(r%u,rb%u,t%u,tb%u,f%u,w%u,o%u", skmeminfo[SK_MEMINFO_RMEM_ALLOC], skmeminfo[SK_MEMINFO_RCVBUF], skmeminfo[SK_MEMINFO_WMEM_ALLOC], skmeminfo[SK_MEMINFO_SNDBUF], skmeminfo[SK_MEMINFO_FWD_ALLOC], skmeminfo[SK_MEMINFO_WMEM_QUEUED], skmeminfo[SK_MEMINFO_OPTMEM]); if (RTA_PAYLOAD(tb[attrtype]) >= (SK_MEMINFO_BACKLOG + 1) * sizeof(__u32)) printf(",bl%u", skmeminfo[SK_MEMINFO_BACKLOG]); if (RTA_PAYLOAD(tb[attrtype]) >= (SK_MEMINFO_DROPS + 1) * sizeof(__u32)) printf(",d%u", skmeminfo[SK_MEMINFO_DROPS]); printf(")"); net/core/sock.c line:3095 void sk_get_meminfo(const struct sock *sk, u32 *mem) { memset(mem, 0, sizeof(*mem) * SK_MEMINFO_VARS); mem[SK_MEMINFO_RMEM_ALLOC] = sk_rmem_alloc_get(sk); mem[SK_MEMINFO_RCVBUF] = sk->sk_rcvbuf; mem[SK_MEMINFO_WMEM_ALLOC] = sk_wmem_alloc_get(sk); mem[SK_MEMINFO_SNDBUF] = sk->sk_sndbuf; mem[SK_MEMINFO_FWD_ALLOC] = sk->sk_forward_alloc; mem[SK_MEMINFO_WMEM_QUEUED] = sk->sk_wmem_queued; mem[SK_MEMINFO_OPTMEM] = atomic_read(&sk->sk_omem_alloc); mem[SK_MEMINFO_BACKLOG] = sk->sk_backlog.len; mem[SK_MEMINFO_DROPS] = atomic_read(&sk->sk_drops); } </pre></td></tr></table></figure> <img src="/images/951413iMgBlog/image-20210604120011898.png" alt="image-20210604120011898"> –memory/-m ：展示buffer窗口的大小 <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 </pre></td><td class="code"><pre>#ss -m | xargs -L 1 | grep "ESTAB" | awk '{ if($3>0 || $4>0) print $0 }' tcp ESTAB 0 31 10.97.137.1:7764 10.97.137.2:41019 skmem:(r0,rb7160692,t0,tb87040,f1792,w2304,o0,bl0) tcp ESTAB 0 193 ::ffff:10.97.137.1:sdo-tls ::ffff:10.97.137.2:55545 skmem:(r0,rb369280,t0,tb87040,f1792,w2304,o0,bl0) tcp ESTAB 0 65 ::ffff:10.97.137.1:splitlock ::ffff:10.97.137.2:47796 skmem:(r0,rb369280,t0,tb87040,f1792,w2304,o0,bl0) tcp ESTAB 0 80 ::ffff:10.97.137.1:informer ::ffff:10.97.137.3:49279 skmem:(r0,rb369280,t0,tb87040,f1792,w2304,o0,bl0) tcp ESTAB 0 11 ::ffff:10.97.137.1:acp-policy ::ffff:10.97.137.2:41607 skmem:(r0,rb369280,t0,tb87040,f1792,w2304,o0,bl0) #ss -m -n | xargs -L 1 | grep "tcp EST" | grep "t[1-9]" tcp ESTAB 0 281 10.97.169.173:32866 10.97.170.220:3306 skmem:(r0,rb4619516,t2304,tb87552,f1792,w2304,o0,bl0) //如下w204312都很大，接近 tb 大小了，应用代码中写死了 buffer 为 102K skmem:(r2304,rb204800,t0,tb204800,f18664,w204312,o0,bl0,d40150) cubic wscale:1,1 rto:330 rtt:129.991/0.028 ato:40 mss:1448 rcvmss:536 advmss:1448 cwnd:47 ssthresh:26 bytes_acked:1859972764 bytes_received:8052067 segs_out:1418895 segs_in:635234 send 4.2Mbps lastsnd:84 lastrcv:1035 lastack:84 pacing_rate 8.4Mbps unacked:38 retrans:0/577 rcv_rtt:34871 rcv_space:52040 skmem:(r0,rb204800,t0,tb204800,f1532,w240132,o0,bl0,d40051) cubic wscale:1,1 rto:334 rtt:133.523/0.594 ato:40 mss:1448 rcvmss:536 advmss:1448 cwnd:49 ssthresh:30 bytes_acked:8280788253 bytes_received:55404796 segs_out:6521018 segs_in:2842524 send 4.3Mbps lastsnd:5 lastrcv:7 lastack:88 pacing_rate 8.5Mbps unacked:41 retrans:0/40 reordering:8 rcv_rtt:26793 rcv_space:36790 </pre></td></tr></table></figure> <img src="/images/oss/4a09503e6c6e84c25e026248a1b3ebb6.png" alt="image.png"> 如上图，tb指可分配的发送buffer大小，不够还可以动态调整（应用没有写死的话），w[The memory allocated for sending packet (which has not been sent to layer 3)]已经预分配好了的size，t[the memory used for sending packet (which has been sent to layer 3)] , 似乎 w总是等于大于t？ example: <img src="/images/oss/4ed3d8aab6ef3ee45decda75e534baab.png" alt="image.png"> 对172.16.210.17和172.16.160.1之间的带宽限速50MB后观察(带宽限制后，发送buffer就很容易被撑满了）： <figure class="highlight shell"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 </pre></td><td class="code"><pre>$ss -m | xargs -L 1 | grep "tcp EST" | awk '{ if($3>0 || $4>0) print $0 }' Netid State Recv-Q Send-Q Local Address:Port Peer Address:Port tcp ESTAB 1431028 0 172.16.210.17:30082 172.16.160.1:4847 skmem:(r2066432,rb2135508,t0,tb46080,f2048,w0,o0,bl0,d72) tcp ESTAB 1195628 0 172.16.210.17:30086 172.16.160.1:4847 skmem:(r1742848,rb1915632,t8,tb46080,f190464,w0,o0,bl0,d187) tcp ESTAB 86416 0 172.16.210.17:40470 172.16.160.1:4847 skmem:(r127232,rb131072,t0,tb46080,f3840,w0,o0,bl0,d16) tcp ESTAB 1909826 0 172.16.210.17:40476 172.16.160.1:4847 skmem:(r2861568,rb2933688,t2,tb46080,f26112,w0,o0,bl0,d15) tcp ESTAB 758312 0 172.16.210.17:40286 172.16.160.1:4847 skmem:(r1124864,rb1177692,t0,tb46080,f1536,w0,o0,bl0,d17) tcp ESTAB 2238720 0 172.16.210.17:40310 172.16.160.1:4847 skmem:(r3265280,rb3334284,t0,tb46080,f3328,w0,o0,bl0,d30) tcp ESTAB 88172 0 172.16.210.17:40508 172.16.160.1:4847 skmem:(r128000,rb131072,t0,tb46080,f3072,w0,o0,bl0,d16) tcp ESTAB 87700 0 172.16.210.17:41572 172.16.160.1:4847 skmem:(r130560,rb131072,t0,tb46080,f512,w0,o0,bl0,d10) tcp ESTAB 4147293 0 172.16.210.17:40572 172.16.160.1:4847 skmem:(r6064896,rb6291456,t2,tb46080,f75008,w0,o0,bl0,d27) tcp ESTAB 1610940 0 172.16.210.17:30100 172.16.160.1:4847 skmem:(r2358784,rb2533092,t6,tb46080,f82432,w0,o0,bl0,d304) tcp ESTAB 4216156 0 172.16.210.17:30068 172.16.160.1:4847 skmem:(r6091008,rb6291456,t0,tb46080,f3840,w0,o0,bl0,d112) tcp ESTAB 87468 0 172.16.210.17:40564 172.16.160.1:4847 skmem:(r127232,rb131072,t0,tb46080,f3840,w0,o0,bl0,d16) tcp ESTAB 0 84608 172.16.210.17:3306 10.100.7.27:43114 skmem:(r0,rb65536,t8352,tb131072,f75648,w92288,o0,bl0,d0) tcp ESTAB 4141872 0 172.16.210.17:40584 172.16.160.1:4847 skmem:(r6050560,rb6291456,t2,tb46080,f19712,w0,o0,bl0,d14) $ss -itn State Recv-Q Send-Q Local Address:Port Peer Address:Port ESTAB 965824 0 172.16.210.17:19310 172.16.160.1:4847 cubic wscale:9,7 rto:215 rtt:14.405/0.346 ato:160 mss:1440 rcvmss:1460 advmss:1460 cwnd:10 bytes_acked:1324584 bytes_received:2073688144 segs_out:91806 segs_in:1461520 data_segs_out:4824 data_segs_in:1456130 send 8.0Mbps lastsnd:545583 lastrcv:545276 lastack:13173 pacing_rate 16.0Mbps delivery_rate 8.9Mbps app_limited busy:9071ms rcv_rtt:1.303 rcv_space:164245 minrtt:1.293 ESTAB 0 84371 172.16.210.17:3306 10.100.7.147:59664 cubic wscale:7,7 rto:217 rtt:16.662/0.581 ato:40 mss:1448 rcvmss:976 advmss:1448 cwnd:375 ssthresh:19 bytes_acked:5087795046 bytes_received:1647 segs_out:3589314 segs_in:358086 data_segs_out:3589313 data_segs_in:8 send 260.7Mbps lastsnd:6 lastrcv:1177745 lastack:4 pacing_rate 312.8Mbps delivery_rate 32.9Mbps busy:1176476ms rwnd_limited:1717ms(0.1%) sndbuf_limited:159867ms(13.6%) unacked:37 retrans:0/214 rcv_space:14600 notsent:32055 minrtt:7.945 ESTAB 0 83002 172.16.210.17:3306 10.100.7.28:34066 cubic wscale:7,7 rto:215 rtt:14.635/0.432 ato:40 mss:1448 rcvmss:976 advmss:1448 cwnd:144 ssthresh:144 bytes_acked:972464708 bytes_received:1466 segs_out:671667 segs_in:94369 data_segs_out:671666 data_segs_in:8 send 114.0Mbps lastsnd:1 lastrcv:453365 lastack:1 pacing_rate 136.8Mbps delivery_rate 24.0Mbps busy:453493ms sndbuf_limited:200ms(0.0%) unacked:23 rcv_space:14600 notsent:49698 minrtt:9.937 ESTAB 1239616 0 172.16.210.17:41592 172.16.160.1:4847 cubic wscale:9,7 rto:216 rtt:15.754/0.775 ato:144 mss:1440 rcvmss:1460 advmss:1460 cwnd:10 bytes_acked:20321 bytes_received:1351071 segs_out:269 segs_in:1091 data_segs_out:76 data_segs_in:988 send 7.3Mbps lastsnd:339339 lastrcv:337401 lastack:10100 pacing_rate 14.6Mbps delivery_rate 1.0Mbps app_limited busy:1214ms rcv_rtt:227.156 rcv_space:55581 minrtt:11.38 ESTAB 3415748 0 172.16.210.17:30090 172.16.160.1:4847 cubic wscale:9,7 rto:202 rtt:1.667/0.011 ato:80 mss:1440 rcvmss:1460 advmss:1460 cwnd:10 bytes_acked:398583 bytes_received:613824362 segs_out:28630 segs_in:437621 data_segs_out:1495 data_segs_in:435792 send 69.1Mbps lastsnd:1179931 lastrcv:1179306 lastack:12149 pacing_rate 138.2Mbps delivery_rate 7.2Mbps app_limited busy:2520ms rcv_rtt:1.664 rcv_space:212976 minrtt:1.601 ESTAB 86480 0 172.16.210.17:41482 172.16.160.1:4847 cubic wscale:9,7 rto:215 rtt:14.945/1.83 ato:94 mss:1440 rcvmss:1460 advmss:1460 cwnd:10 bytes_acked:3899 bytes_received:93744 segs_out:73 segs_in:136 data_segs_out:20 data_segs_in:83 send 7.7Mbps lastsnd:449541 lastrcv:449145 lastack:19314 pacing_rate 15.4Mbps delivery_rate 964.2Kbps app_limited busy:296ms rcv_rtt:8561.27 rcv_space:14600 minrtt:11.948 ESTAB 89136 0 172.16.210.17:40480 172.16.160.1:4847 cubic wscale:9,7 rto:213 rtt:12.11/0.79 ato:196 mss:1440 rcvmss:1460 advmss:1460 cwnd:10 bytes_acked:2510 bytes_received:95652 segs_out:102 segs_in:168 data_segs_out:16 data_segs_in:81send 9.5Mbps lastsnd:1099067 lastrcv:1098659 lastack:13686 pacing_rate 19.0Mbps delivery_rate 1.0Mbps app_limited busy:199ms rcv_rtt:2438.63 rcv_space:14600 minrtt:11.178 ESTAB 0 84288 172.16.210.17:3306 10.100.7.26:51160 cubic wscale:7,7 rto:216 rtt:15.129/0.314 ato:40 mss:1448 rcvmss:976 advmss:1448 cwnd:157 :157 bytes_acked:2954689465 bytes_received:1393 segs_out:2041403 segs_in:237797 data_segs_out:2041402 data_segs_in:8 send 120.2Mbps lastsnd:11 lastrcv:1103462 lastack:10 pacing_rate 144.2Mbps delivery_rate 31.3Mbps busy:1103503ms sndbuf_limited:3398ms(0.3%) unacked:24 retrans:0/7rcv_space:14600 notsent:49536 minrtt:9.551 </pre></td></tr></table></figure> 推荐 -m -i 一起查看状态，比如 rcv_space 表示buffer达到过的最大水位 <blockquote> rcv_space is the high water mark of the rate of the local application reading from the receive buffer during any RTT. This is used internally within the kernel to adjust sk_rcvbuf. </blockquote> <h2 id="ss-查看拥塞窗口、RTO"><a href="#ss-查看拥塞窗口、RTO" class="headerlink" title="ss 查看拥塞窗口、RTO"></a>ss 查看拥塞窗口、RTO</h2><blockquote> //rto的定义，不让修改，每个ip的rt都不一样，必须通过rtt计算所得, HZ 一般是1秒 #define TCP_RTO_MAX ((unsigned)(120*HZ)) #define TCP_RTO_MIN ((unsigned)(HZ/5)) //在rt很小的环境中计算下来RTO基本等于TCP_RTO_MIN </blockquote> 下面看到的rto和rtt单位都是毫秒，一般rto最小为200ms、最大为120秒 <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 </pre></td><td class="code"><pre>#ss -itn |egrep "cwnd|rto" ESTAB 0 165 [::ffff:192.168.0.174]:48074 [::ffff:192.168.0.173]:3306 cubic wscale:7,7 rto:201 rtt:0.24/0.112 ato:40 mss:1448 rcvmss:1448 advmss:1448 cwnd:10 bytes_acked:1910206449 bytes_received:8847784416 segs_out:11273005 segs_in:22997562 data_segs_out:9818729 data_segs_in:13341573 send 482.7Mbps lastsnd:1 lastrcv:1 pacing_rate 963.8Mbps delivery_rate 163.2Mbps app_limited busy:2676463ms retrans:0/183 rcv_rtt:1.001 rcv_space:35904 minrtt:0.135 ESTAB 0 0 [::ffff:192.168.0.174]:48082 [::ffff:192.168.0.173]:3306 cubic wscale:7,7 rto:201 rtt:0.262/0.112 ato:40 mss:1448 rcvmss:1448 advmss:1448 cwnd:10 bytes_acked:1852907381 bytes_received:8346503207 segs_out:10913962 segs_in:22169704 data_segs_out:9531411 data_segs_in:12796151 send 442.1Mbps lastsnd:2 lastack:2 pacing_rate 881.3Mbps delivery_rate 164.3Mbps app_limited busy:2736500ms retrans:0/260 rcv_rtt:1.042 rcv_space:31874 minrtt:0.133 ----- skmem:(r0,rb131072,t0,tb133632,f0,w0,o0,bl0,d0) cubic wscale:8,7 rto:233 rtt:32.489/2.99 ato:40 mss:1380 rcvmss:536 advmss:1460 cwnd:11 ssthresh:8 bytes_acked:99862366 bytes_received:2943 segs_out:78933 segs_in:23388 data_segs_out:78925 data_segs_in:81 send 3.7Mbps lastsnd:1735288 lastrcv:1735252 lastack:1735252 pacing_rate 4.5Mbps delivery_rate 2.9Mbps busy:370994ms retrans:0/6479 reordering:5 rcv_space:14600 minrtt:27.984 </pre></td></tr></table></figure> <h3 id="RTO计算算法"><a href="#RTO计算算法" class="headerlink" title="RTO计算算法"></a>RTO计算算法</h3>RTO的计算依赖于RTT值，或者说一系列RTT值。rto=f(rtt) <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 </pre></td><td class="code"><pre>1.1. 在没有任何rtt sample的时候，RTO <- TCP_TIMEOUT_INIT (1s) 多次重传时同样适用指数回避算法(backoff)增加RTO 1.2. 获得第一个RTT sample后， SRTT <- RTT RTTVAR <- RTT/2 RTO <- SRTT + max(G, K * RTTVAR) 其中K=4, G表示timestamp的粒度(在CONFIG_HZ=1000时，粒度为1ms) 1.3. 后续获得更多RTT sample后， RTTVAR <- (1 - beta) * RTTVAR + beta * |SRTT - R| SRTT <- (1 - alpha) * SRTT + alpha * R 其中beta = 1/4, alpha = 1/8 1.4. Whenever RTO is computed, if it is less than 1 second, then the RTO SHOULD be rounder up to 1 second. 1.5. A maximum value MAY be placed on RTO provided it is at least 60 seconds. </pre></td></tr></table></figure> RTTVAR表示的是平滑过的平均偏差，SRTT表示的平滑过的RTT。这两个值的具体含义会在后面介绍 具体实现的时候进一步的解释。 以上是计算一个初始RTO值的过程，当连续出现RTO超时后， RTO值会用一个叫做指数回避的策略进行调整，下面来具体介绍。 <h2 id="从系统cache中查看-tcp-metrics-item"><a href="#从系统cache中查看-tcp-metrics-item" class="headerlink" title="从系统cache中查看 tcp_metrics item"></a>从系统cache中查看 tcp_metrics item</h2><pre><code>$sudo ip tcp_metrics show | grep 100.118.58.7 100.118.58.7 age 1457674.290sec tw_ts 3195267888/5752641sec ago rtt 1000us rttvar 1000us ssthresh 361 cwnd 40 ----这两个值对传输性能很重要 192.168.1.100 age 1051050.859sec ssthresh 4 cwnd 2 rtt 4805us rttvar 4805us source 192.168.0.174 ---这条记录有问题，缓存的ssthresh 4 cwnd 2都太小，传输速度一定慢清除 tcp_metrics, sudo ip tcp_metrics flush all 关闭 tcp_metrics 功能，net.ipv4.tcp_no_metrics_save = 1 sudo ip tcp_metrics delete 100.118.58.7 </code></pre> 每个连接的ssthresh默认是个无穷大的值，但是内核会cache对端ip上次的ssthresh（大部分时候两个ip之间的拥塞窗口大小不会变），这样大概率到达ssthresh之后就基本拥塞了，然后进入cwnd的慢增长阶段。 <h2 id="ss-过滤地址和端口号，类似tcpdump的用法"><a href="#ss-过滤地址和端口号，类似tcpdump的用法" class="headerlink" title="ss 过滤地址和端口号，类似tcpdump的用法"></a>ss 过滤地址和端口号，类似tcpdump的用法</h2>过滤目标端口是80的或者源端口是1723的连接，dst后面要跟空格然后加“：”： <pre><code># ss -ant dst :80 or src :1723 State Recv-Q Send-Q Local Address:Port Peer Address:Port LISTEN 0 3 *:1723 *:* TIME-WAIT 0 0 172.31.23.95:37269 111.161.68.235:80 TIME-WAIT 0 0 172.31.23.95:37263 111.161.68.235:80 TIME-WAIT 0 0 172.31.23.95:37267 </code></pre> or： <pre><code>ss -ant dport = :80 or sport = :1723 </code></pre> 地址筛选，目标地址是111.161.68.235的连接 <pre><code>ss -ant dst 111.161.68.235 </code></pre> 端口大小筛选，源端口大于1024的端口： <pre><code>ss sport gt 1024 </code></pre> How Do I Compare Local and/or Remote Port To A Number? Use the following syntax: <pre><code>## Compares remote port to a number ## ss dport OP PORT ## Compares local port to a number ## sport OP PORT </code></pre> Where OP can be one of the following: <pre><code><= or le : Less than or equal to port >= or ge : Greater than or equal to port == or eq : Equal to port != or ne : Not equal to port < or gt : Less than to port > or lt : Greater than to port Note: le, gt, eq, ne etc. are use in unix shell and are accepted as well. ################################################################################### ### Do not forget to escape special characters when typing them in command line ### ################################################################################### ss sport = :http ss dport = :http ss dport \> :1024 ss sport \> :1024 ss sport \< :32000 ss sport eq :22 ss dport != :22 ss state connected sport = :http ss $ sport = :http or sport = :https $ ss -o state fin-wait-1 $ sport = :http or sport = :https $ dst 192.168.1/24 </code></pre> <h2 id="ss-查看-timer-状态"><a href="#ss-查看-timer-状态" class="headerlink" title="ss 查看 timer 状态"></a>ss 查看 timer 状态</h2>ss -atonp <h2 id="按连接状态过滤"><a href="#按连接状态过滤" class="headerlink" title="按连接状态过滤"></a>按连接状态过滤</h2>Display All Established HTTP Connections <pre><code>ss -o state established '( dport = :http or sport = :http )' </code></pre> List all the TCP sockets in state -FIN-WAIT-1 for our httpd to network 202.54.1/24 and look at their timers: ss -o state fin-wait-1 ‘( sport = :http or sport = :https )’ dst 202.54.1/24 Filter Sockets Using TCP States <pre><code>ss -4 state FILTER-NAME-HERE </code></pre> Where FILTER-NAME-HERE can be any one of the following, <pre><code>established syn-sent syn-recv fin-wait-1 fin-wait-2 time-wait closed close-wait last-ack listen closing all : All of the above states connected : All the states except for listen and closed synchronized : All the connected states except for syn-sent bucket : Show states, which are maintained as minisockets, i.e. time-wait and syn-recv. big : Opposite to bucket state. </code></pre> <h2 id="ss分析重传的包数量"><a href="#ss分析重传的包数量" class="headerlink" title="ss分析重传的包数量"></a>ss分析重传的包数量</h2>通过抓取ss命令，可以分析出来重传的包数量，然后将重传的流的数量和重传的包的数量按照对端IP:port的维度分段聚合，参考命令： <pre><code>ss -itn |grep -v "Address:Port" | xargs -L 1 | grep retrans | awk '{gsub("retrans:.*/", "",$21); print $5, $21}' | awk '{arr[$1]+=$2} END {for (i in arr) {print i,arr[i]}}' | sort -rnk 2 </code></pre> xargs -L 1 每一行处理一次，但是这个行如果是空格、tab结尾，那么会被认为是连续行，跟下一行合并 高版本Linux内核的话，可以用systemtap或者bcc来获取每个连接的重传包以及发生重传的阶段 <h2 id="当前和最大全连接队列确认"><a href="#当前和最大全连接队列确认" class="headerlink" title="当前和最大全连接队列确认"></a>当前和最大全连接队列确认</h2><pre><code>$ss -lt State Recv-Q Send-Q Local Address:Port Peer Address:Port LISTEN 0 128 127.0.0.1:10248 *:* LISTEN 0 128 *:2376 *:* LISTEN 0 128 127.0.0.1:10249 *:* LISTEN 0 128 *:7337 *:* LISTEN 0 128 *:10250 *:* LISTEN 0 128 11.163.187.44:7946 *:* LISTEN 0 128 127.0.0.1:55631 *:* LISTEN 0 128 *:10256 *:* LISTEN 0 10 *:6640 *:* LISTEN 0 128 127.0.0.1:vmware-fdm *:* LISTEN 0 128 11.163.187.44:vmware-fdm *:* LISTEN 0 128 *:ssh *:* LISTEN 0 10 127.0.0.1:15772 *:* LISTEN 0 10 127.0.0.1:15776 *:* LISTEN 0 10 127.0.0.1:19777 *:* LISTEN 0 10 11.163.187.44:15778 *:* LISTEN 0 128 *:tr-rsrb-p2 *:* </code></pre> <h2 id="ss-s"><a href="#ss-s" class="headerlink" title="ss -s"></a>ss -s</h2>统计所有连接的状态 <h2 id="nstat"><a href="#nstat" class="headerlink" title="nstat"></a>nstat</h2>nstat -z -t 1 类似 netstat -s (ss –info 展示rto、拥塞算法等更详细信息； netstat -ant -o 展示keepalive是否) netstat<a target="_blank" rel="noopener" href="http://perthcharles.github.io/2015/11/10/wiki-netstat-proc/">参考</a> 比如： <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 </pre></td><td class="code"><pre>#nstat -az TcpExtTCPRcvCollapsed TcpExtTCPRcvCoalesce TcpExtTCPRcvQDrop #kernel TcpExtTCPRcvCollapsed 0 0.0 //类似对内存进行垃圾回收，慢 TcpExtTCPRcvCoalesce 403679 0.0 //合并整理，较快 TcpExtTCPRcvQDrop 0 0.0 </pre></td></tr></table></figure> 参考 <a target="_blank" rel="noopener" href="https://blog.cloudflare.com/when-the-window-is-not-fully-open-your-tcp-stack-is-doing-more-than-you-think">cloudflare 博客</a>： <img src="/images/951413iMgBlog/image5-13.png" alt="img"> <img src="/images/951413iMgBlog/image8-4.png" alt="img"> <h2 id="knetstat"><a href="#knetstat" class="headerlink" title="knetstat"></a>knetstat</h2>最后给出的一个工具，knetstat（需要单独安装），也可以查看tcp的状态下的各种参数，需要单独安装 example(3306是本地server，4192是后端MySQL）： <pre><code>Recv-Q Send-Q Local Address Foreign Address Stat Diag Options 0 0 0.0.0.0:3306 0.0.0.0:* LSTN SO_REUSEADDR=1,SO_REUSEPORT=0,SO_KEEPALIVE=0,TCP_NODELAY=0,TCP_FASTOPEN=0,TCP_DEFER_ACCEPT=0 0 0 0.0.0.0:3406 0.0.0.0:* LSTN SO_REUSEADDR=1,SO_REUSEPORT=0,SO_KEEPALIVE=0,TCP_NODELAY=0,TCP_FASTOPEN=0,TCP_DEFER_ACCEPT=0 0 0 127.0.0.1:8182 0.0.0.0:* LSTN SO_REUSEADDR=1,SO_REUSEPORT=0,SO_KEEPALIVE=0,TCP_NODELAY=0,TCP_FASTOPEN=0,TCP_DEFER_ACCEPT=0 0 0 10.0.186.73:8182 0.0.0.0:* LSTN SO_REUSEADDR=1,SO_REUSEPORT=0,SO_KEEPALIVE=0,TCP_NODELAY=0,TCP_FASTOPEN=0,TCP_DEFER_ACCEPT=0 0 0 0.0.0.0:22 0.0.0.0:* LSTN SO_REUSEADDR=1,SO_REUSEPORT=0,SO_KEEPALIVE=0,TCP_NODELAY=0,TCP_FASTOPEN=0,TCP_DEFER_ACCEPT=0 0 0 0.0.0.0:8188 0.0.0.0:* LSTN SO_REUSEADDR=1,SO_REUSEPORT=0,SO_KEEPALIVE=0,TCP_NODELAY=0,TCP_FASTOPEN=0,TCP_DEFER_ACCEPT=0 0 0 127.0.0.1:15778 0.0.0.0:* LSTN SO_REUSEADDR=1,SO_REUSEPORT=0,SO_KEEPALIVE=0,TCP_NODELAY=0,TCP_FASTOPEN=0,TCP_DEFER_ACCEPT=0 0 138 10.0.186.73:51756 10.0.160.1:4192 ESTB ># SO_REUSEADDR=0,SO_REUSEPORT=0,SO_KEEPALIVE=1,TCP_NODELAY=1,TCP_DEFER_ACCEPT=0 0 0 10.0.186.73:3306 10.0.186.70:37428 ESTB SO_REUSEADDR=1,SO_REUSEPORT=0,SO_KEEPALIVE=1,SO_RCVBUF=32768,SO_SNDBUF=65536,TCP_NODELAY=1,TCP_DEFER_ACCEPT=0 0 138 10.0.186.73:51476 10.0.160.1:4192 ESTB ># SO_REUSEADDR=0,SO_REUSEPORT=0,SO_KEEPALIVE=1,TCP_NODELAY=1,TCP_DEFER_ACCEPT=0 0 0 10.0.186.73:3306 10.0.186.70:37304 ESTB SO_REUSEADDR=1,SO_REUSEPORT=0,SO_KEEPALIVE=1,SO_RCVBUF=32768,SO_SNDBUF=65536,TCP_NODELAY=1,TCP_DEFER_ACCEPT=0 0 0 10.0.186.73:51842 10.0.160.1:4192 ESTB SO_REUSEADDR=0,SO_REUSEPORT=0,SO_KEEPALIVE=1,TCP_NODELAY=1,TCP_DEFER_ACCEPT=0 44 0 10.0.186.73:3306 10.0.186.70:36238 ESTB SO_REUSEADDR=1,SO_REUSEPORT=0,SO_KEEPALIVE=1,SO_RCVBUF=32768,SO_SNDBUF=65536,TCP_NODELAY=1,TCP_DEFER_ACCEPT=0 44 0 10.0.186.73:3306 10.0.186.70:36160 ESTB SO_REUSEADDR=1,SO_REUSEPORT=0,SO_KEEPALIVE=1,SO_RCVBUF=32768,SO_SNDBUF=65536,TCP_NODELAY=1,TCP_DEFER_ACCEPT=0 0 0 10.0.186.73:19030 10.0.171.188:8000 TIMW </code></pre> 3306对应的client上： <pre><code>Recv-Q Send-Q Local Address Foreign Address Stat Diag Options 0 44 10.0.186.70:42428 10.0.186.73:3306 ESTB ># SO_REUSEADDR=0,SO_REUSEPORT=0,SO_KEEPALIVE=1,SO_RCVTIMEO=31536000000ms,SO_SNDTIMEO=31536000000ms,TCP_NODELAY=1,TCP_DEFER_ACCEPT=0 0 44 10.0.186.70:42298 10.0.186.73:3306 ESTB ># SO_REUSEADDR=0,SO_REUSEPORT=0,SO_KEEPALIVE=1,SO_RCVTIMEO=31536000000ms,SO_SNDTIMEO=31536000000ms,TCP_NODELAY=1,TCP_DEFER_ACCEPT=0 0 44 10.0.186.70:42296 10.0.186.73:3306 ESTB ># SO_REUSEADDR=0,SO_REUSEPORT=0,SO_KEEPALIVE=1,SO_RCVTIMEO=31536000000ms,SO_SNDTIMEO=31536000000ms,TCP_NODELAY=1,TCP_DEFER_ACCEPT=0 0 44 10.0.186.70:42322 10.0.186.73:3306 ESTB ># SO_REUSEADDR=0,SO_REUSEPORT=0,SO_KEEPALIVE=1,SO_RCVTIMEO=31536000000ms,SO_SNDTIMEO=31536000000ms,TCP_NODELAY=1,TCP_DEFER_ACCEPT=0 </code></pre> Diag列的说明 Indicator Meaning >| The sender window (i.e. the window advertised by the remote endpoint) is 0. No data can be sent to the peer. >|< The receiver window (i.e. the window advertised by the local endpoint) is 0. No data can be received from the peer. > ># There are unacknowledged packets and the last ACK was received more than one second ago. This may be an indication that there are network problems or that the peer crashed. <h2 id="参考文章"><a href="#参考文章" class="headerlink" title="参考文章"></a>参考文章</h2><a target="_blank" rel="noopener" href="https://www.cyberciti.biz/tips/linux-investigate-sockets-network-connections.html">https://www.cyberciti.biz/tips/linux-investigate-sockets-network-connections.html</a> <a target="_blank" rel="noopener" href="http://perthcharles.github.io/2015/11/10/wiki-netstat-proc/">http://perthcharles.github.io/2015/11/10/wiki-netstat-proc/</a> 源代码：<a target="_blank" rel="noopener" href="https://github.com/sivasankariit/iproute2/blob/master/misc/ss.c">https://github.com/sivasankariit/iproute2/blob/master/misc/ss.c</a> <a target="_blank" rel="noopener" href="https://github.com/veithen/knetstat/tree/master">https://github.com/veithen/knetstat/tree/master</a> <a target="_blank" rel="noopener" href="https://access.redhat.com/discussions/782343">https://access.redhat.com/discussions/782343</a> <a target="_blank" rel="noopener" href="https://perthcharles.github.io/2015/09/06/wiki-rtt-estimator/">RTO的计算方法(基于RFC6298和Linux 3.10)</a> </div> <footer class="post-footer"> <div class="post-eof"></div> </footer> </article> </div> <div class="post-block"> <article itemscope itemtype="http://schema.org/Article" class="post-content" lang=""> <link itemprop="mainEntityOfPage" href="https://plantegg.github.io/2016/08/24/Linux%20tc%20qdisc%E7%9A%84%E4%BD%BF%E7%94%A8%E6%A1%88%E4%BE%8B/"> <meta itemprop="image" content="/images/avatar.gif"> <meta itemprop="name" content="twitter @plantegg"> <meta itemprop="name" content="plantegg"> <meta itemprop="description" content="java mysql tcp performance network docker Linux"> <meta itemprop="name" content=" | plantegg"> <meta itemprop="description" content=""> <header class="post-header"> <h2 class="post-title" itemprop="name headline"> <a href="/2016/08/24/Linux%20tc%20qdisc%E7%9A%84%E4%BD%BF%E7%94%A8%E6%A1%88%E4%BE%8B/" class="post-title-link" itemprop="url">Linux tc qdisc的使用案例</a> </h2> <div class="post-meta-container"> <div class="post-meta"> 发表于 <time title="创建时间：2016-08-24 17:30:03" itemprop="dateCreated datePublished" datetime="2016-08-24T17:30:03+08:00">2016-08-24</time> 更新于 <time title="修改时间：2025-11-29 15:19:06" itemprop="dateModified" datetime="2025-11-29T15:19:06+08:00">2025-11-29</time> 分类于 <a href="/categories/Linux/" itemprop="url" rel="index">Linux</a> </div> </div> </header> <div class="post-body" itemprop="articleBody"> <h1 id="Linux-tc-qdisc的使用案例"><a href="#Linux-tc-qdisc的使用案例" class="headerlink" title="Linux tc qdisc的使用案例"></a>Linux tc qdisc的使用案例</h1>在linux下通过tc qdisc 很容易对rt延时、丢包、带宽进行控制，这样的话方便重现各种网络问题 <h2 id="延时"><a href="#延时" class="headerlink" title="延时"></a>延时</h2><figure class="highlight shell"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 </pre></td><td class="code"><pre>1. give packets from eth0 a delay of 2ms bash$ tc qdisc add dev eth0 root netem delay 2ms 2.change the delay to 300ms bash$ tc qdisc change dev eth0 root netem delay 3ms 3.display eth0 delay setting bash$ tc qdisc show dev eth0 4.stop the delay bash$ tc qdisc del dev eth0 root #corrupt The following rule corrupts 5% of the packets by introducing single bit error at a random offset in the packet: tc qdisc change dev eth0 root netem corrupt 5% </pre></td></tr></table></figure> <h2 id="模拟网络丢包"><a href="#模拟网络丢包" class="headerlink" title="模拟网络丢包"></a>模拟网络丢包</h2><figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 </pre></td><td class="code"><pre>tc qdisc add dev eth0 root netem loss 1% </pre></td></tr></table></figure> 指定ip 172.31.65.30延时17ms，测试发现181和183这两句命令顺序无所谓。恢复正常：179行命令 <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 </pre></td><td class="code"><pre>179 tc qdisc del dev eth0 root 180 tc qdisc add dev eth0 root handle 1: prio 181 tc filter add dev eth0 parent 1:0 protocol ip pref 55 handle ::55 u32 match ip dst 172.31.65.30 flowid 2:1 182 tc qdisc ls 183 tc qdisc add dev eth0 parent 1:1 handle 2: netem delay 17ms </pre></td></tr></table></figure> <h2 id="指定ip和端口延时"><a href="#指定ip和端口延时" class="headerlink" title="指定ip和端口延时"></a>指定ip和端口延时</h2>指定 eth0 网卡，来源 ip 是 10.0.1.1，目的端口是 3306 的访问延迟 20ms，上下浮动 2ms 100.100.146.3 <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 </pre></td><td class="code"><pre># 指定 eth0 网卡，来源 ip 是 10.0.1.1，目的端口是 3306 的访问延迟 20ms，上下浮动 2ms tc qdisc add dev eth0 root handle 1: prio bands 4 tc qdisc add dev eth0 parent 1:4 handle 40: netem delay 5ms 30ms tc filter add dev eth0 parent 1: protocol ip prio 4 basic match "cmp(u16 at 2 layer transport eq 80) and cmp(u8 at 16 layer network eq 100) and cmp(u8 at 17 layer network eq 100) and cmp(u8 at 18 layer network eq 146) and cmp(u8 at 19 layer network eq 3)" flowid 1:4 tc filter add dev eth0 parent 1: protocol ip prio 4 basic match "cmp(u8 at 16 layer network eq 100) and cmp(u8 at 17 layer network eq 100) and cmp(u8 at 18 layer network eq 61) and cmp(u8 at 19 layer network eq 88)" flowid 1:4 # 删除过滤 sudo tc filter del dev eth0 parent 1: prio 4 basic sudo tc qdisc del dev eth0 root </pre></td></tr></table></figure> 0 layer 代表 sport 2 layer 代表 dport <h2 id="指定端口34001上，延时5ms"><a href="#指定端口34001上，延时5ms" class="headerlink" title="指定端口34001上，延时5ms"></a>指定端口34001上，延时5ms</h2><figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 </pre></td><td class="code"><pre>tc qdisc add dev eth0 root handle 1: prio tc qdisc add dev eth0 parent 1:3 handle 30: netem delay 5ms tc filter add dev eth0 protocol ip parent 1:0 u32 match ip sport 34001 0xffff flowid 1:3 </pre></td></tr></table></figure> <h2 id="控制网卡的带宽、延时、乱序、丢包"><a href="#控制网卡的带宽、延时、乱序、丢包" class="headerlink" title="控制网卡的带宽、延时、乱序、丢包"></a>控制网卡的带宽、延时、乱序、丢包</h2><figure class="highlight shell"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 </pre></td><td class="code"><pre>sudo tc qdisc add dev bond0 root handle 1: netem delay 10ms reorder 25% 50% loss 0.2% sudo tc qdisc add dev bond0 parent 1: handle 2: tbf rate 1mbit burst 32kbit latency 10ms /sbin/tc qdisc add dev bond0 root tbf rate 500kbit latency 50ms burst 15kb // 同时模拟20Mbps带宽，50msRTT和0.1%丢包率 # tc qdisc add dev bond0 root handle 1:0 tbf rate 20mbit burst 10kb limit 300000 # tc qdisc add dev bond0 parent 1:0 handle 10:0 netem delay 50ms loss 0.1 limit 300000 tc qdisc change dev eth0 root netem reorder 50% gap 3 delay 1ms tc qdisc change dev eth0 root netem delay 1ms reorder 15% //在eth0上设置一个tbf队列，网络带宽为200kbit，延迟10ms以内，超出的包会被drop掉，缓冲区为1540个字节 sudo /sbin/tc qdisc add dev eth0 root tbf rate 200kbit latency 10ms burst 15kb sudo /sbin/tc qdisc ls dev eth0 </pre></td></tr></table></figure> 在eth0上设置一个tbf队列，网络带宽为200kbit，延迟10ms以内，超出的包会被drop掉，缓冲区为1540个字节 <blockquote> rate表示令牌的产生速率, sustained maximum rate latency表示数据包在队列中的最长等待时间, packets with higher latency get dropped burst参数表示 maximum allowed burst： burst means the maximum amount of bytes that tokens can be available for instantaneously. 如果数据包的到达速率与令牌的产生速率一致，即200kbit，则数据不会排队，令牌也不会剩余 如果数据包的到达速率小于令牌的产生速率，则令牌会有一定的剩余。 如果后续某一会数据包的到达速率超过了令牌的产生速率，则可以一次性的消耗一定量的令牌。 burst就是用于限制这“一次性”消耗的令牌的数量的，以字节数为单位。 </blockquote> tbf: use the token buffer filter to manipulate traffic rates 限制10MB，排队等待超过100ms就触发丢包，只限制了出去的流量，没有限制进来的流量: <figure class="highlight shell"><table><tr><td class="gutter"><pre>1 2 3 4 5 </pre></td><td class="code"><pre>tc qdisc ls dev eth0 // 查看eth0上的队列规则 sudo tc qdisc add dev eth0 root tbf rate 80mbit burst 1mbit latency 100ms //限制80MB sudo tc qdisc add dev eth0 root tbf rate 80mbps burst 1mbps latency 100ms </pre></td></tr></table></figure> <h3 id="乱序"><a href="#乱序" class="headerlink" title="乱序"></a>乱序</h3><figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 </pre></td><td class="code"><pre>1001 [2024-08-08 15:12:01] sudo tc qdisc add dev bond0 root handle 1: prio 1004 [2024-08-08 15:12:44] sudo tc filter add dev bond0 parent 1: protocol ip prio 1 u32 match ip dst 1.2.3.7 flowid 1:1 1005 [2024-08-08 15:13:17] tc qdisc add dev bond0 parent 1:1 handle 10: netem delay 10ms reorder 5% 10% </pre></td></tr></table></figure> <h2 id="两地三中心模拟"><a href="#两地三中心模拟" class="headerlink" title="两地三中心模拟"></a>两地三中心模拟</h2>针对不同的ip地址可以限制不同的带宽和网络延时，htb较prio多了一个带宽控制 通过htb 只限制带宽和延时 <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 </pre></td><td class="code"><pre>//对10.0.3.228、229延时1ms，对 10.0.3.232延时30ms 两地三中心限制延时和带宽 tc qdisc add dev eth0 root handle 1: htb tc class add dev eth0 parent 1: classid 1:1 htb rate 600Gbps tc filter add dev eth0 parent 1: protocol ip prio 1 u32 flowid 1:1 match ip dst 10.0.3.228 tc qdisc add dev eth0 parent 1:1 handle 10: netem delay 1ms tc class add dev eth0 parent 1: classid 1:2 htb rate 600Gbps tc filter add dev eth0 parent 1: protocol ip prio 1 u32 flowid 1:2 match ip dst 10.0.3.229 tc qdisc add dev eth0 parent 1:2 handle 20: netem delay 1ms tc class add dev eth0 parent 1: classid 1:3 htb rate 600Gbps tc filter add dev eth0 parent 1: protocol ip prio 1 u32 flowid 1:3 match ip dst 10.0.3.232 tc qdisc add dev eth0 parent 1:3 handle 30: netem delay 30ms </pre></td></tr></table></figure> <img src="/images/951413iMgBlog/image-20230607152951762-3791233.png" alt="image-20230607152951762"> <img src="/images/951413iMgBlog/TX_path_tc_mqprio-1.png" alt="img"> 通过prio 只限制延时 <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 </pre></td><td class="code"><pre>//两地三中心限制不同的延时，htb 才可以加带宽限制 tc qdisc add dev eth0 root handle 1: prio //flowid 指定的是流量要去往的目标队列 //10.0.3.228/10.0.3.229 延时1ms tc filter add dev eth0 parent 1: protocol ip prio 1 u32 flowid 1:1 match ip dst 10.0.3.228/31 tc qdisc add dev eth0 parent 1:1 handle 10: netem delay 1ms //以上两行可以改成如下三行单独为 10.0.3.228 和 10.0.3.229 添加延时 1ms tc filter add dev eth0 parent 1: protocol ip prio 1 u32 flowid 1:1 match ip dst 10.0.3.228 tc filter add dev eth0 parent 1: protocol ip prio 1 u32 flowid 1:1 match ip dst 10.0.3.229 tc qdisc add dev eth0 parent 1:1 handle 10: netem delay 1ms //表示多条 filter 命中的流量都走这条 qdisc 规则 tc filter add dev eth0 parent 1: protocol ip prio 1 u32 flowid 1:2 match ip dst 10.0.3.232 tc qdisc add dev eth0 parent 1:2 handle 20: netem delay 30ms </pre></td></tr></table></figure> 对多个 ip 进行不同的时延控制： <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 </pre></td><td class="code"><pre>tc qdisc add dev bond0 root handle 1: prio tc qdisc add dev bond0 parent 1:1 handle 10: netem delay 30ms tc filter add dev bond0 protocol ip parent 1:0 prio 1 u32 match ip dst 100.1.2.3 flowid 1:1 tc qdisc add dev bond0 parent 1:2 handle 20: netem delay 30ms tc filter add dev bond0 protocol ip parent 1:0 prio 1 u32 match ip dst 11.1.2.3 flowid 1:2 //查看 tc qdisc show dev bond0 tc filter show dev bond0 </pre></td></tr></table></figure> <h2 id="qdisc的类别"><a href="#qdisc的类别" class="headerlink" title="qdisc的类别"></a><a target="_blank" rel="noopener" href="https://cloud.tencent.com/developer/article/1409664">qdisc的类别</a></h2>QDisc(排队规则)是queueing discipline的简写，它是理解流量控制(traffic control)的基础。无论何时，内核如果需要通过某个网络接口发送数据包，它都需要按照为这个接口配置的qdisc(排队规则)把数据包加入队列。然后，内核会尽可能多地从qdisc里面取出数据包，把它们交给网络适配器驱动模块。最简单的QDisc是pfifo它不对进入的数据包做任何的处理，数据包采用先入先出的方式通过队列。不过，它会保存网络接口一时无法处理的数据包。 一个网络接口上如果没有设置QDisc，pfifo_fast就作为缺省的QDisc。 CLASSFUL QDISC(分类QDisc)，可分类的qdisc包括： <ul> <li>CBQ： CBQ是Class Based Queueing(基于类别排队)的缩写。它实现了一个丰富的连接共享类别结构，既有限制(shaping)带宽的能力，也具有带宽优先级管理的能力。带宽限制是通过计算连接的空闲时间完成的。空闲时间的计算标准是数据包离队事件的频率和下层连接(数据链路层)的带宽。</li> <li>HTB： HTB是Hierarchy Token Bucket的缩写。通过在实践基础上的改进，它实现了一个丰富的连接共享类别体系。使用HTB可以很容易地保证每个类别的带宽，它也允许特定的类可以突破带宽上限，占用别的类的带宽。HTB可以通过TBF(Token Bucket Filter)实现带宽限制，也能够划分类别的优先级。</li> <li>PRIO： PRIO QDisc 不能限制带宽，因为属于不同类别的数据包是顺序离队的。使用PRIO QDisc可以很容易对流量进行优先级管理，只有属于高优先级类别的数据包全部发送完毕，才会发送属于低优先级类别的数据包。为了方便管理，需要使用iptables或者ipchains处理数据包的服务类型(Type Of Service,ToS)。</li> </ul> <h3 id="htb分类-qdisc"><a href="#htb分类-qdisc" class="headerlink" title="htb分类 qdisc"></a>htb分类 qdisc</h3>tbf 能对流量无差别控制，htb 可以进一步进行更精细的控制 <h4 id="针对IP、端口限速案例"><a href="#针对IP、端口限速案例" class="headerlink" title="针对IP、端口限速案例"></a>针对IP、端口限速案例</h4><figure class="highlight shell"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 </pre></td><td class="code"><pre>$cat qdisc_bw.sh #!/bin/bash #针对不同的ip进行限速 #清空原有规则 tc qdisc del dev eth0 root #创建根序列 tc qdisc add dev eth0 root handle 1: htb default 1 #创建一个主分类绑定所有带宽资源（60M） tc class add dev eth0 parent 1:0 classid 1:1 htb rate 60Mbps burst 15k #到这里可以使用了，整机速度限制到了60M #创建子分类，ceil表示最大带宽 tc class add dev eth0 parent 1:1 classid 1:10 htb rate 2Mbps ceil 1Mbps burst 15k tc class add dev eth0 parent 1:1 classid 1:20 htb rate 20Mbps ceil 30Mbps burst 15k #为了避免一个会话永占带宽,添加随即公平队列sfq. #perturb：是多少秒后重新配置一次散列算法，默认为10秒 #sfq,他可以防止一个段内的一个ip占用整个带宽 tc qdisc add dev eth0 parent 1:10 handle 10: sfq perturb 10 tc qdisc add dev eth0 parent 1:20 handle 20: sfq perturb 10 #创建过滤器 #对所有ip限速到1Mbps tc filter add dev eth0 protocol ip parent 1:0 prio 2 u32 match ip dst 0.0.0.0/0 flowid 1:10 #对10.0.186.140限速在30Mbps tc filter add dev eth0 protocol ip parent 1:0 prio 1 u32 match ip dst 10.0.186.140 flowid 1:20 #对端口进行filter限流 #tc filter add dev eth0 protocol ip parent 1:0 prio 1 u32 match ip sport 22 flowid 1:10 #查看以上规则 sudo tc class show dev eth0 sudo tc filter show dev eth0 </pre></td></tr></table></figure> 限流100MB后的实际监控效果 <img src="/images/951413iMgBlog/image-20211031205539407.png" alt="image-20211031205539407"> <h2 id="tc-qdisc-示例"><a href="#tc-qdisc-示例" class="headerlink" title="tc qdisc 示例"></a>tc qdisc 示例</h2>通过 Linux tc filter/qdisc 的代码来对 10.0.3.228/229/230/231 这四个 ip 分别增加 delay1/2/3/4 ms，带宽限制在 1Mb/2Mb/4Mb/8Mb <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 </pre></td><td class="code"><pre># 1. 首先在网卡上添加一个根队列规程(qdisc) tc qdisc add dev eth0 root handle 1: htb default 10 # 2. 创建主类 tc class add dev eth0 parent 1: classid 1:1 htb rate 100mbit # 3. 为每个 IP 创建子类并设置带宽 tc class add dev eth0 parent 1:1 classid 1:10 htb rate 1mbit tc class add dev eth0 parent 1:1 classid 1:20 htb rate 2mbit tc class add dev eth0 parent 1:1 classid 1:30 htb rate 4mbit tc class add dev eth0 parent 1:1 classid 1:40 htb rate 8mbit # 4. 为每个类添加延迟 tc qdisc add dev eth0 parent 1:10 handle 10: netem delay 1ms tc qdisc add dev eth0 parent 1:20 handle 20: netem delay 2ms tc qdisc add dev eth0 parent 1:30 handle 30: netem delay 3ms tc qdisc add dev eth0 parent 1:40 handle 40: netem delay 4ms # 5. 添加过滤规则，将不同 IP 的流量导向不同的类 tc filter add dev eth0 protocol ip parent 1: prio 1 u32 match ip dst 10.0.3.228/32 flowid 1:10 tc filter add dev eth0 protocol ip parent 1: prio 1 u32 match ip dst 10.0.3.229/32 flowid 1:20 tc filter add dev eth0 protocol ip parent 1: prio 1 u32 match ip dst 10.0.3.230/32 flowid 1:30 tc filter add dev eth0 protocol ip parent 1: prio 1 u32 match ip dst 10.0.3.231/32 flowid 1:40 </pre></td></tr></table></figure> 以上代码对应的层级结构： <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 </pre></td><td class="code"><pre>eth0 [root] └── 1: htb (根队列规程) └── 1:1 htb [rate 100mbit] (主类) ├── 1:10 htb [rate 1mbit] (子类) │ └── 10: netem [delay 1ms] │ └── filter: dst 10.0.3.228/32 │ ├── 1:20 htb [rate 2mbit] (子类) │ └── 20: netem [delay 2ms] │ └── filter: dst 10.0.3.229/32 │ ├── 1:30 htb [rate 4mbit] (子类) │ └── 30: netem [delay 3ms] │ └── filter: dst 10.0.3.230/32 │ └── 1:40 htb [rate 8mbit] (子类) └── 40: netem [delay 4ms] └── filter: dst 10.0.3.231/32 </pre></td></tr></table></figure> <h2 id="docker-中使用-tc"><a href="#docker-中使用-tc" class="headerlink" title="docker 中使用 tc"></a>docker 中使用 tc</h2>docker里无法使用的bug 可以参考 <a target="_blank" rel="noopener" href="https://bugzilla.redhat.com/show_bug.cgi?id=1152231%EF%BC%8C%E8%A7%A3%E5%86%B3%E6%96%B9%E6%B3%95%E5%B0%B1%E6%98%AF%E5%8D%87%E7%BA%A7tc%E7%89%88%E6%9C%AC%EF%BC%8Ctc">https://bugzilla.redhat.com/show_bug.cgi?id=1152231，解决方法就是升级tc版本，tc</a> qdisc add 时加上direct_qlen参数 <h3 id="场景："><a href="#场景：" class="headerlink" title="场景："></a>场景：</h3>故障注入的docker: 10.1.1.149 10.1.1.149上会模拟各种网络故障，但是中控机到该docker的连接需要不受影响 DEVICE_NAME=eth0 <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 </pre></td><td class="code"><pre># 根规则，direct_qlen 1000必须加，否则在docker的虚拟网络跑不了 tc qdisc add dev ${DEVICE_NAME} root handle 1: htb default 1024 direct_qlen 1000 # 建立两个类继承root tc class add dev ${DEVICE_NAME} parent 1:0 classid 1:1 htb rate 10000mbit tc class add dev ${DEVICE_NAME} parent 1:0 classid 1:2 htb rate 10000mbit #新版本的tc在filter设置完后，所有网络都会断，类似黑名单，需要加qdisc才能恢复, 所以先让两个通道都能跑 # 队列采用公平的调度算法，保证网络通畅，perturb参数是每隔10秒换一次hash，进一步保障平均 tc qdisc add dev ${DEVICE_NAME} parent 1:1 sfq perturb 10 tc qdisc add dev ${DEVICE_NAME} parent 1:2 sfq perturb 10 # 加过滤规则 #1.队列1是和跳板机交互的网络，需要保持通畅 tc filter add dev ${DEVICE_NAME} protocol ip parent 1: prio 10 u32 match ip dst 10.0.0.200/32 flowid 1:1 #2.其他所有主机走队列2，实现网络模拟 tc filter add dev ${DEVICE_NAME} protocol ip parent 1: prio 10 u32 match ip dst 0.0.0.0/0 flowid 1:2 #队列2 开始网络模拟 #该命令将${DEVICE_NAME}网卡的耗时随机delay 100ms，延迟的尖刺在标准值的正负30ms, 最后的百分比数字是尖刺的相关系数 # 这边用replace是因为之前已经用add加过规则了 tc qdisc replace dev ${DEVICE_NAME} parent 1:2 netem delay 100ms 30ms 25% #该命令将 ${DEVICE_NAME} 网卡的传输设置为随机丢掉10%的数据包, 成功率为50% tc qdisc replace dev ${DEVICE_NAME} parent 1:2 netem loss 10% 50% #该命令将 ${DEVICE_NAME} 网卡的传输设置为随机产生10%的重复数据包。 tc qdisc replace dev ${DEVICE_NAME} parent 1:2 netem duplicate 10% #该命令将 ${DEVICE_NAME} 网卡的传输设置为:有25%的数据包会被立即发送,其他的延迟10ms,相关性是10%,产生乱序 tc qdisc replace dev ${DEVICE_NAME} parent 1:2 netem delay 10ms reorder 25% 10% #该命令将 ${DEVICE_NAME} 网卡的传输设置为随机产生9%的损坏的数据包 tc qdisc replace dev ${DEVICE_NAME} parent 1:2 netem corrupt 9% </pre></td></tr></table></figure> 恢复网络 <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 </pre></td><td class="code"><pre>#让网络恢复正常 tc qdisc replace dev ${DEVICE_NAME} parent 1:2 sfq perturb 10 # =================== 查看规则 ====================== tc filter show dev ${DEVICE_NAME} tc class show dev ${DEVICE_NAME} tc qdisc show dev ${DEVICE_NAME} #====================== 清理 ====================== tc filter delete dev ${DEVICE_NAME} parent 1:0 protocol ip pref 10 tc qdisc del dev ${DEVICE_NAME} parent 1:2 netem tc class del dev ${DEVICE_NAME} parent 1:0 classid 1:2 tc class del dev ${DEVICE_NAME} parent 1:0 classid 1:1 tc qdisc del dev ${DEVICE_NAME} root handle 1 </pre></td></tr></table></figure> <h2 id="报错"><a href="#报错" class="headerlink" title="报错"></a>报错</h2><figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 </pre></td><td class="code"><pre>[root@iZj6c7oe1q6a7lz27e3m20Z ~]# tc qdisc show dev eth0 qdisc prio 1: root refcnt 9 bands 3 priomap 1 2 2 2 1 2 0 0 1 1 1 1 1 1 1 1 [root@iZj6c7oe1q6a7lz27e3m20Z ~]# tc qdisc add dev eth0 parent 1:3 handle 30: netem delay 5ms Error: Specified qdisc kind is unknown. #tc qdisc add dev eth0 root netem delay 2ms Error: Specified qdisc kind is unknown. </pre></td></tr></table></figure> 内核没有加载 sch_netem 模块导致，安装： <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 </pre></td><td class="code"><pre>sudo yum install -y kernel-modules-extra-`uname -r` 然后 modprobe sch_netem </pre></td></tr></table></figure> sch_netem 内核模块加载后就正常了 <h2 id="参考资料"><a href="#参考资料" class="headerlink" title="参考资料"></a>参考资料</h2><a target="_blank" rel="noopener" href="https://netbeez.net/blog/how-to-use-the-linux-traffic-control/">https://netbeez.net/blog/how-to-use-the-linux-traffic-control/</a> <a target="_blank" rel="noopener" href="https://bootlin.com/blog/multi-queue-improvements-in-linux-kernel-ethernet-mvneta/">https://bootlin.com/blog/multi-queue-improvements-in-linux-kernel-ethernet-mvneta/</a> </div> <footer class="post-footer"> <div class="post-eof"></div> </footer> </article> </div> <div class="post-block"> <article itemscope itemtype="http://schema.org/Article" class="post-content" lang=""> <link itemprop="mainEntityOfPage" href="https://plantegg.github.io/2016/03/24/ansible%20%E4%BD%BF%E7%94%A8%E6%89%8B%E5%86%8C/"> <meta itemprop="image" content="/images/avatar.gif"> <meta itemprop="name" content="twitter @plantegg"> <meta itemprop="name" content="plantegg"> <meta itemprop="description" content="java mysql tcp performance network docker Linux"> <meta itemprop="name" content=" | plantegg"> <meta itemprop="description" content=""> <header class="post-header"> <h2 class="post-title" itemprop="name headline"> <a href="/2016/03/24/ansible%20%E4%BD%BF%E7%94%A8%E6%89%8B%E5%86%8C/" class="post-title-link" itemprop="url">ansible 手册</a> </h2> <div class="post-meta-container"> <div class="post-meta"> 发表于 <time title="创建时间：2016-03-24 17:30:03" itemprop="dateCreated datePublished" datetime="2016-03-24T17:30:03+08:00">2016-03-24</time> 更新于 <time title="修改时间：2025-11-16 19:58:49" itemprop="dateModified" datetime="2025-11-16T19:58:49+08:00">2025-11-16</time> 分类于 <a href="/categories/Ansible/" itemprop="url" rel="index">Ansible</a> </div> </div> </header> <div class="post-body" itemprop="articleBody"> <h1 id="ansible-手册"><a href="#ansible-手册" class="headerlink" title="ansible 手册"></a>ansible 手册</h1><h2 id="获取模块信息"><a href="#获取模块信息" class="headerlink" title="获取模块信息"></a>获取模块信息</h2><ul> <li></li> </ul> 获取所有模块信息，100多个 <ul> <li>ansible-doc -l</li> </ul> 获取每个模块的具体信息 <ul> <li>ansible-doc example：ansible-doc ping PING A trivial test module, this module always returns <code>pong' on successful contact. It does not make sense in playbooks, but it is useful from </code>/usr/bin/udp’ EXAMPLES: Test ‘webservers’ status udp webservers -m ping </li> </ul> <h2 id="嵌套执行命令roles"><a href="#嵌套执行命令roles" class="headerlink" title="嵌套执行命令roles"></a>嵌套执行命令roles</h2><pre><code>- name: create jdk home file: path={{ remote_jdk_home }} state=directory mode=0755 - name: xxxxxxxxx include: ../../init/tasks/main.yml </code></pre> <h2 id="defaults-中变量定义"><a href="#defaults-中变量定义" class="headerlink" title="defaults 中变量定义"></a>defaults 中变量定义</h2><pre><code> 1：加双引号；2：变量名和变量之间，有空格； diamond_db_key: "{{ diamond_db_ip }}_{{ diamond_db_name }}_dbkey" manager_user1: "{{ manager_user_name }}" </code></pre> <h1 id="tags"><a href="#tags" class="headerlink" title="tags"></a>tags</h1>相同的tasks在不同的环境下面执行，通过tag来进行表面，如下图： <pre><code> useage: udp-playbook setup.yml -v -kK -i hosts.ini --tags "ta" - name: 1 authorized_key: user={{ ansible_ssh_user }} key="{{ lookup('file', '~/.ssh/id_rsa.pub') }}" state=present tags: ta - name: 2 group: name={{ remote_user }} tags: always - name: 3 file: path={{ remote_home }} owner={{ remote_user }} group={{ remote_user }} state=directory recurse=yes mode=0755 tags: tb </code></pre> <h2 id="常见错误"><a href="#常见错误" class="headerlink" title="常见错误"></a>常见错误</h2>ansible 中 scp scp: ambiguous target 错误还是因为ssh 增加了 -t 参数, scp不支持 -t 参数 <h2 id="disable-python-warning"><a href="#disable-python-warning" class="headerlink" title="disable python warning"></a><a target="_blank" rel="noopener" href="https://docs.ansible.com/ansible/latest/reference_appendices/interpreter_discovery.html">disable python warning</a></h2>To control the discovery behavior: <ul> <li>for individual hosts and groups, use the <code>ansible_python_interpreter</code> inventory variable</li> <li>globally, use the <code>interpreter_python</code> key in the <code>[defaults]</code> section of <code>ansible.cfg</code></li> </ul> <figure class="highlight shell"><table><tr><td class="gutter"><pre>1 2 </pre></td><td class="code"><pre>[defaults] interpreter_python=auto_silent </pre></td></tr></table></figure> </div> <footer class="post-footer"> <div class="post-eof"></div> </footer> </article> </div> <div class="post-block"> <article itemscope itemtype="http://schema.org/Article" class="post-content" lang=""> <link itemprop="mainEntityOfPage" href="https://plantegg.github.io/2016/03/24/ansible%20%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98/"> <meta itemprop="image" content="/images/avatar.gif"> <meta itemprop="name" content="twitter @plantegg"> <meta itemprop="name" content="plantegg"> <meta itemprop="description" content="java mysql tcp performance network docker Linux"> <meta itemprop="name" content=" | plantegg"> <meta itemprop="description" content=""> <header class="post-header"> <h2 class="post-title" itemprop="name headline"> <a href="/2016/03/24/ansible%20%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98/" class="post-title-link" itemprop="url">ansible 常见问题</a> </h2> <div class="post-meta-container"> <div class="post-meta"> 发表于 <time title="创建时间：2016-03-24 17:30:03" itemprop="dateCreated datePublished" datetime="2016-03-24T17:30:03+08:00">2016-03-24</time> 更新于 <time title="修改时间：2025-11-16 19:58:49" itemprop="dateModified" datetime="2025-11-16T19:58:49+08:00">2025-11-16</time> 分类于 <a href="/categories/Ansible/" itemprop="url" rel="index">Ansible</a> </div> </div> </header> <div class="post-body" itemprop="articleBody"> <h1 id="ansible-常见问题"><a href="#ansible-常见问题" class="headerlink" title="ansible 常见问题"></a>ansible 常见问题</h1><h2 id="获取模块信息"><a href="#获取模块信息" class="headerlink" title="获取模块信息"></a>获取模块信息</h2><ul> <li></li> </ul> 获取所有模块信息，100多个 <ul> <li>ansible-doc -l</li> </ul> 获取每个模块的具体信息 <ul> <li>ansible-doc example：ansible-doc ping PING A trivial test module, this module always returns <code>pong' on successful contact. It does not make sense in playbooks, but it is useful from </code>/usr/bin/udp’ EXAMPLES: Test ‘webservers’ status udp webservers -m ping </li> </ul> <h2 id="嵌套执行命令roles"><a href="#嵌套执行命令roles" class="headerlink" title="嵌套执行命令roles"></a>嵌套执行命令roles</h2><pre><code>- name: create jdk home file: path={{ remote_jdk_home }} state=directory mode=0755 - name: xxxxxxxxx include: ../../init/tasks/main.yml </code></pre> <h2 id="defaults-中变量定义"><a href="#defaults-中变量定义" class="headerlink" title="defaults 中变量定义"></a>defaults 中变量定义</h2><pre><code> 1：加双引号；2：变量名和变量之间，有空格； diamond_db_key: "{{ diamond_db_ip }}_{{ diamond_db_name }}_dbkey" manager_user1: "{{ manager_user_name }}" </code></pre> <h1 id="tags"><a href="#tags" class="headerlink" title="tags"></a>tags</h1>相同的tasks在不同的环境下面执行，通过tag来进行表面，如下图： <pre><code> useage: udp-playbook setup.yml -v -kK -i hosts.ini --tags "ta" - name: 1 authorized_key: user={{ ansible_ssh_user }} key="{{ lookup('file', '~/.ssh/id_rsa.pub') }}" state=present tags: ta - name: 2 group: name={{ remote_user }} tags: always - name: 3 file: path={{ remote_home }} owner={{ remote_user }} group={{ remote_user }} state=directory recurse=yes mode=0755 tags: tb </code></pre> <h2 id="常见错误"><a href="#常见错误" class="headerlink" title="常见错误"></a>常见错误</h2>ansible 中 scp scp: ambiguous target 错误还是因为ssh 增加了 -t 参数, scp不支持 -t 参数 <h2 id="disable-python-warning"><a href="#disable-python-warning" class="headerlink" title="disable python warning"></a><a target="_blank" rel="noopener" href="https://docs.ansible.com/ansible/latest/reference_appendices/interpreter_discovery.html">disable python warning</a></h2>To control the discovery behavior: <ul> <li>for individual hosts and groups, use the <code>ansible_python_interpreter</code> inventory variable</li> <li>globally, use the <code>interpreter_python</code> key in the <code>[defaults]</code> section of <code>ansible.cfg</code></li> </ul> <figure class="highlight shell"><table><tr><td class="gutter"><pre>1 2 </pre></td><td class="code"><pre>[defaults] interpreter_python=auto_silent </pre></td></tr></table></figure> <h3 id="其它常见错误"><a href="#其它常见错误" class="headerlink" title="其它常见错误"></a>其它常见错误</h3><table> <thead> <tr> <th>问题</th> <th>解决方案</th> </tr> </thead> <tbody><tr> <td>性能</td> <td>ansible现在并发执行的任务好像还不够，执行批量传大文件的任务等的比较久 — 用 synchronize 并将 fork 默认的5改大</td> </tr> <tr> <td>sudoers</td> <td>尝试解决ansible不能执行的问题，搜索各种英文文档，有人说版本的原因，有人反馈是脚本错误，最终无解。继续在本地进行测试，发现使用原始的ansible命令可以执行ls，但是sudo ls时会提示 sudo need tty 之类的报错。定位这个错误是因为在/etc/sudoers文件中设置了 Defaults requiretty，修改为 #Defaults requiretty，重试发现问题解决。手工修改所有机器的配置文件，问题解决。{“msg”: “ssh connection closed waiting for a privilege escalation password prompt”}—实际在部分机器上执行ansible命令时仍然有：sudo: no tty present and no askpass program specified 可以给ssh 增加-t/-tt参数来强制分配一个tty</td> </tr> <tr> <td>failed to transfer file to xxx</td> <td>远端机器磁盘已经满,查看df -h，特别是/tmp</td> </tr> <tr> <td>requires a json module, none found</td> <td>问题已经通过nginx进行解决部署,安装ansible的时候，在目标机器上面安装 python-simplejson 通过如下命令：yum install python-simplejson -y</td> </tr> <tr> <td>openssh升级后无法登录报错</td> <td>sshrpm 升级后会修改/etc/pam.d/sshd 文件。需要升级前备份此文件最后还原即可登录。</td> </tr> <tr> <td>安装EagleEye出现的问题</td> <td>1.hadoop name -format 这个需要输入Y/N；2.ssh-key没搞定；3.我们原来可以for循环的地方，古谦脚本只能1条1条的加</td> </tr> <tr> <td>使用lineinfile方法时，内容不能包含”: “(冒号+空格)，这个与ansible底层的分隔符冲突；</td> <td>让用户在内容中不要包含”: “</td> </tr> <tr> <td>https 相关</td> <td>SSL validation is not available in your version of python. You can use validate_certs=no, however this is unsafe and not recommended. You can also install python-ssl from EPEL</td> </tr> <tr> <td>You need a C++ compiler for C++ support</td> <td>yum install -y gcc gcc-c++</td> </tr> <tr> <td>１：udp权限问题，有时候会出现权限认证失败；２：udp如何执行本地命令；　３：udp线上有什么方便的安装方法</td> <td>问题1:方法一去掉sudo试试（报访问文件 /opt/aliUDP/logs/udp.log 失败，备份重新建一个udp.log 文件给于 777 权限）; 方法二指定 –private-key=PRIVATE_KEY_FILE （先试试直接ssh登录某台目标机器行不行）问题2：udp支持直接运行目标机器上的命令，用法：udp server -i ~/ali/udp-roles/roles/udp-install/udp-hosts.ini -m shell -a “ uptime ; df -lh “ -u admin</td> </tr> <tr> <td>同一个ip部署不同的工程时，定义的变量会冲突；例如ip1同时部署mysql和diamond，都定义project_name；这样上面的会生效，下面定义的会被冲掉</td> <td>Wiki：<a target="_blank" rel="noopener" href="http://gitlab.alibaba-inc.com/middleware-udp/udp-doc/wikis/Different_Hosts_With_Different_Variables">http://gitlab.alibaba-inc.com/middleware-udp/udp-doc/wikis/Different_Hosts_With_Different_Variables</a> 将变量分别定义在 ./roles/mysql/defaults/main.yml 和 ./roles/diamond/defaults/main.yml中或者使用不同的变量名</td> </tr> <tr> <td>执行udp-play-book 时会报找不到key的问题</td> <td>在udp机器上执行 ssh-keygen 来生成key，解决</td> </tr> <tr> <td>ssh 的时候需要手工 yes/no</td> <td>增加参数 -o StrictHostKeyChecking no 就不需要输入了</td> </tr> <tr> <td>防火墙问题，本地可以访问，远程不能</td> <td>通过抓包/telnet等方式来确认这个问题，通过iptables stop 来临时关闭防火墙；修改iptables 的配置永久关闭或者增加所有其它节点到白名单中</td> </tr> <tr> <td></td> <td>重要！ hostname -i 一定要是本机在局域网内的真实ip地址（不是127.0.0.1 ）。要绑定etc/hosts 下面把自己的hostname绑定到对应的真实ip上。</td> </tr> <tr> <td>在UDP PlayBook中如何定义不同的机器、不同的Role使用不同的变量</td> <td><a target="_blank" rel="noopener" href="http://gitlab.alibaba-inc.com/middleware-udp/udp-doc/wikis/Different_Hosts_With_Different_Variables">http://gitlab.alibaba-inc.com/middleware-udp/udp-doc/wikis/Different_Hosts_With_Different_Variables</a></td> </tr> <tr> <td>Dauth部署问题总结</td> <td><a target="_blank" rel="noopener" href="http://gitlab.alibaba-inc.com/middleware-udp/udp-doc/wikis/Dauth-UDP-deployment-issues">http://gitlab.alibaba-inc.com/middleware-udp/udp-doc/wikis/Dauth-UDP-deployment-issues</a></td> </tr> <tr> <td>Device or resource busy</td> <td>一般出现在Docker中修改/etc/hosts会有这个问题，ansible会rm它，实际它是-v进去的，通过脚本补丁绕过去</td> </tr> </tbody></table> ansible 中 scp scp: ambiguous target 错误还是因为ssh 增加了 -t 参数, scp不支持 -t 参数 </div> <footer class="post-footer"> <div class="post-eof"></div> </footer> </article> </div> <div class="post-block"> <article itemscope itemtype="http://schema.org/Article" class="post-content" lang=""> <link itemprop="mainEntityOfPage" href="https://plantegg.github.io/2016/03/24/ansible%20%E5%91%BD%E4%BB%A4%E9%80%9A%E9%81%93%E4%BD%BF%E7%94%A8%E6%89%8B%E5%86%8C/"> <meta itemprop="image" content="/images/avatar.gif"> <meta itemprop="name" content="twitter @plantegg"> <meta itemprop="name" content="plantegg"> <meta itemprop="description" content="java mysql tcp performance network docker Linux"> <meta itemprop="name" content=" | plantegg"> <meta itemprop="description" content=""> <header class="post-header"> <h2 class="post-title" itemprop="name headline"> <a href="/2016/03/24/ansible%20%E5%91%BD%E4%BB%A4%E9%80%9A%E9%81%93%E4%BD%BF%E7%94%A8%E6%89%8B%E5%86%8C/" class="post-title-link" itemprop="url">ansible 命令使用手册</a> </h2> <div class="post-meta-container"> <div class="post-meta"> 发表于 <time title="创建时间：2016-03-24 17:30:03" itemprop="dateCreated datePublished" datetime="2016-03-24T17:30:03+08:00">2016-03-24</time> 更新于 <time title="修改时间：2025-11-29 15:11:18" itemprop="dateModified" datetime="2025-11-29T15:11:18+08:00">2025-11-29</time> 分类于 <a href="/categories/Ansible/" itemprop="url" rel="index">Ansible</a> </div> </div> </header> <div class="post-body" itemprop="articleBody"> <h1 id="ansible-命令使用手册"><a href="#ansible-命令使用手册" class="headerlink" title="ansible 命令使用手册"></a>ansible 命令使用手册</h1><h2 id="什么是命令通道？"><a href="#什么是命令通道？" class="headerlink" title="什么是命令通道？"></a>什么是命令通道？</h2>有时候一些简单任务，没必要写复杂的playbook，所以大多时候我们可以通过ansible命令行来批量操控目标机器 <blockquote> 当我们需要批量操作、查看一组机器，或者在这些机器上批量执行某个命令、修改某个文件，都可以通过命令通道在一台机器上批量并发完成对所有机器的操作 命令通道只是一个帮你将命令发送到多个目标机器，并将执行结果返回来给你的一个执行通道 </blockquote> <h2 id="使用场景"><a href="#使用场景" class="headerlink" title="使用场景"></a>使用场景</h2><ul> <li>执行一行命令就能看到几十台机器的负载情况</li> <li>批量执行远程服务器上已经写好的Shell脚本</li> <li>查看所有Web服务器最近10000行Log中有没有ERROR</li> <li>查看所有DB服务器的内存使用情况</li> <li>批量将所有Diamond服务器的某个端口从7000改成9000</li> </ul> <h2 id="开始准备"><a href="#开始准备" class="headerlink" title="开始准备"></a>开始准备</h2><blockquote> 如果不想每次输入ssh密码的话请提前将本地公钥(~/.ssh/id_rsa.pub 没有的话 ssh-keygen生成一对)复制到目标机器的 ~/.ssh/authorized_keys 里面，否则每次执行命令都要输入密码 </blockquote> <h3 id="编写一个-hosts-ini-配置文件，内容如下"><a href="#编写一个-hosts-ini-配置文件，内容如下" class="headerlink" title="编写一个 hosts.ini 配置文件，内容如下:"></a>编写一个 hosts.ini 配置文件，内容如下:</h3><figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 </pre></td><td class="code"><pre>[server] 10.125.0.169 ansible_ssh_port=9999 #如果只有这台机器ssh走的是9999端口，其它没有设置的还是默认22端口 10.125.3.33 120.26.116.193 [worker] 10.125.12.174 10.125.14.238 [target] 10.125.192.40 10.125.7.151 192.168.2.[101:107] </pre></td></tr></table></figure> server/worker/target表示将7台机器分成了三组，可以到所有7台机器执行同一个命令，也可以只在server/worker/target中的一组机器上执行某个命令.all代表所有7台机器 <h2 id="运行命令行"><a href="#运行命令行" class="headerlink" title="运行命令行"></a>运行命令行</h2><h3 id="查看-hosts-ini-里面所有服务器的-uptime"><a href="#查看-hosts-ini-里面所有服务器的-uptime" class="headerlink" title="查看 hosts.ini 里面所有服务器的 uptime"></a>查看 hosts.ini 里面所有服务器的 uptime</h3><pre><code><figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 </pre></td><td class="code"><pre> $ ansible -i hosts.ini all -m raw -a " uptime " -u admin /usr/bin/ansible -i hosts.ini all -m raw -a uptime -u admin success => 10.125.12.174 => rc=0 => 11:10:50 up 27 days, 15:40, 1 user, load average: 0.05, 0.03, 0.05 success => 120.26.116.193 => rc=0 => 11:10:50 up 13 days, 21:07, 1 user, load average: 0.00, 0.00, 0.00 命令参数说明 > __all:__ 表示对hosts.ini里面的所有服务器执行后面的命令 > __-i:__ 指定hosts.ini文件所在的位置 > __-m raw -a:__ 指定需要执行的命令 > __" uptime "__ 双引号里面写上需要执行的命令 > __-u admin__ 表示通过用户名admin 去执行命令【如果没有做好免密码，请加上 -k 参数，会出来提示输入SSH密码】 ### 查看 hosts.ini 里面 server 组服务器的 home目录下的文件结构 $ ansible -i hosts.ini server -m raw -a " ls -lh ~/ " -u admin /usr/bin/ansible -i hosts.ini server -m raw -a ls -lh ~/ -u admin success => 10.125.0.169 => rc=0 => total 12K drwxr-xr-x 2 root root 4.0K Nov 13 12:34 files drwxr-xr-x 11 admin admin 4.0K Oct 20 10:49 tomcat drwxr-xr-x 3 test games 4.0K Nov 18 15:40 ansible-engine success => 10.125.3.33 => rc=0 => total 20K -rw------- 1 admin admin 1.4K Nov 12 13:39 authorized_keys drwxr-xr-x 2 root root 4.0K Nov 12 16:24 engine drwxr-xr-x 2 root root 4.0K Nov 13 12:22 files drwxr-xr-x 11 admin admin 4.0K Nov 18 15:43 tomcat drwxr-xr-x 3 test games 4.0K Nov 18 15:40 ansible-engine ### 查看部分机器 hostname </pre></td></tr></table></figure> </code></pre> <h1 id="ansible-i-ccb-test-ini-192-168-2-10-m-shell-a-‘hostname-‘"><a href="#ansible-i-ccb-test-ini-192-168-2-10-m-shell-a-‘hostname-‘" class="headerlink" title="ansible -i ccb_test.ini 192.168.2.10* -m shell -a ‘hostname ‘"></a>ansible -i ccb_test.ini 192.168.2.10* -m shell -a ‘hostname ‘</h1>[WARNING]: Invalid characters were found in group names but not replaced, use -vvvv to see details 192.168.2.100 | CHANGED | rc=0 >> az2-drds-100 192.168.2.106 | CHANGED | rc=0 >> az2-manager-106 192.168.2.101 | CHANGED | rc=0 >> az2-alisql-101 192.168.2.102 | CHANGED | rc=0 >> az2-alisql-102 192.168.2.105 | CHANGED | rc=0 >> az2-alisql-105 192.168.2.104 | CHANGED | rc=0 >> az2-alisql-104 192.168.2.103 | CHANGED | rc=0 >> az2-alisql-103 192.168.2.107 | CHANGED | rc=0 >> az2-manager-107 <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 </pre></td><td class="code"><pre> ### 使用环境变量 </pre></td></tr></table></figure> #config /etc/hosts ansible -i $1 all -m shell -a “ sed -i ‘/registry/d’ /etc/hosts “ ansible -i $1 all -m shell -a “ echo ‘ registry’ >/etc/hosts “ ansible -i $1 all -m shell -a “ echo ‘ <code>hostname</code>‘ >>/etc/hosts “ ansible -i $1 diamond -m shell -a “ echo ‘ jmenv.tbsite.net’ >> /etc/hosts “ -u root //修改机器hostname ansible -i $1 all -m shell -a “ hostnamectl set-hostname=’drds-‘ “ -u root //修改机器hostname -i ansible -i $1 all -m shell -a “ echo ‘ drds-‘ >> /etc/hosts “ -u root //hostname 修改机器名 <h1 id="ansible-i-ccb-test-ini-192-168-2-101-m-hostname-a-“-name-az2-alisql-101-“"><a href="#ansible-i-ccb-test-ini-192-168-2-101-m-hostname-a-“-name-az2-alisql-101-“" class="headerlink" title="ansible -i ccb_test.ini 192.168.2.101 -m hostname -a “ name=az2-alisql-101 “"></a>ansible -i ccb_test.ini 192.168.2.101 -m hostname -a “ name=az2-alisql-101 “</h1>[WARNING]: Invalid characters were found in group names but not replaced, use -vvvv to see details 192.168.2.101 | CHANGED => { “ansible_facts”: { “ansible_domain”: “”, “ansible_fqdn”: “iZ2ze9aj0re2ggbqa4dgxkZ”, “ansible_hostname”: “az2-alisql-101”, “ansible_nodename”: “az2-alisql-101”, “discovered_interpreter_python”: “/usr/bin/python” }, “changed”: true, “name”: “az2-alisql-101” } <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 </pre></td><td class="code"><pre> ### 管理系统service 设置 docker daemon服务重新启动和开机自动启动 </pre></td></tr></table></figure> <h1 id="ansible-i-ccb-test-ini-192-168-2-101-m-service-a-“-name-docker-enabled-yes-state-restarted-“"><a href="#ansible-i-ccb-test-ini-192-168-2-101-m-service-a-“-name-docker-enabled-yes-state-restarted-“" class="headerlink" title="ansible -i ccb_test.ini 192.168.2.101 -m service -a “ name=docker enabled=yes state=restarted “"></a>ansible -i ccb_test.ini 192.168.2.101 -m service -a “ name=docker enabled=yes state=restarted “</h1>[WARNING]: Invalid characters were found in group names but not replaced, use -vvvv to see details 192.168.2.101 | CHANGED => { “ansible_facts”: { “discovered_interpreter_python”: “/usr/bin/python” }, “changed”: true, “enabled”: true, “name”: “docker”, “state”: “started”, “status”: { “ActiveEnterTimestamp”: “二 2020-05-12 19:03:57 CST”, “ActiveEnterTimestampMonotonic”: “1553024093129”, “ActiveExitTimestamp”: “二 2020-05-12 19:01:24 CST”, “ActiveExitTimestampMonotonic”: “1552870910912”, “ActiveState”: “active”, “After”: “systemd-journald.socket system.slice docker.socket firewalld.service containerd.service network-online.target basic.target”, “AllowIsolate”: “no”, “AmbientCapabilities”: “0”, “AssertResult”: “yes”, “AssertTimestamp”: “二 2020-05-12 19:03:57 CST”, “AssertTimestampMonotonic”: “1553023902297”, “Before”: “multi-user.target shutdown.target”, “BindsTo”: “containerd.service”, “BlockIOAccounting”: “no”, “BlockIOWeight”: “18446744073709551615”, “CPUAccounting”: “no”, “CPUQuotaPerSecUSec”: “infinity”, “CPUSchedulingPolicy”: “0”, “CPUSchedulingPriority”: “0”, “CPUSchedulingResetOnFork”: “no”, “CPUShares”: “18446744073709551615”, “CanIsolate”: “no”, “CanReload”: “yes”, “CanStart”: “yes”, “CanStop”: “yes”, “CapabilityBoundingSet”: “18446744073709551615”, “ConditionResult”: “yes”, “ConditionTimestamp”: “二 2020-05-12 19:03:57 CST”, “ConditionTimestampMonotonic”: “1553023902297”, “Conflicts”: “shutdown.target”, “ConsistsOf”: “docker.socket”, “ControlGroup”: “/system.slice/docker.service”, “ControlPID”: “0”, “DefaultDependencies”: “yes”, “Delegate”: “yes”, “Description”: “Docker Application Container Engine”, “DevicePolicy”: “auto”, “Documentation”: “<a target="_blank" rel="noopener" href="https://docs.docker.com/">https://docs.docker.com</a>“, “ExecMainCode”: “0”, “ExecMainExitTimestampMonotonic”: “0”, “ExecMainPID”: “16213”, “ExecMainStartTimestamp”: “二 2020-05-12 19:03:57 CST”, “ExecMainStartTimestampMonotonic”: “1553023907468”, “ExecMainStatus”: “0”, “ExecReload”: “{ path=/bin/kill ; argv[]=/bin/kill -s HUP $MAINPID ; ignore_errors=no ; start_time=[n/a] ; stop_time=[n/a] ; pid=0 ; code=(null) ; status=0/0 }”, “ExecStart”: “{ path=/usr/bin/dockerd ; argv[]=/usr/bin/dockerd -H fd:// -H tcp://0.0.0.0:2376 –data-root=/var/lib/docker –log-opt max-size=50m –log-opt max-file=3 –registry-mirror=<a target="_blank" rel="noopener" href="https://oqpc6eum.mirror.aliyuncs.com/">https://oqpc6eum.mirror.aliyuncs.com</a> –containerd=/run/containerd/containerd.sock ; ignore_errors=no ; start_time=[n/a] ; stop_time=[n/a] ; pid=0 ; code=(null) ; status=0/0 }”, “FailureAction”: “none”, “FileDescriptorStoreMax”: “0”, “FragmentPath”: “/usr/lib/systemd/system/docker.service”, “GuessMainPID”: “yes”, “IOScheduling”: “0”, “Id”: “docker.service”, “IgnoreOnIsolate”: “no”, “IgnoreOnSnapshot”: “no”, “IgnoreSIGPIPE”: “yes”, “InactiveEnterTimestamp”: “二 2020-05-12 19:03:43 CST”, “InactiveEnterTimestampMonotonic”: “1553009791884”, “InactiveExitTimestamp”: “二 2020-05-12 19:03:57 CST”, “InactiveExitTimestampMonotonic”: “1553023907496”, “JobTimeoutAction”: “none”, “JobTimeoutUSec”: “0”, “KillMode”: “process”, “KillSignal”: “15”, “LimitAS”: “18446744073709551615”, “LimitCORE”: “18446744073709551615”, “LimitCPU”: “18446744073709551615”, “LimitDATA”: “18446744073709551615”, “LimitFSIZE”: “18446744073709551615”, “LimitLOCKS”: “18446744073709551615”, “LimitMEMLOCK”: “65536”, “LimitMSGQUEUE”: “819200”, “LimitNICE”: “0”, “LimitNOFILE”: “18446744073709551615”, “LimitNPROC”: “18446744073709551615”, “LimitRSS”: “18446744073709551615”, “LimitRTPRIO”: “0”, “LimitRTTIME”: “18446744073709551615”, “LimitSIGPENDING”: “379870”, “LimitSTACK”: “18446744073709551615”, “LoadState”: “loaded”, “MainPID”: “16213”, “MemoryAccounting”: “no”, “MemoryCurrent”: “58327040”, “MemoryLimit”: “18446744073709551615”, “MountFlags”: “0”, “Names”: “docker.service”, “NeedDaemonReload”: “no”, “Nice”: “0”, “NoNewPrivileges”: “no”, “NonBlocking”: “no”, “NotifyAccess”: “main”, “OOMScoreAdjust”: “0”, “OnFailureJobMode”: “replace”, “PermissionsStartOnly”: “no”, “PrivateDevices”: “no”, “PrivateNetwork”: “no”, “PrivateTmp”: “no”, “ProtectHome”: “no”, “ProtectSystem”: “no”, “RefuseManualStart”: “no”, “RefuseManualStop”: “no”, “RemainAfterExit”: “no”, “Requires”: “docker.socket basic.target”, “Restart”: “always”, “RestartUSec”: “2s”, “Result”: “success”, “RootDirectoryStartOnly”: “no”, “RuntimeDirectoryMode”: “0755”, “SameProcessGroup”: “no”, “SecureBits”: “0”, “SendSIGHUP”: “no”, “SendSIGKILL”: “yes”, “Slice”: “system.slice”, “StandardError”: “inherit”, “StandardInput”: “null”, “StandardOutput”: “journal”, “StartLimitAction”: “none”, “StartLimitBurst”: “3”, “StartLimitInterval”: “60000000”, “StartupBlockIOWeight”: “18446744073709551615”, “StartupCPUShares”: “18446744073709551615”, “StatusErrno”: “0”, “StopWhenUnneeded”: “no”, “SubState”: “running”, “SyslogLevelPrefix”: “yes”, “SyslogPriority”: “30”, “SystemCallErrorNumber”: “0”, “TTYReset”: “no”, “TTYVHangup”: “no”, “TTYVTDisallocate”: “no”, “TasksAccounting”: “no”, “TasksCurrent”: “58”, “TasksMax”: “18446744073709551615”, “TimeoutStartUSec”: “0”, “TimeoutStopUSec”: “0”, “TimerSlackNSec”: “50000”, “Transient”: “no”, “TriggeredBy”: “docker.socket”, “Type”: “notify”, “UMask”: “0022”, “UnitFilePreset”: “disabled”, “UnitFileState”: “enabled”, “WantedBy”: “multi-user.target”, “Wants”: “network-online.target system.slice”, “WatchdogTimestamp”: “二 2020-05-12 19:03:57 CST”, “WatchdogTimestampMonotonic”: “1553024093096”, “WatchdogUSec”: “0” } } <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 </pre></td><td class="code"><pre> ### 一次执行多个命令 </pre></td></tr></table></figure> $ ansible -i hosts.ini server -m raw -a “ which nc ; find /opt/aliUDP/logs/ “ -u admin /usr/bin/ansible -i hosts.ini server -m raw -a which nc ; find /opt/aliUDP/logs/ -u admin FAILED => 120.26.116.193 => rc=1 => which: no nc in (/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin) find: /opt/aliUDP: No such file or directory success => 10.125.3.33 => rc=0 => /usr/bin/nc /opt/aliUDP/logs/ /opt/aliUDP/logs/ansible.log.bak /opt/aliUDP/logs/ansible.log success => 10.125.0.169 => rc=0 => /usr/bin/nc /opt/aliUDP/logs/ /opt/aliUDP/logs/ansible.log.bak /opt/aliUDP/logs/ansible.log <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 </pre></td><td class="code"><pre> 结果说明 > 其中 120.26.116.193 上没有命令 nc 和 /opt/aliUDP 文件夹所有执行失败，但是其他两台机器都正常返回了结果 ### Copy本地的某个文件到服务器上【前面的例子中都是单独在远程机器上执行的命令】 </pre></td></tr></table></figure> $ ansible -i hosts.ini server -m copy -a “ src=’~/.ssh/id_rsa.pub’ dest=’/tmp/‘ owner=admin “ -u admin SUCCESS => 120.26.116.193 => { “changed”: true, “checksum”: “b12ccf236ab788bbaebd7159c563e97411389c9e”, “dest”: “/tmp/id_rsa.pub”, “gid”: 0, “group”: “root”, “md5sum”: “b6ba28284ab95aaa0f47602bdab49f46”, “mode”: “0644”, “owner”: “root”, “size”: 392, “src”: “/root/.ansible/ansible-tmp-1449109886.94-70134064194486/source”, “state”: “file”, “uid”: 0 } SUCCESS => 10.125.0.169 => { “changed”: true, “checksum”: “b12ccf236ab788bbaebd7159c563e97411389c9e”, “dest”: “/tmp/id_rsa.pub”, “gid”: 500, “group”: “admin”, “md5sum”: “b6ba28284ab95aaa0f47602bdab49f46”, “mode”: “0664”, “owner”: “admin”, “size”: 392, “src”: “/home/admin/.ansible/ansible-tmp-1449109886.78-98797505042348/source”, “state”: “file”, “uid”: 500 } SUCCESS => 10.125.3.33 => { “changed”: true, “checksum”: “b12ccf236ab788bbaebd7159c563e97411389c9e”, “dest”: “/tmp/id_rsa.pub”, “gid”: 500, “group”: “admin”, “md5sum”: “b6ba28284ab95aaa0f47602bdab49f46”, “mode”: “0664”, “owner”: “admin”, “size”: 392, “src”: “/home/admin/.ansible/ansible-tmp-1449109886.81-269249309502640/source”, “state”: “file”, “uid”: 500 } <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 </pre></td><td class="code"><pre>参数说明 > __-m copy -a:__ 指定这是 **copy** 的命令 > > __" src='~/.ssh/id_rsa.pub' dest='/tmp/' "__ src表示本地文件 dest表示远程目标位置 ### 验证一下刚刚copy上去的文件的MD5值 </pre></td></tr></table></figure> $ ansible -i hosts.ini server -m command -a “ md5sum /tmp/id_rsa.pub “ -u admin success => 10.125.0.169 => rc=0 => b6ba28284ab95aaa0f47602bdab49f46 /tmp/id_rsa.pub success => 10.125.3.33 => rc=0 => b6ba28284ab95aaa0f47602bdab49f46 /tmp/id_rsa.pub success => 120.26.116.193 => rc=0 => b6ba28284ab95aaa0f47602bdab49f46 /tmp/id_rsa.pub <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 </pre></td><td class="code"><pre>结果说明 > md5都是b6ba28284ab95aaa0f47602bdab49f46 跟本地的一致，说明成功复制到目标机器了 ### 执行远程服务器上已经写好的Shell脚本 </pre></td></tr></table></figure> $ cat test.sh #/bin/sh ifconfig | grep ‘inet addr’ echo “————-“ uptime echo “————-“ date df -lh <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 </pre></td><td class="code"><pre>执行结果 ```shell $ ansible -i hosts.ini server -m command -a " sh /tmp/test.sh " -u admin /usr/bin/ansible -i hosts.ini server -m command -a sh /tmp/test.sh -u admin success => 10.125.3.33 =>rc=0 => inet addr:10.125.3.33 Bcast:10.125.15.255 Mask:255.255.240.0 inet addr:127.0.0.1 Mask:255.0.0.0 </pre></td></tr></table></figure> <h3 id="copy个人笔记本的公钥到服务器上，以后从笔记本登录服务器不再需要输入密码"><a href="#copy个人笔记本的公钥到服务器上，以后从笔记本登录服务器不再需要输入密码" class="headerlink" title="copy个人笔记本的公钥到服务器上，以后从笔记本登录服务器不再需要输入密码"></a>copy个人笔记本的公钥到服务器上，以后从笔记本登录服务器不再需要输入密码</h3><figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 </pre></td><td class="code"><pre>$ ansible -i ansible-hosts.ini all -m authorized_key -a " user=admin key=\"{{ lookup('file', '/tmp/id_rsa.pub') }} \" " -u admin -k </pre></td></tr></table></figure> <h3 id="Copying-files-between-different-folders-on-the-same-remote-machine"><a href="#Copying-files-between-different-folders-on-the-same-remote-machine" class="headerlink" title="Copying files between different folders on the same remote machine"></a>Copying files between different folders on the same remote machine</h3>You can also copy files between the various locations on the remote servers. You have to set the remote_src parameter to yes. The following example copies the hello6 file in the /tmp directory of the remote server and pastes it in the /etc/ directory. <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 </pre></td><td class="code"><pre>- hosts: blocks tasks: - name: Ansible copy files remote to remote copy: src: /tmp/hello6 dest: /etc remote_src: yes </pre></td></tr></table></figure> or: <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 </pre></td><td class="code"><pre>ansible blocks -m copy -a "src=/tmp/hello6 dest=/tmp/hello7etc remote_src=yes" -s -i inventory.ini </pre></td></tr></table></figure> <h3 id="效率更高的-copy：synchronize"><a href="#效率更高的-copy：synchronize" class="headerlink" title="效率更高的 copy：synchronize"></a>效率更高的 copy：synchronize</h3><figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 </pre></td><td class="code"><pre>ansible -i xty_172.ini all -m synchronize -a " src=/home/ren/docker.service dest=/usr/lib/systemd/system/docker.socket " -u root </pre></td></tr></table></figure> <h3 id="find-file"><a href="#find-file" class="headerlink" title="find_file"></a>find_file</h3><figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 </pre></td><td class="code"><pre>- hosts: all tasks: - name: find_file find: paths: /home/admin/.ssh/ patterns: "*.rsa" recurse: no register: file_name - name: copy_file fetch: src: "{{ item.path }}" dest: /tmp/sshbak/ flat: no with_items: "{{ file_name.files }}" </pre></td></tr></table></figure> test <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 </pre></td><td class="code"><pre>ansible-playbook -i 127.0.0.1, ./find_file.yaml </pre></td></tr></table></figure> <h3 id="不使用-hosts-ini文件，从命令行中传入目标机的-ip-列表"><a href="#不使用-hosts-ini文件，从命令行中传入目标机的-ip-列表" class="headerlink" title="不使用 hosts.ini文件，从命令行中传入目标机的 ip 列表"></a>不使用 hosts.ini文件，从命令行中传入目标机的 ip 列表</h3><figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 </pre></td><td class="code"><pre>$ ansible -i 10.125.0.169,10.125.192.40 all -e "ansible_ssh_port=22" -a "uptime" -u admin success => 10.125.192.40 => rc=0 => 12:31:50 up 48 days, 17:01, 0 users, load average: 0.13, 0.06, 0.05 success => 10.125.0.169 => rc=0 => 12:31:50 up 49 days, 2:25, 0 users, load average: 0.00, 0.01, 0.05 </pre></td></tr></table></figure> 执行说明 <blockquote> -i 后面带入ip列表，注意每个IP后面一定要有 “,” 分割开来，all 关键字也是必须的 </blockquote> <blockquote> -e 中ansible_ssh_port=22表示ssh使用22端口（默认），如果ssh使用9999端口在这里将22改成9999即可 </blockquote> <h3 id="使用root-sudo权限来执行命令"><a href="#使用root-sudo权限来执行命令" class="headerlink" title="使用root sudo权限来执行命令"></a>使用root sudo权限来执行命令</h3><figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 </pre></td><td class="code"><pre>ansible -i 10.125.6.93, all -m shell -a " ls -lh /home/admin/" -u admin --become-user=root --ask-become-pass --become-method=sudo --become -k </pre></td></tr></table></figure> <h3 id="给admin授权登录server不需要输入密码（也不知道admin的密码）"><a href="#给admin授权登录server不需要输入密码（也不知道admin的密码）" class="headerlink" title="给admin授权登录server不需要输入密码（也不知道admin的密码）"></a>给admin授权登录server不需要输入密码（也不知道admin的密码）</h3><figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 </pre></td><td class="code"><pre>通过 admin(已知密码) 以root 权限将本机pub key复制到server上的 /home/admin, 再通过admin账号登录server就不需要密码了： ansible -i 10.125.6.93, all -m authorized_key -a " user=admin key=\"{{ lookup('file', '/home/ren/.ssh/id_rsa.pub') }} \" " -u admin --become-user=root --ask-become-pass --become-method=sudo --become -k 不需要密码就可以执行： ansible -i 10.125.6.93, all -m shell -a " ls -lha /home/admin/ " -u admin </pre></td></tr></table></figure> <h3 id="fetch-将远程服务器上的public-key-读取到本地"><a href="#fetch-将远程服务器上的public-key-读取到本地" class="headerlink" title="fetch:将远程服务器上的public key 读取到本地"></a>fetch:将远程服务器上的public key 读取到本地</h3><figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 </pre></td><td class="code"><pre>ansible -i kfc.ini hadoop -m fetch -a " src=/home/admin/.ssh/id_rsa.pub dest=./test/ " -u admin find test/ -type f | xargs cat > ./authorized_keys #push all the public keys to the server ansible -i ~/ali/ansible-edas/kfc.ini hadoop -m copy -a " src=./authorized_keys dest=/home/admin/.ssh/authorized_keys mode=600 " -u admin </pre></td></tr></table></figure> 或者循环fetch： <figure class="highlight yaml"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 </pre></td><td class="code"><pre>$cat fetch.yaml - hosts: all tasks: - name: list the files in the folder #command: ls /u01/nmon/tpcc/ shell: (cd /remote; find . -maxdepth 1 -type f) | cut -d'/' -f2 register: dir_out - name: do the action fetch: src=/u01/nmon/tpcc/{{item}} dest=/home/aliyun/nmon_tpcc/ flat=no with_items: "{{dir_out.stdout_lines}}" </pre></td></tr></table></figure> 执行结果： <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 </pre></td><td class="code"><pre>$ansible-playbook -i /home/aliyun/all.ini fetch.yaml -u admin PLAY [all] ******************************************************************************************* TASK [Gathering Facts] ******************************************************************************* ok: [10.88.88.18] ok: [10.88.88.16] ok: [10.88.88.15] ok: [10.88.88.19] ok: [10.88.88.17] ok: [10.88.88.20] TASK [list the files in the folder] ****************************************************************** changed: [10.88.88.15] changed: [10.88.88.16] changed: [10.88.88.17] changed: [10.88.88.18] changed: [10.88.88.19] changed: [10.88.88.20] TASK [do the action] ********************************************************************************* changed: [10.88.88.15] => (item=uos15_200729_1108.nmon) changed: [10.88.88.18] => (item=uos18_200729_1107.nmon) changed: [10.88.88.16] => (item=uos16_200729_1106.nmon) changed: [10.88.88.19] => (item=adbpg2-PC_200729_1108.nmon) changed: [10.88.88.17] => (item=uos17_200729_1107.nmon) changed: [10.88.88.19] => (item=adbpg2-PC_200729_1936.nmon) changed: [10.88.88.20] => (item=adbpg-PC_200729_1110.nmon) PLAY RECAP ******************************************************************************************* 10.88.88.15 : ok=3 changed=2 unreachable=0 failed=0 10.88.88.16 : ok=3 changed=2 unreachable=0 failed=0 10.88.88.17 : ok=3 changed=2 unreachable=0 failed=0 10.88.88.18 : ok=3 changed=2 unreachable=0 failed=0 10.88.88.19 : ok=3 changed=2 unreachable=0 failed=0 10.88.88.20 : ok=3 changed=2 unreachable=0 failed=0 </pre></td></tr></table></figure> <h3 id="setup-获取机器配置、参数信息"><a href="#setup-获取机器配置、参数信息" class="headerlink" title="setup:获取机器配置、参数信息"></a>setup:获取机器配置、参数信息</h3><figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 </pre></td><td class="code"><pre># ansible -i 192.168.1.91, all -m setup -u admin 192.168.1.91 | SUCCESS => { "ansible_facts": { "ansible_all_ipv4_addresses": [ "172.17.0.1", "192.168.0.91", "192.168.1.91" ], "ansible_all_ipv6_addresses": [], "ansible_apparmor": { "status": "disabled" }, "ansible_architecture": "x86_64", "ansible_bios_date": "04/01/2014", "ansible_bios_version": "8c24b4c", "ansible_cmdline": { "BOOT_IMAGE": "/boot/vmlinuz-3.10.0-957.21.3.el7.x86_64", "LANG": "en_US.UTF-8", "biosdevname": "0", "console": "ttyS0,115200n8", "crashkernel": "auto", "idle": "halt", "net.ifnames": "0", "noibrs": true, "quiet": true, "rhgb": true, "ro": true, "root": "UUID=1114fe9e-2309-4580-b183-d778e6d97397" }, "ansible_date_time": { "date": "2020-07-15", "day": "15", "epoch": "1594796084", "hour": "14", "iso8601": "2020-07-15T06:54:44Z", "iso8601_basic": "20200715T145444643628", "iso8601_basic_short": "20200715T145444", "iso8601_micro": "2020-07-15T06:54:44.643725Z", "minute": "54", "month": "07", "second": "44", "time": "14:54:44", "tz": "CST", "tz_offset": "+0800", "weekday": "星期三", "weekday_number": "3", "weeknumber": "28", "year": "2020" }, "ansible_default_ipv4": { "address": "192.168.0.91", "alias": "eth0", "broadcast": "192.168.0.255", "gateway": "192.168.0.253", "interface": "eth0", "macaddress": "00:16:3e:30:d9:a4", "mtu": 1500, "netmask": "255.255.255.0", "network": "192.168.0.0", "type": "ether" }, "ansible_default_ipv6": {}, "ansible_device_links": { "ids": {}, "labels": { "loop2": [ "CDROM" ] }, "masters": {}, "uuids": { "loop0": [ "2020-07-12-14-26-47-00" ], "loop1": [ "2020-07-12-20-25-18-00" ], "loop2": [ "2020-07-13-09-57-36-00" ], "vda1": [ "1114fe9e-2309-4580-b183-d778e6d97397" ] } }, "ansible_devices": { "loop0": { "holders": [], "host": "", "links": { "ids": [], "labels": [], "masters": [], "uuids": [ "2020-07-12-14-26-47-00" ] }, "model": null, "partitions": {}, "removable": "0", "rotational": "1", "sas_address": null, "sas_device_handle": null, "scheduler_mode": "", "sectors": "327924", "sectorsize": "512", "size": "160.12 MB", "support_discard": "4096", "vendor": null, "virtual": 1 }, "loop1": { "holders": [], "host": "", "links": { "ids": [], "labels": [], "masters": [], "uuids": [ "2020-07-12-20-25-18-00" ] }, "model": null, "partitions": {}, "removable": "0", "rotational": "1", "sas_address": null, "sas_device_handle": null, "scheduler_mode": "", "sectors": "359172", "sectorsize": "512", "size": "175.38 MB", "support_discard": "4096", "vendor": null, "virtual": 1 }, "loop2": { "holders": [], "host": "", "links": { "ids": [], "labels": [ "CDROM" ], "masters": [], "uuids": [ "2020-07-13-09-57-36-00" ] }, "model": null, "partitions": {}, "removable": "0", "rotational": "1", "sas_address": null, "sas_device_handle": null, "scheduler_mode": "", "sectors": "128696", "sectorsize": "512", "size": "62.84 MB", "support_discard": "4096", "vendor": null, "virtual": 1 }, "vda": { "holders": [], "host": "SCSI storage controller: Red Hat, Inc. Virtio block device", "links": { "ids": [], "labels": [], "masters": [], "uuids": [] }, "model": null, "partitions": { "vda1": { "holders": [], "links": { "ids": [], "labels": [], "masters": [], "uuids": [ "1114fe9e-2309-4580-b183-d778e6d97397" ] }, "sectors": "838847992", "sectorsize": 512, "size": "399.99 GB", "start": "2048", "uuid": "1114fe9e-2309-4580-b183-d778e6d97397" } }, "removable": "0", "rotational": "1", "sas_address": null, "sas_device_handle": null, "scheduler_mode": "mq-deadline", "sectors": "838860800", "sectorsize": "512", "size": "400.00 GB", "support_discard": "0", "vendor": "0x1af4", "virtual": 1 } }, "ansible_distribution": "CentOS", "ansible_distribution_file_parsed": true, "ansible_distribution_file_path": "/etc/redhat-release", "ansible_distribution_file_variety": "RedHat", "ansible_distribution_major_version": "7", "ansible_distribution_release": "Core", "ansible_distribution_version": "7.8", "ansible_dns": { "nameservers": [ "100.100.2.136", "100.100.2.138" ], "options": { "attempts": "3", "rotate": true, "single-request-reopen": true, "timeout": "2" } }, "ansible_docker0": { "active": false, "device": "docker0", "features": { "busy_poll": "off [fixed]", "fcoe_mtu": "off [fixed]", "generic_receive_offload": "on", "generic_segmentation_offload": "on", "highdma": "on", "hw_tc_offload": "off [fixed]", "l2_fwd_offload": "off [fixed]", "large_receive_offload": "off [fixed]", "loopback": "off [fixed]", "netns_local": "on [fixed]", "ntuple_filters": "off [fixed]", "receive_hashing": "off [fixed]", "rx_all": "off [fixed]", "rx_checksumming": "off [fixed]", "rx_fcs": "off [fixed]", "rx_gro_hw": "off [fixed]", "rx_udp_tunnel_port_offload": "off [fixed]", "rx_vlan_filter": "off [fixed]", "rx_vlan_offload": "off [fixed]", "rx_vlan_stag_filter": "off [fixed]", "rx_vlan_stag_hw_parse": "off [fixed]", "scatter_gather": "on", "tcp_segmentation_offload": "on", "tx_checksum_fcoe_crc": "off [fixed]", "tx_checksum_ip_generic": "on", "tx_checksum_ipv4": "off [fixed]", "tx_checksum_ipv6": "off [fixed]", "tx_checksum_sctp": "off [fixed]", "tx_checksumming": "on", "tx_fcoe_segmentation": "on", "tx_gre_csum_segmentation": "on", "tx_gre_segmentation": "on", "tx_gso_partial": "on", "tx_gso_robust": "on", "tx_ipip_segmentation": "on", "tx_lockless": "on [fixed]", "tx_nocache_copy": "off", "tx_scatter_gather": "on", "tx_scatter_gather_fraglist": "on", "tx_sctp_segmentation": "on", "tx_sit_segmentation": "on", "tx_tcp6_segmentation": "on", "tx_tcp_ecn_segmentation": "on", "tx_tcp_mangleid_segmentation": "on", "tx_tcp_segmentation": "on", "tx_udp_tnl_csum_segmentation": "on", "tx_udp_tnl_segmentation": "on", "tx_vlan_offload": "on", "tx_vlan_stag_hw_insert": "on", "udp_fragmentation_offload": "on", "vlan_challenged": "off [fixed]" }, "hw_timestamp_filters": [], "id": "8000.0242e441b693", "interfaces": [], "ipv4": { "address": "172.17.0.1", "broadcast": "172.17.255.255", "netmask": "255.255.0.0", "network": "172.17.0.0" }, "macaddress": "02:42:e4:41:b6:93", "mtu": 1500, "promisc": false, "stp": false, "timestamping": [ "rx_software", "software" ], "type": "bridge" }, "ansible_domain": "", "ansible_effective_group_id": 1000, "ansible_effective_user_id": 1000, "ansible_env": { "HISTCONTROL": "erasedups", "HISTFILESIZE": "30000", "HISTIGNORE": "pwd:ls:cd:ll:", "HISTSIZE": "30000", "HISTTIMEFORMAT": "%d/%m/%y %T ", "HOME": "/home/admin", "JAVA_HOME": "/opt/taobao/java", "LANG": "C", "LC_ADDRESS": "zh_CN.UTF-8", "LC_ALL": "C", "LC_IDENTIFICATION": "zh_CN.UTF-8", "LC_MEASUREMENT": "zh_CN.UTF-8", "LC_MONETARY": "zh_CN.UTF-8", "LC_NAME": "zh_CN.UTF-8", "LC_NUMERIC": "C", "LC_PAPER": "zh_CN.UTF-8", "LC_TELEPHONE": "zh_CN.UTF-8", "LC_TIME": "zh_CN.UTF-8", "LESSOPEN": "||/usr/bin/lesspipe.sh %s", "LOGNAME": "admin", "MAIL": "/var/mail/admin", "PATH": "/usr/local/bin:/usr/bin:/opt/taobao/java8/bin:/home/admin/tools", "PROMPT_COMMAND": "history -a", "PS4": "+(${BASH_SOURCE}:${LINENO}): ${FUNCNAME[0]:+${FUNCNAME[0]}(): }", "PWD": "/home/admin", "SHELL": "/bin/bash", "SHLVL": "2", "SSH_CLIENT": "192.168.1.79 51412 22", "SSH_CONNECTION": "192.168.1.79 51412 192.168.1.91 22", "USER": "admin", "XDG_RUNTIME_DIR": "/run/user/1000", "XDG_SESSION_ID": "40120", "_": "/usr/bin/python" }, "ansible_eth0": { "active": true, "device": "eth0", "features": { "busy_poll": "off [fixed]", "fcoe_mtu": "off [fixed]", "generic_receive_offload": "on", "generic_segmentation_offload": "on", "highdma": "on [fixed]", "hw_tc_offload": "off [fixed]", "l2_fwd_offload": "off [fixed]", "large_receive_offload": "off [fixed]", "loopback": "off [fixed]", "netns_local": "off [fixed]", "ntuple_filters": "off [fixed]", "receive_hashing": "off [fixed]", "rx_all": "off [fixed]", "rx_checksumming": "on [fixed]", "rx_fcs": "off [fixed]", "rx_gro_hw": "off [fixed]", "rx_udp_tunnel_port_offload": "off [fixed]", "rx_vlan_filter": "off [fixed]", "rx_vlan_offload": "off [fixed]", "rx_vlan_stag_filter": "off [fixed]", "rx_vlan_stag_hw_parse": "off [fixed]", "scatter_gather": "on", "tcp_segmentation_offload": "on", "tx_checksum_fcoe_crc": "off [fixed]", "tx_checksum_ip_generic": "on", "tx_checksum_ipv4": "off [fixed]", "tx_checksum_ipv6": "off [fixed]", "tx_checksum_sctp": "off [fixed]", "tx_checksumming": "on", "tx_fcoe_segmentation": "off [fixed]", "tx_gre_csum_segmentation": "off [fixed]", "tx_gre_segmentation": "off [fixed]", "tx_gso_partial": "off [fixed]", "tx_gso_robust": "off [fixed]", "tx_ipip_segmentation": "off [fixed]", "tx_lockless": "off [fixed]", "tx_nocache_copy": "off", "tx_scatter_gather": "on", "tx_scatter_gather_fraglist": "off [fixed]", "tx_sctp_segmentation": "off [fixed]", "tx_sit_segmentation": "off [fixed]", "tx_tcp6_segmentation": "on", "tx_tcp_ecn_segmentation": "on", "tx_tcp_mangleid_segmentation": "off", "tx_tcp_segmentation": "on", "tx_udp_tnl_csum_segmentation": "off [fixed]", "tx_udp_tnl_segmentation": "off [fixed]", "tx_vlan_offload": "off [fixed]", "tx_vlan_stag_hw_insert": "off [fixed]", "udp_fragmentation_offload": "on", "vlan_challenged": "off [fixed]" }, "hw_timestamp_filters": [], "ipv4": { "address": "192.168.0.91", "broadcast": "192.168.0.255", "netmask": "255.255.255.0", "network": "192.168.0.0" }, "macaddress": "00:16:3e:30:d9:a4", "module": "virtio_net", "mtu": 1500, "pciid": "virtio2", "promisc": false, "timestamping": [ "rx_software", "software" ], "type": "ether" }, "ansible_eth1": { "active": true, "device": "eth1", "features": { "busy_poll": "off [fixed]", "fcoe_mtu": "off [fixed]", "generic_receive_offload": "on", "generic_segmentation_offload": "on", "highdma": "on [fixed]", "hw_tc_offload": "off [fixed]", "l2_fwd_offload": "off [fixed]", "large_receive_offload": "off [fixed]", "loopback": "off [fixed]", "netns_local": "off [fixed]", "ntuple_filters": "off [fixed]", "receive_hashing": "off [fixed]", "rx_all": "off [fixed]", "rx_checksumming": "on [fixed]", "rx_fcs": "off [fixed]", "rx_gro_hw": "off [fixed]", "rx_udp_tunnel_port_offload": "off [fixed]", "rx_vlan_filter": "off [fixed]", "rx_vlan_offload": "off [fixed]", "rx_vlan_stag_filter": "off [fixed]", "rx_vlan_stag_hw_parse": "off [fixed]", "scatter_gather": "on", "tcp_segmentation_offload": "on", "tx_checksum_fcoe_crc": "off [fixed]", "tx_checksum_ip_generic": "on", "tx_checksum_ipv4": "off [fixed]", "tx_checksum_ipv6": "off [fixed]", "tx_checksum_sctp": "off [fixed]", "tx_checksumming": "on", "tx_fcoe_segmentation": "off [fixed]", "tx_gre_csum_segmentation": "off [fixed]", "tx_gre_segmentation": "off [fixed]", "tx_gso_partial": "off [fixed]", "tx_gso_robust": "off [fixed]", "tx_ipip_segmentation": "off [fixed]", "tx_lockless": "off [fixed]", "tx_nocache_copy": "off", "tx_scatter_gather": "on", "tx_scatter_gather_fraglist": "off [fixed]", "tx_sctp_segmentation": "off [fixed]", "tx_sit_segmentation": "off [fixed]", "tx_tcp6_segmentation": "on", "tx_tcp_ecn_segmentation": "on", "tx_tcp_mangleid_segmentation": "off", "tx_tcp_segmentation": "on", "tx_udp_tnl_csum_segmentation": "off [fixed]", "tx_udp_tnl_segmentation": "off [fixed]", "tx_vlan_offload": "off [fixed]", "tx_vlan_stag_hw_insert": "off [fixed]", "udp_fragmentation_offload": "on", "vlan_challenged": "off [fixed]" }, "hw_timestamp_filters": [], "ipv4": { "address": "192.168.1.91", "broadcast": "192.168.1.255", "netmask": "255.255.255.0", "network": "192.168.1.0" }, "macaddress": "00:16:3e:2c:a2:c2", "module": "virtio_net", "mtu": 1500, "pciid": "virtio4", "promisc": false, "timestamping": [ "rx_software", "software" ], "type": "ether" }, "ansible_fibre_channel_wwn": [], "ansible_fips": false, "ansible_form_factor": "Other", "ansible_fqdn": "jtdb001", "ansible_hostname": "jtdb001", "ansible_hostnqn": "", "ansible_interfaces": [ "lo", "docker0", "eth1", "eth0" ], "ansible_is_chroot": false, "ansible_iscsi_iqn": "", "ansible_kernel": "3.10.0-957.21.3.el7.x86_64", "ansible_kernel_version": "#1 SMP Tue Jun 18 16:35:19 UTC 2019", "ansible_lo": { "active": true, "device": "lo", "features": { "busy_poll": "off [fixed]", "fcoe_mtu": "off [fixed]", "generic_receive_offload": "on", "generic_segmentation_offload": "on", "highdma": "on [fixed]", "hw_tc_offload": "off [fixed]", "l2_fwd_offload": "off [fixed]", "large_receive_offload": "off [fixed]", "loopback": "on [fixed]", "netns_local": "on [fixed]", "ntuple_filters": "off [fixed]", "receive_hashing": "off [fixed]", "rx_all": "off [fixed]", "rx_checksumming": "on [fixed]", "rx_fcs": "off [fixed]", "rx_gro_hw": "off [fixed]", "rx_udp_tunnel_port_offload": "off [fixed]", "rx_vlan_filter": "off [fixed]", "rx_vlan_offload": "off [fixed]", "rx_vlan_stag_filter": "off [fixed]", "rx_vlan_stag_hw_parse": "off [fixed]", "scatter_gather": "on", "tcp_segmentation_offload": "on", "tx_checksum_fcoe_crc": "off [fixed]", "tx_checksum_ip_generic": "on [fixed]", "tx_checksum_ipv4": "off [fixed]", "tx_checksum_ipv6": "off [fixed]", "tx_checksum_sctp": "on [fixed]", "tx_checksumming": "on", "tx_fcoe_segmentation": "off [fixed]", "tx_gre_csum_segmentation": "off [fixed]", "tx_gre_segmentation": "off [fixed]", "tx_gso_partial": "off [fixed]", "tx_gso_robust": "off [fixed]", "tx_ipip_segmentation": "off [fixed]", "tx_lockless": "on [fixed]", "tx_nocache_copy": "off [fixed]", "tx_scatter_gather": "on [fixed]", "tx_scatter_gather_fraglist": "on [fixed]", "tx_sctp_segmentation": "on", "tx_sit_segmentation": "off [fixed]", "tx_tcp6_segmentation": "on", "tx_tcp_ecn_segmentation": "on", "tx_tcp_mangleid_segmentation": "on", "tx_tcp_segmentation": "on", "tx_udp_tnl_csum_segmentation": "off [fixed]", "tx_udp_tnl_segmentation": "off [fixed]", "tx_vlan_offload": "off [fixed]", "tx_vlan_stag_hw_insert": "off [fixed]", "udp_fragmentation_offload": "on", "vlan_challenged": "on [fixed]" }, "hw_timestamp_filters": [], "ipv4": { "address": "127.0.0.1", "broadcast": "host", "netmask": "255.0.0.0", "network": "127.0.0.0" }, "mtu": 65536, "promisc": false, "timestamping": [ "rx_software", "software" ], "type": "loopback" }, "ansible_local": {}, "ansible_lsb": {}, "ansible_machine": "x86_64", "ansible_machine_id": "20190711105006363114529432776998", "ansible_memfree_mb": 33368, "ansible_memory_mb": { "nocache": { "free": 41285, "used": 6079 }, "real": { "free": 33368, "total": 47364, "used": 13996 }, "swap": { "cached": 0, "free": 0, "total": 0, "used": 0 } }, "ansible_memtotal_mb": 47364, "ansible_mounts": [ { "block_available": 0, "block_size": 2048, "block_total": 32174, "block_used": 32174, "device": "/dev/loop2", "fstype": "iso9660", "inode_available": 0, "inode_total": 0, "inode_used": 0, "mount": "/mnt/yum", "options": "ro,relatime", "size_available": 0, "size_total": 65892352, "uuid": "2020-07-13-09-57-36-00" }, { "block_available": 0, "block_size": 2048, "block_total": 81981, "block_used": 81981, "device": "/dev/loop0", "fstype": "iso9660", "inode_available": 0, "inode_total": 0, "inode_used": 0, "mount": "/mnt/iso", "options": "ro,relatime", "size_available": 0, "size_total": 167897088, "uuid": "2020-07-12-14-26-47-00" }, { "block_available": 0, "block_size": 2048, "block_total": 89793, "block_used": 89793, "device": "/dev/loop1", "fstype": "iso9660", "inode_available": 0, "inode_total": 0, "inode_used": 0, "mount": "/mnt/drds", "options": "ro,relatime", "size_available": 0, "size_total": 183896064, "uuid": "2020-07-12-20-25-18-00" }, { "block_available": 96685158, "block_size": 4096, "block_total": 103177963, "block_used": 6492805, "device": "/dev/vda1", "fstype": "ext4", "inode_available": 26110896, "inode_total": 26214400, "inode_used": 103504, "mount": "/", "options": "rw,relatime,data=ordered", "size_available": 396022407168, "size_total": 422616936448, "uuid": "1114fe9e-2309-4580-b183-d778e6d97397" } ], "ansible_nodename": "jtdb001", "ansible_os_family": "RedHat", "ansible_pkg_mgr": "yum", "ansible_proc_cmdline": { "BOOT_IMAGE": "/boot/vmlinuz-3.10.0-957.21.3.el7.x86_64", "LANG": "en_US.UTF-8", "biosdevname": "0", "console": [ "tty0", "ttyS0,115200n8" ], "crashkernel": "auto", "idle": "halt", "net.ifnames": "0", "noibrs": true, "quiet": true, "rhgb": true, "ro": true, "root": "UUID=1114fe9e-2309-4580-b183-d778e6d97397" }, "ansible_processor": [ "0", "GenuineIntel", "Intel(R) Xeon(R) Platinum 8269CY CPU @ 2.50GHz", "1", "GenuineIntel", "Intel(R) Xeon(R) Platinum 8269CY CPU @ 2.50GHz", "2", "GenuineIntel", "Intel(R) Xeon(R) Platinum 8269CY CPU @ 2.50GHz", "3", "GenuineIntel", "Intel(R) Xeon(R) Platinum 8269CY CPU @ 2.50GHz", "4", "GenuineIntel", "Intel(R) Xeon(R) Platinum 8269CY CPU @ 2.50GHz", "5", "GenuineIntel", "Intel(R) Xeon(R) Platinum 8269CY CPU @ 2.50GHz", "6", "GenuineIntel", "Intel(R) Xeon(R) Platinum 8269CY CPU @ 2.50GHz", "7", "GenuineIntel", "Intel(R) Xeon(R) Platinum 8269CY CPU @ 2.50GHz", "8", "GenuineIntel", "Intel(R) Xeon(R) Platinum 8269CY CPU @ 2.50GHz", "9", "GenuineIntel", "Intel(R) Xeon(R) Platinum 8269CY CPU @ 2.50GHz", "10", "GenuineIntel", "Intel(R) Xeon(R) Platinum 8269CY CPU @ 2.50GHz", "11", "GenuineIntel", "Intel(R) Xeon(R) Platinum 8269CY CPU @ 2.50GHz" ], "ansible_processor_cores": 6, "ansible_processor_count": 1, "ansible_processor_threads_per_core": 2, "ansible_processor_vcpus": 12, "ansible_product_name": "Alibaba Cloud ECS", "ansible_product_serial": "NA", "ansible_product_uuid": "NA", "ansible_product_version": "pc-i440fx-2.1", "ansible_python": { "executable": "/usr/bin/python", "has_sslcontext": true, "type": "CPython", "version": { "major": 2, "micro": 5, "minor": 7, "releaselevel": "final", "serial": 0 }, "version_info": [ 2, 7, 5, "final", 0 ] }, "ansible_python_version": "2.7.5", "ansible_real_group_id": 1000, "ansible_real_user_id": 1000, "ansible_selinux": { "status": "disabled" }, "ansible_selinux_python_present": true, "ansible_service_mgr": "systemd", "ansible_ssh_host_key_dsa_public": "AAAAB3NzaC1kc3MAAACBAIjMSdXjIBwLTRwqzzLzJzw52IikcmHpmM65Idw9Q/CCH23SJdmmYzl9LIWFTEf2ZP4dHYibvgWtqfc6AHLFVgM1lz3wwdJJSyBD1TyFet+MPZEA1A9jw2Ke2K9C942dWATCpi3B0nk0KJDp49+V0QjUUjZmzt7I66wDmPLpW7mNAAAAFQDXmbLv48zsFHUgPiixhcKsk29ZPQAAAIAHHM+jfcL3V/X6EovQGj/2OytDN7k5hb4KRNTzBwh9JU5V44+S3r5ZViJDthKBolVT1CLX8jAivBu6d70ImYcZLa75AImOnlSp9D4xGP4TNfdAYrA7CkYpzn8ky15xjFDjkL0BjVmeEg6In+04tZOp/kIi/Ft9/ld63W4xopspwwAAAIAhBCIAMW37rknrsmv3sXmhgt+FeUQA/o8moZKcX+xI5sv27NEavQGGKOvZM4+nhCggRvjWaxC9N1DnO2g52trhGrUhNF0qwn/4iar/yknZWwRyZXzB3YtOdJXxCoJphuuGeqJRsLPb7OEIAF7c3lFJcfMUrwcjWrRtFMUM6mE+gQ==", "ansible_ssh_host_key_ecdsa_public": "AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBMffg6EX26f+10IIgg/U7+PsCUDs8Ep0MUttUyVh3+bJ7/K7ROMhuc8BTieA4PRj3MOaKMbUuZTqPTmrK/4srqg=", "ansible_ssh_host_key_ed25519_public": "AAAAC3NzaC1lZDI1NTE5AAAAINIKYkm+FKDTvx6VgENoAnXwOJQ+xZjk3rkvUqZ/4F3i", "ansible_ssh_host_key_rsa_public": "AAAAB3NzaC1yc2EAAAADAQABAAABAQC1xlLrDTri/jRfph6Uqx6CoY1/+uAE34rR9sR4FtE+2OMM8kUN0+N+hWLL+8r/pzM40RJOUmELYTlibfnjkYDsmYcpxD8kOxonvlYQbpvram8Hx7X8W1thYs//Zdhltmz1ijTiEatCL/yxJnwrpxN1XOtbMtALKgykbOzF+LNevFUG05MxxQR5WVjijXwK/Auf0ce/ei3NISQZLiW+d+IVYPkAQDpbUpH5W/qGDN0W8wT2OGE0bOvrPfDPRhSxeYrcS4mgS7nGvB26sFyeAimgadnxmWaxAveargYKt33jJQhVaA/23kw+/lygQcSN1QJ2mpeHb3ugay0Gv1i/Wd7P", "ansible_swapfree_mb": 0, "ansible_swaptotal_mb": 0, "ansible_system": "Linux", "ansible_system_capabilities": [ "" ], "ansible_system_capabilities_enforced": "True", "ansible_system_vendor": "Alibaba Cloud", "ansible_uptime_seconds": 11384976, "ansible_user_dir": "/home/admin", "ansible_user_gecos": "", "ansible_user_gid": 1000, "ansible_user_id": "admin", "ansible_user_shell": "/bin/bash", "ansible_user_uid": 1000, "ansible_userspace_architecture": "x86_64", "ansible_userspace_bits": "64", "ansible_virtualization_role": "guest", "ansible_virtualization_type": "kvm", "discovered_interpreter_python": "/usr/bin/python", "gather_subset": [ "all" ], "module_setup": true }, "changed": false } </pre></td></tr></table></figure> <h2 id="ansible-xargs-占位符"><a href="#ansible-xargs-占位符" class="headerlink" title="ansible + xargs 占位符"></a>ansible + xargs 占位符</h2><figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 </pre></td><td class="code"><pre>//批量执行docker exec ansible -i host.ini all -m shell -a "docker ps -a | grep pxd-tpcc | grep dn | cut -d ' ' -f 1 | xargs -I{} docker exec {} bash -c \"myc -e 'shutdown'\"" </pre></td></tr></table></figure> <h2 id="指定ip执行playbook"><a href="#指定ip执行playbook" class="headerlink" title="指定ip执行playbook"></a>指定ip执行playbook</h2><blockquote> ansible-playbook -i “10.168.101.179,” all test.yml </blockquote> 或者： <blockquote> ansible -i phy.ini 11.167.60.150 -m shell -a ‘docker run -it -d –net=host -e diamond_server_list=”“ -e diamond_db0=”“ -e diamond_db1=”“ -e diamond_db2=”“ -e HOST_IP=”“ -p 8080:8080 -p 9090:9090 –name diamond ‘ -vvv </blockquote> 上面这种还能重用phy.ini中所有的变量配置 <h2 id="创建用户并打通账号"><a href="#创建用户并打通账号" class="headerlink" title="创建用户并打通账号"></a>创建用户并打通账号</h2><figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 </pre></td><td class="code"><pre>$cat create_user.yml # create user ren with passwd test and sudo privileges. # ansible-playbook -i docker.ini create_user.yml - hosts: all user: root vars: # created with: # python -c 'import crypt; print crypt.crypt("password", "$1$SomeSalt$")' password: $1$SomeSalt$OrX9ouxOCP0ZOpVG9SwnR/ tasks: - name: create a new user user: name: '{{ user }}' password: '{{ password }}' home: /home/{{ user }} state: present shell: /bin/bash - name: Add user to the sudoers copy: dest: "/etc/sudoers.d/{{ user }}" content: "{{ user }} ALL=(ALL) NOPASSWD: ALL" - name: Deploy SSH Key authorized_key: user={{ user }} key="{{ lookup('file', '/root/.ssh/id_rsa.pub') }}" state=present </pre></td></tr></table></figure> 然后执行： ansible-playbook -i all.ini create_user.yml -e “user=admin” 。 或者： <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 </pre></td><td class="code"><pre> ansible -i 192.168.2.101, all -m user -a "name=user02 system=yes uid=503 group=root groups=root shell=/etc/nologin home=/home/user02 password=pwd@123" 192.168.2.101 | CHANGED => { "ansible_facts": { "discovered_interpreter_python": "/usr/bin/python" }, "changed": true, "comment": "", "create_home": true, "group": 0, "groups": "root", "home": "/home/user02", "name": "user02", "password": "NOT_LOGGING_PASSWORD", "shell": "/etc/nologin", "state": "present", "system": true, "uid": 503 } </pre></td></tr></table></figure> playbook task规范： <img src="/images/oss/d502a11765273304abd673fb358b482a.png" alt="image.png"> 对齐的时候不能用tab和空格混合 <h2 id="修改密码"><a href="#修改密码" class="headerlink" title="修改密码"></a>修改密码</h2>创建如下yaml脚本 changepw.yml: <figure class="highlight c"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 </pre></td><td class="code"><pre>- name: user module demo hosts: all become: true vars: user: 'admin' mypassword: "PolarDB-X" #mypassword: "$1$SomeSalt$PB9C3LT9wCjmaMYdBWsRS1" tasks: - name: change password ansible.builtin.user: name: "{{ user }}" state: present password: "{{ mypassword | password_hash('sha512') }}" </pre></td></tr></table></figure> 使用方法： <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 </pre></td><td class="code"><pre>ansible-playbook -i 1.2.3.4, changepw.yml -e "user=root" -e "mypassword=123" </pre></td></tr></table></figure> 将 root 账号的密码改成123 或者： <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 </pre></td><td class="code"><pre>ansible -i 1.2.3.4, all -e "newpassword=1234" -m user -a "name=admin update_password=always password={{ newpassword|password_hash('sha512') }}" </pre></td></tr></table></figure> <h3 id="创建用户以及密码"><a href="#创建用户以及密码" class="headerlink" title="创建用户以及密码"></a>创建用户以及密码</h3><figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 </pre></td><td class="code"><pre>ansible -i 1.2.3.4, all -e "newpassword=1234" -m user -a "name=ren state=present shell=/bin/sh update_password=always password={{ newpassword|password_hash('sha512') }}" </pre></td></tr></table></figure> <h2 id="部署docker-daemon的playbook"><a href="#部署docker-daemon的playbook" class="headerlink" title="部署docker daemon的playbook"></a>部署docker daemon的playbook</h2>执行 ansible-playbook site.yml -v -i test.ini -u admin -e “project=docker” -p <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 </pre></td><td class="code"><pre>$cat roles/docker/tasks/main.yml # filename: main.yml --- #"****************************************************************************"" - name: copy docker execute file to remote copy: src=docker/ dest=/usr/bin/ mode=0755 force=yes tags: copytar - name: create storage dir file: path={{ storage_dir }} state=directory ignore_errors: true tags: docker - name: create the dir file: path=/etc/systemd/system/ state=directory ignore_errors: true tags: docker - name: template docker.service to server template: src=docker.service dest=/etc/systemd/system/docker.service tags: docker - name: template docker.socket to server template: src=docker.socket dest=/usr/lib/systemd/system/docker.socket tags: docker - name: create /etc/docker dir to server file: path=/etc/docker state=directory ignore_errors: true tags: docker - name: copy daemon.json to server template: src={{ inventory_hostname }}/daemon.json dest=/etc/docker/daemon.json ignore_errors: true tags: docker - name: copy the load ovs modules to server copy: src=openvswitch.modules dest=/etc/sysconfig/modules/openvswitch.modules mode=0755 force=yes tags: docker - name: kill docker daemon shell: "kill -9 $(cat /var/run/docker.pid)" ignore_errors: true tags: test - name: reload systemctl daemon-reload shell: "systemctl daemon-reload" tags: docker - name: enabled the docker service shell: "systemctl enable docker.service" ignore_errors: true tags: docker - name: start docker service shell: "systemctl start docker.service" - name: remove all containers shell: sudo docker ps -a | awk '{print $1}' | xargs sudo docker rm -f -v ignore_errors: true - name: template /etc/hosts to server template: src=hosts dest=/etc/hosts owner=root group=root mode=0644 force=yes tags: restorehosts - name: mkdir /tmp/etc/ shell: "mkdir /tmp/etc/ " ignore_errors: true tags: hosts - name: copy remote /etc/hosts to /tmp shell: "cp /etc/hosts /tmp/etc/ " tags: hosts - name: copy /etc/hosts to server template: src=etc.host dest=/tmp/etc/ owner={{ remote_user }} group={{ remote_user }} mode=0700 force=yes tags: hosts - name: merge /etc/hosts assemble: src=/tmp/etc dest=/etc/hosts owner=root group=root mode=0644 force=yes tags: hosts - name: copy docker_rc.sh to server template: src=docker_rc.sh dest={{ docker_rc_dir }}/docker_rc.sh owner=root group=root mode=0755 force=yes when: use_vxlan!="true" tags: docker_rc - name: copy docker_rc.sh to server template: src=docker_rc_vm.sh dest={{ docker_rc_dir }}/docker_rc.sh owner=root group=root mode=0755 force=yes when: use_vxlan=="true" tags: docker_rc - name: clean docker_rc in rc.local command: su - root -c " sed -i '/docker_rc.sh/d' /etc/rc.d/rc.local " ignore_errors: true sudo: yes tags: docker_rc - name: start the docker when the system reboot command: su - root -c " echo 'su - root -c \"{{ docker_rc_dir }}/docker_rc.sh\" ' >> /etc/rc.d/rc.local " ignore_errors: true sudo: yes tags: docker_rc - name: chown the /etc/rc.d/rc.local shell: "chmod +x /etc/rc.d/rc.local " ignore_errors: true sudo: yes tags: docker_rc - name: clean previous space occupier file: path={{ storage_dir }}/ark.disk{{ item }}.tmp state=absent with_items: - 1 - 2 ignore_errors: true tags: docker - name: Occupy space for docker shell: "dd if=/dev/zero of={{ storage_dir }}/ark.disk{{ item }}.tmp bs=1M count=1024" sudo: yes with_items: - 1 - 2 tags: docker </pre></td></tr></table></figure> <h2 id="部署zk"><a href="#部署zk" class="headerlink" title="部署zk"></a>部署zk</h2><figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 </pre></td><td class="code"><pre>$cat roles/zookeeper/tasks/main.yml # filename: main.yml --- #"****************************************************************************"" - name: extract zookeeper tgz unarchive: src={{ packages_dir }}/lib/{{ zk_package_name }} dest=/opt sudo: yes - name: create zk data and log dir file: path={{ zk_data_dir }} state=directory mode=0755 with_items: - "{{ zk_data_dir }}" - "{{ zk_logs_dir }}" - name: set the myid template: src=myid dest={{ zk_myid_file }} mode=0644 - name: template zoo.cfg template: src=zoo.cfg dest={{ zk_install_dir }}/conf/ mode=0644 - name: copy log4j to remote template: src=log4j.properties dest={{ zk_install_dir }}/conf/log4j.properties - name: determine zk process command: su - root -c "ps aux | grep java | grep -v grep | grep {{ zk_install_dir }}" register: result ignore_errors: true - name: stop zk server command: su - root -c "sh {{ zk_install_dir }}/bin/zkServer.sh stop" ignore_errors: true when: "result.rc == 0" - name: start zk server command: su - root -c "sh {{ zk_install_dir }}/bin/zkServer.sh start" - name: get process info command: su - root -c "ps aux | grep java | grep -v grep | grep {{ zk_install_dir }}" register: result - name: clean zk service when the system reboot command: su - root -c " sed -i '/{{ zk_dir_name }}/d' /etc/rc.d/rc.local " ignore_errors: true sudo: yes - name: start the zk service when the system reboot command: su - root -c " echo 'su - root -c \"{{ zk_install_dir }}/bin/zkServer.sh start\" ' >> /etc/rc.d/rc.local " ignore_errors: true sudo: yes - name: start the zk service when the system reboot shell: "chmod +x /etc/rc.d/rc.local " ignore_errors: true sudo: yes </pre></td></tr></table></figure> <h2 id="参考资料"><a href="#参考资料" class="headerlink" title="参考资料"></a>参考资料</h2><a target="_blank" rel="noopener" href="https://www.mydailytutorials.com/how-to-copy-files-and-directories-in-ansible-using-copy-and-fetch-modules/">How to Copy Files and Directories in Ansible Using Copy and Fetch Modules</a> </div> <footer class="post-footer"> <div class="post-eof"></div> </footer> </article> </div> <div class="post-block"> <article itemscope itemtype="http://schema.org/Article" class="post-content" lang=""> <link itemprop="mainEntityOfPage" href="https://plantegg.github.io/2016/03/22/ansible%20PlayBook%20%E5%8F%98%E9%87%8F/"> <meta itemprop="image" content="/images/avatar.gif"> <meta itemprop="name" content="twitter @plantegg"> <meta itemprop="name" content="plantegg"> <meta itemprop="description" content="java mysql tcp performance network docker Linux"> <meta itemprop="name" content=" | plantegg"> <meta itemprop="description" content=""> <header class="post-header"> <h2 class="post-title" itemprop="name headline"> <a href="/2016/03/22/ansible%20PlayBook%20%E5%8F%98%E9%87%8F/" class="post-title-link" itemprop="url">在ansible PlayBook中如何定义不同的机器、不同的Role使用不同的变量</a> </h2> <div class="post-meta-container"> <div class="post-meta"> 发表于 <time title="创建时间：2016-03-22 17:30:03" itemprop="dateCreated datePublished" datetime="2016-03-22T17:30:03+08:00">2016-03-22</time> 更新于 <time title="修改时间：2025-11-16 19:58:49" itemprop="dateModified" datetime="2025-11-16T19:58:49+08:00">2025-11-16</time> 分类于 <a href="/categories/Ansible/" itemprop="url" rel="index">Ansible</a> </div> </div> </header> <div class="post-body" itemprop="articleBody"> <h1 id="在ansible-PlayBook中如何定义不同的机器、不同的Role使用不同的变量"><a href="#在ansible-PlayBook中如何定义不同的机器、不同的Role使用不同的变量" class="headerlink" title="在ansible PlayBook中如何定义不同的机器、不同的Role使用不同的变量"></a>在ansible PlayBook中如何定义不同的机器、不同的Role使用不同的变量</h1><h2 id="问题场景1"><a href="#问题场景1" class="headerlink" title="问题场景1"></a>问题场景1</h2><blockquote> 在安装Edas Agent脚本的时候发现在不同的机房[深圳、杭州、北京]有不同的网络定义[VPC、Normal],希望不同机房的机器在不同网络下使用不同的下载地址 </blockquote> <h2 id="问题场景2"><a href="#问题场景2" class="headerlink" title="问题场景2"></a>问题场景2</h2><blockquote> 在同一台机器上安装MySQL和Diamond，需要定义一个Project_Name, 如果定义在Hosts.ini中必然会覆盖，一台机器相当于一个作用域【同一个函数中也不允许你定义两个一样的名字吧！】 </blockquote> <h2 id="问题场景1的解决"><a href="#问题场景1的解决" class="headerlink" title="问题场景1的解决"></a>问题场景1的解决</h2><h3 id="在hosts-ini文件中定义不同的机器和变量"><a href="#在hosts-ini文件中定义不同的机器和变量" class="headerlink" title="在hosts.ini文件中定义不同的机器和变量"></a>在hosts.ini文件中定义不同的机器和变量</h3><pre><code>[sz_vpc] 10.125.0.169 10.125.192.40 [sz_normal] 10.125.12.174 [sz:children] sz_vpc sz_normal [hz_vpc] 10.125.3.33 [hz_normal] 10.125.14.238 [hz:children] hz_vpc hz_normal ############variables [sz_vpc:vars] script_url="sz_vpc" [sz_normal:vars] script_url="sz_normal" [hz_vpc:vars] script_url="hz_vpc" [hz_normal:vars] script_url="hz_normal" </code></pre> <h3 id="执行代码"><a href="#执行代码" class="headerlink" title="执行代码"></a>执行代码</h3><pre><code>- name: test variables debug: msg={{ script_url }} #对所有机器输出他们的url来验证一下我们的定义生效没有 tags: test </code></pre> <h3 id="执行结果"><a href="#执行结果" class="headerlink" title="执行结果"></a>执行结果</h3><pre><code>$udp-playbook -i udp-hosts.ini site.yml -b -u admin -t test UDP-PLAY-START: [apply common configuration to all nodes] ********************* UDP-TASK: [test variables] **************************************************** ok => 10.125.3.33 => { "msg": "hz_vpc" } ok => 10.125.0.169 => { "msg": "sz_vpc" } ok => 10.125.192.40 => { "msg": "sz_vpc" } ok => 10.125.14.238 => { "msg": "hz_normal" } ok => 10.125.12.174 => { "msg": "sz_normal" } </code></pre> <h2 id="问题场景2的解决"><a href="#问题场景2的解决" class="headerlink" title="问题场景2的解决"></a>问题场景2的解决</h2><blockquote> 在这里变量不要放在hosts.ini中，到MySQL、Diamond的roles中新建两个yml文件,在里面分别写上 MySQL和Diamond的 Project_Name 这样就不会覆盖了 </blockquote> <h3 id="目录结构"><a href="#目录结构" class="headerlink" title="目录结构"></a>目录结构</h3><pre><code><figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 </pre></td><td class="code"><pre>$ find roles roles/ roles/mysql roles/mysql/tasks roles/mysql/tasks/main.yml roles/mysql/defaults roles/mysql/defaults/main.yml roles/diamond roles/diamond/tasks roles/diamond/tasks/main.yml roles/diamond/defaults roles/diamond/defaults/main.yml </pre></td></tr></table></figure> </code></pre> <h3 id="变量定义"><a href="#变量定义" class="headerlink" title="变量定义"></a>变量定义</h3><figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 </pre></td><td class="code"><pre>$ cat roles/mysql/defaults/main.yml project: { "project_name": mysql, "version": 5.6.0 } $ cat roles/daimond/defaults/main.yml project: { "project_name": daimond, "version": 3.5.0 } </pre></td></tr></table></figure> <h3 id="变量使用"><a href="#变量使用" class="headerlink" title="变量使用"></a>变量使用</h3><figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 2 3 </pre></td><td class="code"><pre>- name: print the tar file name debug: msg="{{ project.project_name }}" tags: test </pre></td></tr></table></figure> <h2 id="role-和-playbook-用法"><a href="#role-和-playbook-用法" class="headerlink" title="role 和 playbook 用法"></a>role 和 playbook 用法</h2>role中文件夹含义 <ul> <li>tasks目录：存放task列表。若role要生效，此目录必须要有一个主task文件main.yml，在main.yml中可以使用include包含同目录(即tasks)中的其他文件。</li> <li>handlers目录：存放handlers的目录，若要生效，则文件必须名为main.yml文件。</li> <li>files目录：在task中执行copy或script模块时，如果使用的是相对路径，则会到此目录中寻找对应的文件。</li> <li>templates目录：在task中执行template模块时，如果使用的是相对路径，则会到此目录中寻找对应的模块文件。</li> <li>vars目录：定义专属于该role的变量，如果要有var文件，则必须为main.yml文件。</li> <li>defaults目录：定义角色默认变量，角色默认变量的优先级最低，会被任意其他层次的同名变量覆盖。如果要有var文件，则必须为main.yml文件。</li> </ul> <figure class="highlight plaintext"><table><tr><td class="gutter"><pre>1 </pre></td><td class="code"><pre>ansible-playbook 11.harbor.yml --list-tasks </pre></td></tr></table></figure> </div> <footer class="post-footer"> <div class="post-eof"></div> </footer> </article> </div> <nav class="pagination"> <a class="extend prev" rel="prev" title="上一页" aria-label="上一页" href="/page/18/"></a><a class="page-number" href="/">1</a>…<a class="page-number" href="/page/18/">18</a>19 </nav> </div> </main> <footer class="footer"> <div class="footer-inner"> <div class="copyright"> © 2026 twitter @plantegg </div> <div class="busuanzi-count"> </div> <div class="powered-by">由 <a href="https://hexo.io/" rel="noopener" target="_blank">Hexo</a> & <a href="https://theme-next.js.org/muse/" rel="noopener" target="_blank">NexT.Muse</a> 强力驱动 </div> </div> </footer> <div class="toggle sidebar-toggle" role="button"> </div> <div class="sidebar-dimmer"></div> <div class="back-to-top" role="button" aria-label="返回顶部"> 0% </div> <noscript> <div class="noscript-warning">Theme NexT works best with JavaScript enabled</div> </noscript> </body> </html>

方舟环境容器调度

主要功能

通过 ark-schedule 镜像启动调度

环境变量参数说明

镜像版本

所有需要调度的容器增加调度标志标签

API （如下ip：10.125.14.238 在现场换成客户物理机IP）

维护状态

升级ark-schedule步骤：

下载并导入新镜像

停止原来的ark-schedule

启动新的ark-schdule

检查调度日志

参考资料

磁盘爆掉的几种情况

现场的同学按如下方法依次检查

方法零： 检查系统根目录下每个文件夹的大小

方法一： 容器内部日志非常大（请确保先按方法零检查过了）

执行完后会输出如下格式：

然后进到容器后通过 du / –max-depth=2 快速发现大文件

方法二： 容器使用的volume使用过大

方法三 容器的系统日志没有限制大小

一些其他可能占用空间的地方

检查是否restart能支持只重启deamon，容器还能正常运行：

通过分析tcp包来确认服务调用的响应时间

不需要在应用中打点，不限定于具体语言（php、cpp、java都可以）, 分析服务调用的响应时间

案例

原因

数据库服务器网卡中断瓶颈导致rtt非常高，进一步导致每个Query的ResponseTime非常高（图中左边都是出问题、右边都是问题解决后的响应时间）

问题修复后数据库每个查询的平均响应时间从47毫秒下降到了4.5毫秒

从wireshark中也可以看到类似的rtt不正常（超过150ms的比较多）

从wireshark中也可以看到类似的rtt正常(99%都在10ms以内）

总结

最牛B的Linux Shell命令

引言

1.以sudo运行上条命令

2.以HTTP方式共享当前文件夹的文件

find

top

xargs 传参数

非贪婪匹配

macOS sed 删除行

ps 查看进程

循环按行处理

3.在以普通用户打开的vim当中保存一个root用户文件

4.切换回上一个目录

5.替换上一条命令中的一个短语

6.快速备份一个文件

7.免密码ssh登录主机

8.抓取Linux桌面的视频

1.用你最喜欢的编辑器来敲命令

2.清空或创建一个文件

3.用ssh创建端口转发通道

4.重置终端

5.在午夜的时候执行某命令

6.远程传送麦克风语音

7.映射一个内存目录

8.用diff对比远程文件跟本地文件

9.查看系统中占用端口的进程

1. 更友好的显示当前挂载的文件系统

2. 运行前一个 Shell 命令，同时用 “bar” 替换掉命令行中的每一个 “foo”

3. 实时某个目录下查看最新改动过的文件

4. 通过 SSH 挂载远程主机上的文件夹

5. 通过 DNS 来读取 Wikipedia 的词条

6. 用 Wget 的递归方式下载整个网站

7. 复制最后使用的命令中的参数

8. 执行一条命令但不保存到 history 中

9. 显示当前目录中所有子目录的大小 du

10. 显示消耗内存最多的 10 个运行中的进程，以内存使用量排序

11. 用 python 快速开启一个 SMTP 服务

4.在一个子shell中运行一个命令

7.我想知道一台服务器什么时候重启完

8.列出你最常用的10条命令

9.检查Gmail新邮件

方法零：检查系统根目录下每个文件夹的大小

方法一：容器内部日志非常大（请确保先按方法零检查过了）

方法二：容器使用的volume使用过大

方法三容器的系统日志没有限制大小