iptables命令语法顺序

![](https://pic.nexopera.tech/1522111.png)

```
-L  
显示所选链的所有规则。如果没有选择链，所有链将被显示。
也可以和z选项一起 使用，这时链会被自动列出和归零。精确输出受其它所给参数影响。-n 只显示数字ip、port-t 指定表
-A append，追加最后
-I  insert 最前面插入新规则
-D 删除规则
-p 指定协议，protocal，tcp、udp、icmp、all
--dport 目标端口
--sport source源端口
-s  源ip
-d 目标ip
-m 指定模块
-i 指定数据进入时，走哪个网卡
-o 数据流出时，走哪个网卡
-j  满足链之后的动作、drop、accept、reject
-F 删除所有规则
-X 删除用户自定义的链
-Z 链计数器为零# author : by www.yuchaoit.cn
```

1.安装iptables
------------

```
yum install iptables-services -y
```

2.加载防火墙内核模块
-----------

```
modprobe ip_tables
modprobe iptable_filter
modprobe iptable_nat
modprobe ip_conntrack
modprobe ip_conntrack_ftp
modprobe ip_nat_ftp
modprobe ipt_state查看已加载的模块
```

![](https://pic.nexopera.tech/1522112.png)

3.启动防火墙
-------

```
1.停止firewalld，开启iptables
systemctl stop firewalld
systemctl disable firewalldsystemctl start iptables.service
systemctl enable iptables.service
```

4.iptables核心命令
--------------

### 1.查看规则

```
# -n --numeric -n 地址和端口的数字输出
# -L  列出所有链的规则[root@db-51 ~]#iptables -nL
Chain INPUT (policy ACCEPT)
target     prot opt source               destination         
ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0            state RELATED,ESTABLISHED
ACCEPT     icmp --  0.0.0.0/0            0.0.0.0/0           
ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0           
ACCEPT     tcp  --  0.0.0.0/0            0.0.0.0/0            state NEW tcp dpt:22
REJECT     all  --  0.0.0.0/0            0.0.0.0/0            reject-with icmp-host-prohibitedChain FORWARD (policy ACCEPT)
target     prot opt source               destination         
REJECT     all  --  0.0.0.0/0            0.0.0.0/0            reject-with icmp-host-prohibitedChain OUTPUT (policy ACCEPT)
target     prot opt source               destination
```

### 2.清空规则

```
iptables -F <- 清除所有规则，不会处理默认的规则
iptables -X <- 删除用户自定义的链
iptables -Z <- 链的计数器清零（数据包计数器与数据包字节计数器）[root@db-51 ~]#
[root@db-51 ~]#iptables -F
[root@db-51 ~]#iptables -X
[root@db-51 ~]#iptables -Z
[root@db-51 ~]#
[root@db-51 ~]#
[root@db-51 ~]#iptables -L
Chain INPUT (policy ACCEPT)
target     prot opt source               destination         Chain FORWARD (policy ACCEPT)
target     prot opt source               destination         Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination
```

### 3.添加防火墙规则

```
iptables -t     <-    指定表d(efault: `filter')
iptables -A     <-    把规则添加到指定的链上，默认添加到最后一行。
iptables -I     <-    插入规则，默认插入到第一行(封IP)。
iptables -D     <-    删除链上的规则
```

### 4.查看网络连接状态

```
NEW：已经或将启动新的连接
ESTABLISHED：已建立的连接
RELATED：正在启动的新连接
INVALID：非法或无法识别的
```

5.删除某个规则
--------

```
iptables -nL --line-numbers 查看规则号码[root@db-51 ~]#iptables -nL --line-numbers
Chain INPUT (policy ACCEPT)
num  target     prot opt source               destination         Chain FORWARD (policy ACCEPT)
num  target     prot opt source               destination         Chain OUTPUT (policy ACCEPT)
num  target     prot opt source               destination    # 删除指定链上的指定序号
iptables -D INPUT 1# 测试，给INPUT 加一个规则
# 禁止访问6379端口
# 区分大小写命令[root@db-51 ~]#
[root@db-51 ~]#iptables -t filter -A INPUT -p tcp --dport 6379 -j DROP
[root@db-51 ~]#
[root@db-51 ~]#iptables -nL
Chain INPUT (policy ACCEPT)
target     prot opt source               destination         
DROP       tcp  --  0.0.0.0/0            0.0.0.0/0            tcp dpt:6379Chain FORWARD (policy ACCEPT)
target     prot opt source               destination         Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination       # 试试还能连接吗
[root@db-52 ~]#redis-cli -h 172.16.1.51 -p 6379# 删除规则
[root@db-51 ~]#iptables -nL --line-numbers
Chain INPUT (policy ACCEPT)
num  target     prot opt source               destination         
1    DROP       tcp  --  0.0.0.0/0            0.0.0.0/0            tcp dpt:6379Chain FORWARD (policy ACCEPT)
num  target     prot opt source               destination         Chain OUTPUT (policy ACCEPT)
num  target     prot opt source               destination    # 删除规则
[root@db-51 ~]#iptables -D INPUT 1# 再连接试试
[root@db-52 ~]#redis-cli -h 172.16.1.51 -p 6379
172.16.1.51:6379> ping
PONG
```

2.规则实战玩法
--------

1.禁止22端口访问
----------

危险操作，别瞎执行..

```
参数解释
-p               #<==指定过滤的协议-p（tcp,udp,icmp,all）
--dport          #<==指定目标端口（用户请求的端口）。
-j               #<==对规则的具体处理方法（ACCEPT,DROP,REJECT,SNAT/DNAT)
--sport             #<==指定源端口。# 预测，执行后会怎么样？iptables -t filter -A INPUT -p tcp --dport 22 -j DROP
```

![](https://pic.nexopera.tech/1522113.png)

2.禁止某个ip访问具体网卡
--------------

```
iptables -F# 禁止52机器访问51机器（ens33网卡）
iptables -I INPUT -p tcp -s 10.0.0.52 -i ens33 -j DROP# 查看
[root@db-51 ~]#
[root@db-51 ~]#iptables -nL
Chain INPUT (policy ACCEPT)
target     prot opt source               destination         
DROP       tcp  --  10.0.0.52            0.0.0.0/0Chain FORWARD (policy ACCEPT)
target     prot opt source               destination         Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination         
[root@db-51 ~]## 试试52和51通信
[root@db-52 ~]#ssh root@10.0.0.51
[root@db-52 ~]#ssh root@172.16.1.51
```

3.使用取反符号
--------

```
禁止除了10.0.0.53以外的ip访问本机的ens33# 危险命令
[root@db-51 ~]#iptables -A INPUT -p tcp ! -s 10.0.0.53 -i ens33 -j DROP
```

![](https://pic.nexopera.tech/1522114.png)

```
[root@db-53 ~]#ssh root@10.0.0.51
root@10.0.0.51's password: 
Last login: Mon Aug 15 17:27:21 2022 from 172.16.1.52
[root@db-51 ~]#
```

### 查看51机器最新规则

```
[root@db-51 ~]#ssh root@10.0.0.51^C
[root@db-51 ~]#iptables -L
Chain INPUT (policy ACCEPT)
target     prot opt source               destination         
DROP       tcp  --  10.0.0.52            anywhere            
DROP       tcp  -- !10.0.0.53            anywhere            Chain FORWARD (policy ACCEPT)
target     prot opt source               destination         Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination   # 可见-A是追加规则
```

4.只允许10.0.0.0网段的数据包进入
---------------------

```
iptables -A INPUT -p tcp ! -s 10.0.0.0/24 -i ens33 -j DROP
```

![](https://pic.nexopera.tech/1522115.png)

```
发现规则的加载顺序，因此想让这个规则有用，还得删除2号规则
[root@db-51 ~]#iptables -nL --line-number
Chain INPUT (policy ACCEPT)
num  target     prot opt source               destination         
1    DROP       tcp  --  10.0.0.52            0.0.0.0/0           
2    DROP       tcp  -- !10.0.0.53            0.0.0.0/0           
3    DROP       tcp  -- !10.0.0.0/24          0.0.0.0/0           Chain FORWARD (policy ACCEPT)
num  target     prot opt source               destination         Chain OUTPUT (policy ACCEPT)
num  target     prot opt source               destination         
[root@db-51 ~]#
[root@db-51 ~]#
[root@db-51 ~]#iptables -D INPUT 2
```

![](https://pic.nexopera.tech/1522116.png)

5.实现堡垒机登录唯一入口
-------------

要作为第一个规则，就是`-I`

```
iptables -I INPUT -p tcp ! -s 10.0.0.61 -j DROP# 查看TCP
[root@db-51 ~]#
[root@db-51 ~]#netstat -an|grep 10.0.0.61
tcp        0      0 10.0.0.51:22            10.0.0.61:44198         ESTABLISHED
[root@db-51 ~]#
```

![](https://pic.nexopera.tech/1522117.png)

6.匹配端口范围
--------

> 只允许172.16.1.0/24网段访问本机的22 ，6379，80端口

```
# 禁止多个目标端口被访问
# 只允许172.16.1.0/24网段访问本机的22 ，6379，80端口iptables -I INPUT -p tcp  ! -s 172.16.1.0/24 -m multiport --dport 22,6379,80 -j DROP# 远程访问试试
[root@m-61 ~]#ssh root@172.16.1.51[root@db-51 ~]#redis-cli -h 172.16.1.51 -p 6379
172.16.1.51:6379> ping
PONG
172.16.1.51:6379># 禁止端口范围语法
iptables -I INPUT -p tcp  ! -s 172.16.1.0/24  --dport 6000:7000 -j DROP# 注意iptable规则，自上而下的匹配[root@db-51 ~]#iptables -nL
Chain INPUT (policy ACCEPT)
target     prot opt source               destination         
DROP       tcp  -- !172.16.1.0/24        0.0.0.0/0            tcp dpts:6000:7000
DROP       tcp  -- !172.16.1.0/24        0.0.0.0/0            multiport dports 22,6379,80Chain FORWARD (policy ACCEPT)
target     prot opt source               destination         Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination    # 批量清理规则
[root@m-61 ~]#for i in 51 52 53;do ssh root@172.16.1.$i "iptables -F";done
```

7.禁止服务器被ping，服务器拒绝icmp的流量，给与响应
------------------------------

测试REJECT动作

```
# 常见的禁ping语句#给INPUT链添加规则，指定icmp协议，指定icmp类型 是8(回显请求)，  -s指定网段范围  -j 跳转的目标，即将做什么iptables -A INPUT -p icmp --icmp-type 8 -s 0/0 -j REJECT
简写
iptables -A INPUT -p icmp --icmp-type 8 -j REJECT
```

![](https://pic.nexopera.tech/1522118.png)

8.服务器禁ping，请求直接丢弃
-----------------

测试DROP动作

```
iptables -A INPUT -p icmp --icmp-type 8 -s 0/0 -j DROP
```

![](https://pic.nexopera.tech/1522119.png)

```
所以很明显，REJECT动作更绅士，提供了一定的排错思路。
DROP是很暴力的直接丢弃数据，不做任何反馈。
但若是抵挡恶意流量，DROP还是很必要的操作，可以延缓黑客的攻击进度。
```

9.练习题
-----

```
1. 封禁10.0.0.51 访问本机
[root@m-61 ~]#
[root@m-61 ~]#iptables -I INPUT -s 172.16.1.51 -j DROP
[root@m-61 ~]#iptables -I INPUT -s 10.0.0.51 -j DROP
[root@m-61 ~]#
[root@m-61 ~]#iptables -nL
Chain INPUT (policy ACCEPT)
target     prot opt source               destination         
DROP       all  --  10.0.0.51            0.0.0.0/0           Chain FORWARD (policy ACCEPT)
target     prot opt source               destinationChain OUTPUT (policy ACCEPT)
target     prot opt source               destination# 试试
[root@db-51 ~]#ping 10.0.0.61
PING 10.0.0.61 (10.0.0.61) 56(84) bytes of data.2.限制只有10.0.0.1可以ssh登录堡垒机
iptables -I INPUT -p tcp  ! -s 10.0.0.1 --dport 22 -j DROP
或者iptables -I INPUT -p tcp -s 10.0.0.1 --dport 22 -j ACCEPT
iptables -A INPUT -p tcp -s 0/0 --dport 22 -j DROP3. 封禁任何人访问本机6379
[root@db-51 ~]#iptables -I INPUT -p tcp --dport 6379 -j DROP
[root@db-51 ~]#
[root@db-51 ~]#iptables -nL
Chain INPUT (policy ACCEPT)
target     prot opt source               destination         
DROP       tcp  --  0.0.0.0/0            0.0.0.0/0            tcp dpt:6379Chain FORWARD (policy ACCEPT)
target     prot opt source               destinationChain OUTPUT (policy ACCEPT)
target     prot opt source               destination4.只允许走172内网，访问51机器的6379
[root@db-51 ~]#iptables -I INPUT -p tcp -s 172.16.1.0/24 --dport 6379 -j ACCEPT
[root@db-51 ~]#
[root@db-51 ~]#iptables -nL
Chain INPUT (policy ACCEPT)
target     prot opt source               destination         
ACCEPT     tcp  --  172.16.1.0/24        0.0.0.0/0            tcp dpt:6379
DROP       tcp  --  0.0.0.0/0            0.0.0.0/0            tcp dpt:6379Chain FORWARD (policy ACCEPT)
target     prot opt source               destinationChain OUTPUT (policy ACCEPT)
target     prot opt source               destination# 测试
[root@db-52 ~]#redis-cli -h 172.16.1.51 -p 6379
172.16.1.51:6379> ping
PONG
172.16.1.51:6379> 5.只允许走172内网，访问51机器的6379 ，简写
[root@db-51 ~]#iptables -nL
Chain INPUT (policy ACCEPT)
target     prot opt source               destination         
DROP       tcp  -- !172.16.1.0/24        0.0.0.0/0            tcp dpt:6379Chain FORWARD (policy ACCEPT)
target     prot opt source               destinationChain OUTPUT (policy ACCEPT)
target     prot opt source               destination
```

10.封禁恶意访问网站80口的IP
-----------------

```
iptables -I INPUT -p tcp -s 恶意ip/24 --dport 80 -j DROP# 但是由于可能存在动态IP，能起到部分作用
```

3.实战玩法
------

```
关于防火墙规则，我们的3个链，防火墙规则有2个方案：
- 默认规则是ACCEPT，然后添加部分限制的规则语句
- 默认规则拒绝，然后添加允许通过的策略
```

3.1 关于web服务器的规则策略
-----------------

```
iptables -F
iptables -X
iptables -Z
iptables -A INPUT -p tcp -m multiport --dport 80,443 -j ACCEPT
iptables -A INPUT -p tcp --dport 22 -j ACCEPT
iptables -A INPUT -s 10.0.0.0/24 -j ACCEPT
iptables -A INPUT -s 172.16.1.0/24 -j ACCEPT
iptables -A INPUT -i lo -j ACCEPT
iptables -P INPUT DROP
iptables -P FORWARD DROP
iptables -P OUTPUT ACCEPT
iptables -nL
```

![](https://pic.nexopera.tech/15221110.png)

3.2 局域网共享上网
-----------

```
实现效果，m-61作为上网网关出口，实现数据包转发
其他机器只有172局域网地址，网关指向m-61
```

### m-61机器

```
iptables -t nat -A POSTROUTING -s 172.16.1.0/24 -j SNAT --to-source 10.0.0.61
echo 'net.ipv4.ip_forward = 1' >> /etc/sysctl.conf# 检查
[root@m-61 ~]#
[root@m-61 ~]#iptables -t nat  -nL
Chain PREROUTING (policy ACCEPT)
target     prot opt source               destination         Chain INPUT (policy ACCEPT)
target     prot opt source               destination         Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination         Chain POSTROUTING (policy ACCEPT)
target     prot opt source               destination         
SNAT       all  --  172.16.1.0/24        0.0.0.0/0            to:10.0.0.61
SNAT       all  --  172.16.1.0/24        0.0.0.0/0            to:10.0.0.61
SNAT       all  --  172.16.1.0/24        0.0.0.0/0            to:10.0.0.61# 其他转发规则sysctl -p
iptables -F
iptables -X
iptables -Z
iptables -A INPUT -p tcp -m multiport --dport 80,443 -j ACCEPT
iptables -A INPUT -p tcp --dport 22 -j ACCEPT
iptables -A INPUT -s 10.0.1.0/24 -j ACCEPT
iptables -A INPUT -s 172.16.1.0/24 -j ACCEPT
iptables -A INPUT -i lo -j ACCEPT
iptables -P INPUT DROP
iptables -P FORWARD DROP
iptables -P OUTPUT ACCEPT
iptables -A FORWARD -i ens37 -s 172.16.1.0/24 -j ACCEPT
iptables -A FORWARD -o ens33 -s 172.16.1.0/24 -j ACCEPT
iptables -A FORWARD -i ens33 -d 172.16.1.0/24 -j ACCEPT
iptables -A FORWARD -o ens37 -d 172.16.1.0/24 -j ACCEPT# -i 输入接口
# -o 输出接口
# 允许echo 'net.ipv4.ip_forward = 0' >> /etc/sysctl.conf
```

### 其他内网机器

```
思路
1. 关闭10网段网卡
2. 修改172网段网关，指向172.16.1.61，实现数据包转发
3.清除无用网络
[root@db-51 ~]#sed -i '$a NOZEROCONF=yes' /etc/sysconfig/network
[root@db-51 ~]#/etc/init.d/network restart
Restarting network (via systemctl):                        [  OK  ]4.确保客户端地址为
[root@db-51 ~]#route -n
Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
0.0.0.0         172.16.1.61     0.0.0.0         UG    0      0        0 ens37
172.16.1.0      0.0.0.0         255.255.255.0   U     0      0        0 ens37
```

### 图解网络流量转发

![](https://pic.nexopera.tech/15221111.png)

### 添加iptables规则的转发数据包

![](https://pic.nexopera.tech/15221112.png)

### 图解iptables配置原理

![](https://pic.nexopera.tech/15221113.png)

3.3 本地端口映射
----------

```
其实就是在61机器本地，将20022端口的数据包，转发给22端口# 禁用22端口直连流量iptables -t nat -A PREROUTING -d 10.0.0.61 -p tcp --dport 20022 -j DNAT --to-destination 172.16.1.61:22[root@m-61 ~]#
[root@m-61 ~]#iptables -t nat -nL
Chain PREROUTING (policy ACCEPT)
target     prot opt source               destination         
DNAT       tcp  --  0.0.0.0/0            10.0.1.61            tcp dpt:20022 to:172.16.1.7:22Chain INPUT (policy ACCEPT)
target     prot opt source               destination         Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination         Chain POSTROUTING (policy ACCEPT)
target     prot opt source               destination
```

### 测试映射效果

![](https://pic.nexopera.tech/15221114.png)

4.保存规则记录
--------

```
iptables-save > /opt/www.yuchaoit.cn_iptables.txt # 保存到指定文件
iptables-save # 保存到配置文件，防止重启后丢失
iptables-resotre <  /opt/www.yuchaoit.cn_iptables.txt  # 恢复规则
```

踩坑指南
----

```
1.修改之前先导出备份一份
2.修改的时候小心别把自己关在外面
3.可以现在定时任务里添加一条定时清空的规则，等测试没问题再取消定时任务
4.如果加错了规则，导致拒绝了所有请求，以及没有给与正确放行的规则，且iptables -F命令不会恢复规则ACCEPT，因此只能想办法去物理机上，调整iptables规则。
- 要么是云控制台
- 要么是找机房人员恢复规则
```

练习题
---

```
1.从上往下依次匹配
2.一但匹配上,就不在往下匹配了
3.默认规则,默认的情况,默认规则是放行所有禁止源地址是10.0.0.7的主机访问22端口
iptables -A INPUT -p tcp -s 10.0.0.7 --dport 22 -j DROP禁止源地址是10.0.0.7的主机访问任何端口
iptables -A INPUT -p tcp -s 10.0.0.7 -j DROP禁止源地址是10.0.0.8的主机访问80端口
iptables -A INPUT -p tcp -s 10.0.0.8 --dport 80 -j DROP禁止除了10.0.0.7以外的地址访问80端口
iptables -A INPUT -p tcp ! -s 10.0.0.7 --dport 80 -j DROP2条规则冲突,会以谁先谁为准
iptables -I INPUT -p tcp -s 10.0.0.7 --dport 22 -j ACCEPT
iptables -I INPUT -p tcp -s 10.0.0.7 --dport 22 -j DROP禁止10.0.0.7访问22和80端口
iptables -I INPUT -p tcp -s 10.0.0.7 -m multiport --dport 22,80 -j DROP禁止10.0.0.7访问22到100之间的所有端口
iptables -A INPUT -p tcp -s 10.0.0.7 --dport 22:100 -j DROP禁止所有主机ping
iptables -A INPUT -p icmp --icmp-type 8 -j DROP放行10.0.0.7可以ping
iptables -I INPUT 2 -p icmp --icmp-type 8 -s 10.0.0.7 -j ACCEPT只允许10.0.0.7可以ping
ACCEPT icmp -- 10.0.0.7 0.0.0.0/0 icmptype 8
DROP icmp -- 0.0.0.0/0 0.0.0.0/0 icmptype 8等同于上一条,优化版,只要不是10.0.0.7就不允许ping
iptables -I INPUT -p icmp --icmp-type 8 ! -s 10.0.0.7 -j DROP
```

iptables怎么用？你不会还不知道吧？

![](https://pic.nexopera.tech/0511.png)  

查看服务器磁盘IO性能
-----------

在服务器运维过程中，了解服务器的磁盘IO性能是非常重要的。磁盘IO性能直接影响到服务器的响应速度和处理能力。本文将介绍如何使用dd命令来查看服务器磁盘IO性能。

1\. 什么是dd命令？
------------

dd命令是Linux系统中的一个非常强大的工具，它可以用于复制文件、转换文件格式、备份数据等。dd命令的基本语法如下：

```
dd if=输入文件 of=输出文件 bs=块大小 count=块数
```

其中，if表示输入文件，of表示输出文件，bs表示块大小，count表示块数。

2\. 为什么要使用dd命令查看磁盘IO性能？
-----------------------

dd命令可以用于测试磁盘的读写速度，通过观察dd命令的执行时间，我们可以了解到磁盘的IO性能。此外，dd命令还可以用于测试磁盘的稳定性和可靠性。

3\. 如何使用dd命令查看磁盘IO性能？
---------------------

要使用dd命令查看磁盘IO性能，我们需要执行以下步骤：

3.1 准备测试文件
----------

首先，我们需要准备一个测试文件。可以使用dd命令创建一个指定大小的空文件，例如：

```
dd if=/dev/zero of=b.txt bs=1M count=10240
```

这条命令会创建一个名为b.txt的文件，大小为1GB（10240MB），内容全为0。

3.2 执行dd命令
----------

接下来，我们需要执行dd命令来测试磁盘的IO性能。在终端中输入以下命令：

```
dd if=b.txt of=/dev/null bs=1M iflag=direct oflag=direct count=10240
```

这条命令会将b.txt文件的内容直接写入/dev/null设备，不进行任何实际的磁盘操作。iflag和oflag参数用于指定输入和输出文件的访问方式，direct表示直接访问磁盘，不进行缓存。count参数表示要复制的块数，即测试的持续时间。

3.3 查看测试结果
----------

当dd命令执行完成后，我们可以查看测试结果。在终端中输入以下命令：

```
cat /proc/diskstats | grep b.txt | awk '{print $5}' | tail -n 1
```

这条命令会显示b.txt文件的读取速度。如果需要显示写入速度，可以将grep后面的参数改为b.txt。

4\. 如何解读测试结果？
-------------

在dd命令执行完成后，我们可以通过查看/proc/diskstats文件来获取磁盘的IO性能信息。/proc/diskstats文件包含了磁盘的统计信息，包括读取次数、写入次数、读取字节数、写入字节数等。我们可以通过grep命令筛选出与测试文件相关的信息，然后使用awk命令提取出所需的数据。最后，使用tail命令显示最后一行数据，即测试结果。

测试结果中的数值表示每秒传输的数据量，单位为KBps（千字节每秒）。例如，如果测试结果显示为10240KBps，那么表示磁盘每秒可以传输10240KB的数据。这个数值越大，说明磁盘的IO性能越好。

5\. 注意事项
--------

在使用dd命令查看磁盘IO性能时，需要注意以下几点：

*   由于dd命令会占用大量的CPU资源和内存资源，因此在执行dd命令时，建议关闭其他不必要的程序和服务。

*   为了获得准确的测试结果，建议在服务器负载较低的情况下进行测试。如果服务器负载较高，测试结果可能会受到其他因素的影响。

*   由于dd命令会创建大量的临时文件，因此建议在测试结束后删除这些临时文件，以释放磁盘空间。可以使用rm命令删除这些文件，例如：rm b.txt。

*   如果需要定期检查磁盘IO性能，可以将这些dd命令添加到cron定时任务中，以便自动执行。例如，可以创建一个名为check\_io.sh的脚本文件，内容如下：

```
#!/bin/bash
echo "开始检查磁盘IO性能..." >> io_test.log
dd if=b.txt of=/dev/null bs=1M iflag=direct oflag=direct count=10240 >> io_test.log
echo "检查完成" >> io_test.log
```

然后将这个脚本添加到cron定时任务中，例如：\*/5 \* \* \* \* /path/to/check\_io.sh，表示每5分钟执行一次检查。这样，我们就可以定期查看服务器的磁盘IO性能了。

6\. 总结
------

通过本文的介绍，我们了解了如何使用dd命令来查看服务器磁盘IO性能。dd命令是一个强大而灵活的工具，除了可以用来查看磁盘IO性能外，还可以用来进行数据备份、转换文件格式等操作。在实际运维过程中，我们应该充分利用这个工具，以提高服务器的性能和稳定性。

如何查看Linux服务器磁盘IO性能

### 引言

在自动化运维领域，频繁地进行服务器操作是一项常见的任务。为了简化这一过程并提高工作效率，免密登录成为了一种重要的技术。CentOS系列的免密登录脚本可以帮助自动化运维人员快速实现服务器的免密登录，从而简化操作并提高自动化部署、配置和管理的效率。本文将介绍如何使用这个脚本来实现自动化运维中的CentOS系列免密登录。

![](https://pic.nexopera.tech/1428.png)

### 快速使用

```
wget https://gitee.com/useryc/secret_free_login/raw/main/secret_free_login.sh
# 或者
wget wget https://raw.githubusercontent.com/liuyuanchengweb/secret_free_login/main/secret_free_login.sh
chmod +x secret_free_login.sh
./secret_free_login.sh [用户名] [主机地址] [密码]
```

### 目标

本文的目标是向读者展示如何使用CentOS系列的免密登录脚本来实现自动化运维中的服务器免密登录。通过使用该脚本，可以轻松的配置免密登录，提高工作效率，还可以使其它脚本调用该脚本。

### 脚本概述

CentOS系列的免密登录脚本使用了OpenSSH工具和Expect工具，它的主要功能包括：

*   检查所需工具的安装情况：脚本会自动检查是否已安装所需的工具（如OpenSSH和Expect）。如果发现工具未安装，脚本将自动安装它们。

*   生成密钥对：脚本会生成一对RSA密钥（公钥和私钥），用于加密通信和身份验证。

*   复制公钥到远程服务器：脚本会将生成的公钥复制到目标服务器，以实现免密登录。

*   验证免密登录：脚本会验证免密登录是否成功，并输出相应的结果。

### 前提条件

在使用CentOS系列的免密登录脚本之前，请确保满足以下前提条件：

*   CentOS系列操作系统：本脚本适用于openEuler、CentOS、Red Hat和其他基于CentOS的发行版。

*   本地机器：您需要在本地机器上执行该脚本。

*   远程服务器：您需要具有目标服务器的登录凭据（用户名和密码），并且具有通过SSH进行远程连接的权限。

### 脚本实现

以下是实现CentOS系列的免密登录脚本的代码：

```
#! /bin/bash

user=$1
ip_add=$2
pass=$3
timeout=10ssh_keygen(){
    if [ -e $id_rsa_path ];then
        echo -e "已经生成密钥:$id_rsa_path"
    else
        pass_path=$(/bin/expect -c "
        spawn  ssh-keygen -q -t rsa
        expect {
            \"*save the key*\" { send \"\r\"; exp_continue }
            \"*passphrase*\" { send \"\r\";exp_continue }
            \"*again*\" { send \"\r\"}
            }
        " | awk -F '$' 'NR==2{print $NF}' 2>/dev/null | awk -F '$' '{print $1}' 2>/dev/null)
        echo -e "密钥存放路径：$pass_path"
    fi    if [ $? -eq 1 ];then
        echo "生成密钥失败"
    fi
}
scp_key(){
        output=$(expect -c "
        set timeout $timeout
        spawn ssh-copy-id $user@$ip_add        expect {
                \"password:\" {
                        # 发送密码
                        send \"$pass\r\"
                        exp_continue
                }
                \"yes/no\" {
                        # 确认远程主机的公钥
                        send \"yes\r\"
                        exp_continue
                }
                \"Number of key(s) added\" {
                        # 配置免密登录成功
                        puts  \"succed\"
                        exit 0
                }
                \"WARNING: All keys were skipped because they already exist on the remote system.\" {
                        # 已经配置过免密登录
                        puts  \"outmoded\"
                        exit 1
                }
                \"Permission denied\" {
                        # 登录失败：权限被拒绝
                        puts  \"Permission denial\"
                        exit 2
                }
                \"ERROR: No identities found\" {
                        # 未生成密钥
                        puts  \"Ungenerated key\"
                        exit 3
                        }
                \"ERROR: ssh: connect to host\" {
                        # 连接超时
                        puts \"ssh: connect to host\"
                        exit 4
                        }
                timeout {
                        # 超时处理
                        puts  \"Timeout\"
                        exit 4
                }
        }
        expect eof
        ")
        case $output in
                *"succed"*)
                        echo "配置免密登录成功"
                        ;;
                *"outmoded"*)
                        echo "已经配置过免密登录"
                        ;;
                *"Permission denial"*)
                        echo "登录失败：权限被拒绝"
                        ;;
                *"Ungenerated key"*)
                        echo "未生成密钥"
                        ;;
                *"ssh: connect to host"*)
                        echo "主机连接超时"
                        ;;
                *)
                        echo "其他错误"
                        ;;
        esac
}check_ip(){
    IP=$(echo $ip_add|cut -d "/" -f 1)
    if echo $IP|grep -E "^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$" >/dev/null; then
        res=$(echo $IP|awk -F . '$1>=1&&$1<=255&&$2<=255&&$3<=255&&$4<=255{print "yes"}')
        if [ "X${res}" == "X" ]; then
            echo -e "请输入合法的IP地址"
            return 1
        fi
    fi
}check_expect_installation() {
  if ! command -v expect >/dev/null 2>&1; then
    echo "正在安装Expect..."
        if command -v yum >/dev/null ; then
            sudo yum install -y expect >/dev/null
    else
      echo "无法安装Expect,请手动安装"
      exit 1
    fi
    echo "Expect已成功安装"
  else
    echo "Expect已经安装"
  fi
}run_secret_free_login(){
    if [ -n "$user" ] && [ -n "$ip_add" ] && [ -n "$pass" ];then
        cd ~
        echo -e "你要执行免密登的用户名是：$user"
        echo -e "执行免密登录的主机是:$ip_add "
        echo -e "你要执行免密登的密码是：$pass"
        id_rsa_path=`pwd`/.ssh/id_rsa.pub
        check_expect_installation &&  check_ip && ssh_keygen && scp_key
    else
        echo -e "脚本使用格式# ./secret_free_login 用户名 IP地址 密码 "
    fi
}run_secret_free_login
```

1.  `ssh_keygen()` 函数：该函数用于生成密钥对。首先判断密钥文件是否已存在，如果存在则打印已经生成的密钥路径，否则使用 `ssh-keygen` 命令生成密钥对，并提取出生成的密钥文件路径。

2.  `scp_key()` 函数：该函数使用 `expect` 工具执行 `ssh-copy-id` 命令将公钥复制到远程主机，实现免密登录配置。在 `expect` 语句中，根据不同的匹配情况执行相应的操作，如发送密码、确认远程主机的公钥等。根据命令执行结果，使用 `puts` 命令输出相应的字符串，作为后续处理的依据。

3.  `check_ip()` 函数：该函数用于检查输入的 IP 地址是否合法。通过正则表达式判断 IP 地址的格式是否符合要求。

4.  `check_expect_installation()` 函数：该函数用于检查是否已安装 `expect` 工具。使用 `command -v` 命令检查 `expect` 命令是否存在，如果不存在，则执行安装操作。根据不同的系统包管理器，使用相应的命令进行安装。

5.  `run_secret_free_login()` 函数：该函数是脚本的主函数，用于执行免密登录的操作。首先检查输入参数是否符合要求，然后调用 `check_expect_installation()` 函数检查是否安装了 `expect` 工具，接着调用 `check_ip()` 函数检查 IP 地址的合法性，然后调用 `ssh_keygen()` 函数生成密钥对，最后调用 `scp_key()` 函数执行免密登录的配置操作。

6.  在脚本的最后，调用 `run_secret_free_login()` 函数开始执行免密登录操作。

### 使用方法

按照以下步骤使用CentOS系列的免密登录脚本：

1.  创建sh脚本文件

2.  `chmod +x 免密登录脚本.sh`

3.  运行脚本命令：`./免密登录脚本.sh 用户名 IP地址 密码`

4.  等待脚本执行完成，输出相应的结果

### 注意事项

*   在运行脚本之前，请确保已经安装了OpenSSH工具和Expect工具。

*   请确保输入的IP地址是正确的，并且目标主机可以通过网络访问。

*   如果脚本执行失败或输出错误信息，请仔细检查输入的参数和前提条件。

CentOS系列免密登录脚本分享

**一、CI/CD环境介绍**

![](https://pic.nexopera.tech/15221.png)

本次要实现如下效果，开发人员完成功能开发并提交代码到gitlab仓库，jenkins自动完成拉取代码、编译构建、代码扫描（sonarqube）、打包，再自动化完成部署到Tomcat服务器提供访问。  

环境准备三台Centos7.6机器：

服务器  

IP地址  

配置  

包含功能及版本  

Gitlab  

192.168.220.170

2核2G  

Gitlab：12.4.2 (393a5bdafa2)

Jenkins  

192.168.220.172

2核2G

Jenkins：2.364

Maven：3.8.6  

Sonarqube：7.9.6 (build 41879）

JDK：11.0.16

Git：1.8.3.1

Tomcat  

192.168.220.173

2核2G

Tomcat：8.5.82

JDK：1.8.0\_342

部署过程中踩过不少坑，这套Jenkins因为需要安装较多插件，而Jenkins上的插件版本要求比较严格，所以最好实验情况下直接安装最新的Jenkins版本，这样上面的插件基本都能安装，包括Pipeline、gitlab、SSH Server等。不然遇到Jenkins插件安装不顺畅对新人挺麻烦的。

Jenkins安装最新版，那JDK也必须11以上，那也就要求sonarqube也得7.8以上，三者之间都是有依赖关系的。

**看下效果：**

![](https://pic.nexopera.tech/15222.png)

**自动git拉取代码：**

![](https://pic.nexopera.tech/15223.png)

**maven自动构建：**

![](https://pic.nexopera.tech/15224.png)

**sonarqube自动扫描：**

![](https://pic.nexopera.tech/15225.png)

**自动部署：**  

![](https://pic.nexopera.tech/15226.png)

**sonarqube扫描结果：**

![](https://pic.nexopera.tech/15227.png)

**二、CI/CD平台搭建**

1）安装gitlab

```
1. 安装相关依赖
yum -y install policycoreutils openssh-server openssh-clients postfix
2. 启动ssh服务&设置为开机启动
systemctl enable sshd && sudo systemctl start sshd
3. 设置postfix开机自启，并启动，postfix支持gitlab发信功能
systemctl enable postfix && systemctl start postfix
4. 开放ssh以及http服务，然后重新加载防火墙列表
firewall-cmd --add-service=ssh --permanent
firewall-cmd --add-service=http --permanent
firewall-cmd --reload
如果关闭防火墙就不需要做以上配置
5. 下载gitlab包，并且安装
在线下载安装包：
wget https://mirrors.tuna.tsinghua.edu.cn/gitlab-ce/yum/el6/gitlab-ce-12.4.2-ce.0.el6.x
86_64.rpm
安装：
rpm -i gitlab-ce-12.4.2-ce.0.el6.x86_64.rpm
6. 修改gitlab配置
vi /etc/gitlab/gitlab.rb
修改gitlab访问地址和端口，默认为80，我们改为82
external_url 'http://192.168.220.170:82'
nginx['listen_port'] = 82
7. 重载配置及启动gitlab
gitlab-ctl reconfigure
gitlab-ctl restart
8. 把端口添加到防火墙
firewall-cmd --zone=public --add-port=82/tcp --permanent
firewall-cmd --reload
启动成功后，看到以下修改管理员root密码的页面，修改密码后，然后登录即可
```

![](https://pic.nexopera.tech/15228.png)

添加组、创建用户、创建项目  

![](https://pic.nexopera.tech/15229.png)

![](https://pic.nexopera.tech/152210.png)

这样用户zhangsan就拥有了itheima\_group组的权限。接下来使用zhangsan用户进入组创建一个新的项目，项目名称：hello\_demo  

![](https://pic.nexopera.tech/152211.png)

该项目仓库地址是：

http://192.168.220.170:82/itheima\_group/hello-demo.git

git@192.168.220.170:itheima\_group/hello-demo.git

接下来将本地的maven工程代码上传到gitlab仓库，上传成功后如下：

![](https://pic.nexopera.tech/152212.png)

到这gitlab就准备好了！

2）安装jenkins

```
1）安装JDK
Jenkins需要依赖JDK，所以先安装JDK11
yum install -y java-11-openjdk*
安装目录为：/usr/lib/jvm
2）获取jenkins安装包
wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat/jenkins.repo --no-check-certificate
rpm --import https://pkg.jenkins.io/redhat/jenkins.io.key
yum install jenkins
3）启动Jenkinssystemctl start jenkins
4）打开浏览器访问
http://192.168.220.172:8080
注意：本服务器把防火墙关闭了，如果开启防火墙，需要在防火墙添加端口
5）获取并输入admin账户密码
cat /var/lib/jenkins/secrets/initialAdminPassword
6）跳过插件安装
因为Jenkins插件需要连接默认官网下载，速度非常慢，而且经过会失败，所以我们暂时先跳过插件安装
```

Jenkins安装完成后，需要替换插件更新源：需要执行以下步骤：

```
sed -i 's/https:\/\/updates.jenkins.io\/download/https:\/\/mirrors.tuna.tsinghua.edu.cn\/jenkins/g' default.json && sed -i 's/https:\/\/www.google.com/https:\/\/www.baidu.com/g' default.json
```

在Manage Jenkins -- Plungin Manager -- Update Site：将url替换为清华大学的url：https://mirrors.tuna.tsinghua.edu.cn/jenkins/updates/update-center.json

![](https://pic.nexopera.tech/152213.png)

提交后，在浏览器输入：http://192.168.220.172.:8080/restart重启jenkins生效。  

Jenkins准备好后，就是与gitlab集成，完成代码自动拉取的动作了。但是需要先准备如下：

**安装Credentials Binding插件**

要在Jenkins使用凭证管理功能，需要安装Credentials Binding插件，拉取gitlab代码需要使用凭证的方式拉取：

![](https://pic.nexopera.tech/152214.png)

**再去添加gitlab认证的凭证：**  

![](https://pic.nexopera.tech/152215.png)

**还要再jenkins服务器上安装git工具和git插件：**

![](https://pic.nexopera.tech/152216.png)

![](https://pic.nexopera.tech/152217.png)

**在jenkins上准备一个项目：**

![](https://pic.nexopera.tech/152218.png)

![](https://pic.nexopera.tech/152219.png)

到这里，jenkins拉取gitlab代码的准备条件都ok了。开始与gitlab集成吧。

![](https://pic.nexopera.tech/152220.png)

保存，然后回到项目点“Build Now”：  

![](https://pic.nexopera.tech/152221.png)

![](https://pic.nexopera.tech/152222.png)

如上图，jenkins自动去gitlab拉取代码，并且将代码工程放在如上路径下：  

![](https://pic.nexopera.tech/152223.png)

好了，到这里说明jenkins已经安装成功了，也安装了相关的插件和配置了jenkins的基本配置，并且完成了与gitlab的集成，完成构建自动触发代码拉取到本地。  

3）部署Tomcat服务器

```
把Tomcat压缩包上传到192.168.66.102服务器
yum install java-1.8.0-openjdk* -y #安装JDK（已完成）
tar -xzf apache-tomcat-8.5.47.tar.gz #解压
mkdir -p /opt/tomcat #创建目录
mv /root/apache-tomcat-8.5.47/* /opt/tomcat #移动文件
/opt/tomcat/bin/startup.sh #启动tomcat
```

注意：服务器已经关闭了防火墙，所以可以直接访问Tomcat啦，地址为：http://192.168.66.102/8080

![](https://pic.nexopera.tech/152224.png)

![](https://pic.nexopera.tech/152225.png)

tomcat已经部署成功！

4）配置jenkins与tomcat集成，完成CD持续部署功能  

同样的，也是需要在jenkins上做大量的配置：  

**Maven安装和配置**

```
tar -xzf apache-maven-3.6.2-bin.tar.gz #解压
mkdir -p /opt/maven #创建目录
mv apache-maven-3.6.2/* /opt/maven #移动文件
```

配置环境变量

```
export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk
export MAVEN_HOME=/opt/maven
export PATH=$PATH:$JAVA_HOME/bin:$MAVEN_HOME/bin
```

Jenkins全局工具配置，关联JDK和Maven

![](https://pic.nexopera.tech/152226.png)

![](https://pic.nexopera.tech/152227.png)

添加Jenkins全局变量  

![](https://pic.nexopera.tech/152228.png)

准备好后，来测试Maven构建是否生效，还是用刚刚的项目：hello\_web

![](https://pic.nexopera.tech/152229.png)

![](https://pic.nexopera.tech/152230.png)

![](https://pic.nexopera.tech/152231.png)

可以看到，项目构建成功。可以去服务器上看到war包已经生成。  

![](https://pic.nexopera.tech/152232.png)

war可以自动编译，还差自动部署了，有需要配置一些步骤：  

安装 Deploy to container插件

![](https://pic.nexopera.tech/152233.png)

添加Tomcat凭证

![](https://pic.nexopera.tech/152234.png)

jenkins项目配置构建后操作  

![](https://pic.nexopera.tech/152235.png)

![](https://pic.nexopera.tech/152236.png)

保存配置，点“Build Now”：  

![](https://pic.nexopera.tech/152237.png)

![](https://pic.nexopera.tech/152238.png)

可以看到项目成功部署，可以正常访问。

**END**

教你基于 Jenkins 搭建一套 CI/CD 系统

###### 1、使用串口线连接到存储设备的A控或者B控配置口，如下图：

![](https://pic.nexopera.tech/4231.png)

###### 2、使用xshell工具进行连接，将波特率修改为115200，如下图：

![](https://pic.nexopera.tech/4232.png)  
![](https://pic.nexopera.tech/4233.png)

###### 3、进入命令提示符输入用户名：\_super\_admin,密码输入:Admin@revive,输入完成回车，在“storage:\_super\_admin>”提示符后输入initpasswd，回车，接下来输入要重置的用户名，默认是admin，在输入新的密码，修改密码成功后会提示“init admin passwd succeeded”，如下图：

![](https://pic.nexopera.tech/4234.png)

###### 4、输入地址x.x.x.x:8088访问管理地址进行访问，输入刚修改的密码进行登录。

华为存储5300 V5密码忘记

Nexopera是一个专注于Linux、网络和运维等领域的博客网站。将为读者提供广泛的相关文章，涵盖操作系统、服务器管理、网络配置、安全性等多个主题。如果你是初学者，希望这里有适合你的内容。