1
00:00:03,486 --> 00:00:06,972
[音频标志]

2
00:00:09,480 --> 00:00:16,320
所以我看到一个设备 Rack102-R1,
设备 Rack102-R2,

3
00:00:16,320 --> 00:00:18,550
和设备 Rack102-FW1。

4
00:00:18,550 --> 00:00:19,800
看软件版本——

5
00:00:19,800 --> 00:00:25,770
9.14(2)4、16.09.07、16.09.07。

6
00:00:25,770 --> 00:00:28,920
这样
问题要求的第一部分就完成了。

7
00:00:28,920 --> 00:00:35,080
这就是我的脚本此时的样子
。

8
00:00:35,080 --> 00:00:37,080
现在是第二个
部分，即

9
00:00:37,080 --> 00:00:41,880
会更复杂一点，因为这一次，

10
00:00:41,880 --> 00:00:44,460
我需要解析数据。

11
00:00:44,460 --> 00:00:47,010
而我需要以这种方式解析
数据

12
00:00:47,010 --> 00:00:52,260
它只捕获具有 IP 的
接口。

13
00:00:52,260 --> 00:00:54,660
如果它有一个
IP，那么它应该

14
00:00:54,660 --> 00:00:56,370
捕获接口名称。

15
00:00:56,370 --> 00:01:03,048
它应该捕获 IP
地址和子网掩码。

16
00:01:03,048 --> 00:01:04,840
所以这将是我们的下一个要求。

17
00:01:04,840 --> 00:01:08,290
显然，为此，我们
将编写另一个函数。

18
00:01:08,290 --> 00:01:10,290
所以我们要写
另一个函数

19
00:01:10,290 --> 00:01:14,010
为此，这将
基于演出。

20
00:01:14,010 --> 00:01:17,400
是的，我可以这样做
基于显示界面。

21
00:01:17,400 --> 00:01:19,920
连show interface
都有子网掩码，

22
00:01:19,920 --> 00:01:22,170
有IP地址，
有接口名。

23
00:01:22,170 --> 00:01:25,530
所以我可以使用显示接口解析
数据

24
00:01:25,530 --> 00:01:27,390
命令，或者我可以
解析数据

25
00:01:27,390 --> 00:01:29,850
基于 show run 命令。

26
00:01:29,850 --> 00:01:33,380
我会根据演出来做。

27
00:01:33,380 --> 00:01:35,285
因此，让我们也快速
构建该部分。

28
00:01:38,680 --> 00:01:42,150
所以让我们现在
添加接口，

29
00:01:42,150 --> 00:01:46,440
基本上是从路由器获取接口
信息

30
00:01:46,440 --> 00:01:47,860
和防火墙。

31
00:01:47,860 --> 00:01:52,360
因此，我将
创建另一个函数。

32
00:01:52,360 --> 00:01:57,240
我们将其命名为
定义 get_ip

33
00:01:57,240 --> 00:02:03,310
临时占位符
名称为 dev 和冒号。

34
00:02:03,310 --> 00:02:05,100
所以在这里，我要做的第一件事


35
00:02:05,100 --> 00:02:09,250
与我从这里复制/粘贴的地方完全相同。

36
00:02:09,250 --> 00:02:12,240
所以这三个命令是
我要粘贴的

37
00:02:12,240 --> 00:02:13,050
这里。

38
00:02:13,050 --> 00:02:17,530
唯一的区别是
在这里，我会进行表演。

39
00:02:17,530 --> 00:02:22,890
所以就像我之前说的那样，
我会做一场演出

40
00:02:22,890 --> 00:02:27,780
做一个show IP interface
简介或者一个show interface。

41
00:02:27,780 --> 00:02:29,940
是的，你可以做到
使用显示界面

42
00:02:29,940 --> 00:02:33,510
并获取 IP 地址、
子网掩码和相关的

43
00:02:33,510 --> 00:02:34,290
界面。

44
00:02:34,290 --> 00:02:36,390
但它会
更容易接受

45
00:02:36,390 --> 00:02:37,810
从正在运行的配置。

46
00:02:37,810 --> 00:02:42,220
所以我将使用
运行配置。

47
00:02:42,220 --> 00:02:45,420
所以我有dev.enable，
这意味着

48
00:02:45,420 --> 00:02:48,090
我将启用
路由器和防火墙。

49
00:02:48,090 --> 00:02:51,750
我会得到
设备的主机名，无论它是防火墙

50
00:02:51,750 --> 00:02:53,550
或者它是一个路由器。

51
00:02:53,550 --> 00:02:56,130
然后我使用
输出变量

52
00:02:56,130 --> 00:02:58,920
发送命令 show run。

53
00:02:58,920 --> 00:03:01,740
所以基本上，
显示运行输出

54
00:03:01,740 --> 00:03:05,380
将在称为输出的
变量中。

55
00:03:05,380 --> 00:03:10,810
接下来我
要做的是打印。

56
00:03:10,810 --> 00:03:16,350
我会打印信息。

57
00:03:16,350 --> 00:03:20,360
所以根据问题，我需要
首先显示界面信息。

58
00:03:20,360 --> 00:03:33,500
所以让我们打印，让我们
做冒号，或者，事实上，引号，

59
00:03:33,500 --> 00:03:42,610
反斜杠 n 和 Interface
Info，反斜杠 n。

60
00:03:42,610 --> 00:03:46,420
所以这会将
标题打印为接口信息。

61
00:03:46,420 --> 00:03:51,400
前后会有一个
空行。

62
00:03:51,400 --> 00:03:56,050
接下来我
要做的事情基本上就是——

63
00:03:56,050 --> 00:04:00,860
使用节目运行，我会看看
我需要捕捉什么。

64
00:04:00,860 --> 00:04:03,160
所以如果我看一下
防火墙，防火墙

65
00:04:03,160 --> 00:04:06,040
界面内有不同的命令


66
00:04:06,040 --> 00:04:07,460
相对于路由器。

67
00:04:07,460 --> 00:04:11,200
路由器只有
可能接口gig1，

68
00:04:11,200 --> 00:04:13,938
然后有IP地址
和子网掩码。

69
00:04:13,938 --> 00:04:15,730
但是如果你看一个
防火墙，防火墙

70
00:04:15,730 --> 00:04:19,209
有接口和
编号，然后有名称如果，

71
00:04:19,209 --> 00:04:22,400
有安全级别，
然后有IP地址。

72
00:04:22,400 --> 00:04:26,260
所以我想做
我将使用正则表达式

73
00:04:26,260 --> 00:04:28,870
扫描
正在运行的配置

74
00:04:28,870 --> 00:04:31,330
并过滤掉那部分。

75
00:04:31,330 --> 00:04:33,100
事实上，让我告诉你。

76
00:04:33,100 --> 00:04:37,150
我将连接到我的设备。

77
00:04:37,150 --> 00:04:43,990
让我们连接到 R1、
R2 和防火墙。

78
00:04:43,990 --> 00:04:47,620
我将向您展示正在运行的
配置，它的样子，

79
00:04:47,620 --> 00:04:49,510
因为我们需要
知道它的样子

80
00:04:49,510 --> 00:04:52,810
就像在运行配置中一样
实际使用正则表达式

81
00:04:52,810 --> 00:04:57,640
搜索过滤掉
我们有什么信息

82
00:04:57,640 --> 00:04:59,870
需要基本
解析数据。

83
00:04:59,870 --> 00:05:04,750
所以让我们去这里获取
Ubuntu机器。

84
00:05:04,750 --> 00:05:10,150
在这里，我将有
路由器 1，我有路由器 2，

85
00:05:10,150 --> 00:05:14,750
我有我的防火墙。

86
00:05:14,750 --> 00:05:16,330
因此，如果我查看
防火墙--让我们

87
00:05:16,330 --> 00:05:20,410
做一个显示运行界面，
看看界面上有什么。

88
00:05:20,410 --> 00:05:22,450
我有一个东西
叫做nameif。

89
00:05:22,450 --> 00:05:25,797
我有安全级别，
然后我有 IP 地址。

90
00:05:25,797 --> 00:05:27,880
因此，当我真正查看
正在运行的配置时

91
00:05:27,880 --> 00:05:29,297
当我通过数据解析
时，

92
00:05:29,297 --> 00:05:31,660
我必须提供
所有这些信息

93
00:05:31,660 --> 00:05:35,770
然后只捕获这部分
以及接口名称。

94
00:05:35,770 --> 00:05:38,410
我不想捕获
nameif 和安全级别，

95
00:05:38,410 --> 00:05:41,290
但我仍然需要
在我的正则表达式搜索中给出它

96
00:05:41,290 --> 00:05:43,820
当我解析
数据时。

97
00:05:43,820 --> 00:05:50,170
但是如果你看路由器，
我们来做一个show run界面，

98
00:05:50,170 --> 00:05:53,380
假设 gig1，您会看到
它只有界面，

99
00:05:53,380 --> 00:05:55,400
然后直接，我有IP地址。

100
00:05:55,400 --> 00:05:57,400
所以路由器应该
不是问题。

101
00:05:57,400 --> 00:05:59,390
问题出在
防火墙。

102
00:05:59,390 --> 00:06:04,270
所以你必须编写
一个更复杂的正则表达式模式

103
00:06:04,270 --> 00:06:08,270
匹配我们需要的参数
。

104
00:06:08,270 --> 00:06:11,620
那么让我们回到
Ubuntu机器，

105
00:06:11,620 --> 00:06:15,910
我将使用
我的用户名/密码登录。

106
00:06:19,512 --> 00:06:20,970
让我，事实上，
扩大屏幕。

107
00:06:27,480 --> 00:06:32,340
好的，那么
回到我的脚本。

108
00:06:32,340 --> 00:06:35,760
我要做的是
我会

109
00:06:35,760 --> 00:06:39,210
创建一个基于主机名的模式。

110
00:06:39,210 --> 00:06:41,460
现在因为
对防火墙的要求

111
00:06:41,460 --> 00:06:44,280
不一样是因为firewall
有nameif，安全性高

112
00:06:44,280 --> 00:06:47,010
级别，而路由器没有
，我会创建一个 if

113
00:06:47,010 --> 00:06:50,400
条件，如果
主机名包含防火墙，

114
00:06:50,400 --> 00:06:52,500
然后进行此搜索。

115
00:06:52,500 --> 00:06:55,950
如果是路由器，
然后进行其他搜索。

116
00:06:55,950 --> 00:06:58,080
让我们在这里创建一个 if
条件，即

117
00:06:58,080 --> 00:07:07,680
如果 fw 在主机名中--

118
00:07:07,680 --> 00:07:10,840
所以主机名.lower。

119
00:07:10,840 --> 00:07:13,440
所以如果我当时是
主机名.lower，

120
00:07:13,440 --> 00:07:15,730
那么我要匹配什么模式
？

121
00:07:15,730 --> 00:07:18,600
所以让我们创建一个名为模式的
变量

122
00:07:18,600 --> 00:07:23,700
等于 regex.compile。

123
00:07:23,700 --> 00:07:27,050
这就是我的模式
。

124
00:07:27,050 --> 00:07:30,060
我将扫描
原始数据，其中

125
00:07:30,060 --> 00:07:35,820
将是界面，
空间，然后我

126
00:07:35,820 --> 00:07:40,560
需要搜索一个
字字符

127
00:07:40,560 --> 00:07:42,060
将是我的接口名称。

128
00:07:42,060 --> 00:07:46,140
所以如果你看一下界面，
就是千兆以太网。

129
00:07:46,140 --> 00:07:49,410
所以这将是
一个单词字符

130
00:07:49,410 --> 00:07:56,310
可能是一个或多个，所以我会
说，让我们创建一个组--

131
00:07:56,310 --> 00:08:00,410
所以我会
说，反斜杠 w+--

132
00:08:00,410 --> 00:08:02,840
所以任何单词字符——

133
00:08:02,840 --> 00:08:04,490
然后在
单词字符之后，

134
00:08:04,490 --> 00:08:11,450
它将是数字，
类似于 gigabit0/0。

135
00:08:11,450 --> 00:08:14,690
所以如果你看
防火墙，接口号

136
00:08:14,690 --> 00:08:18,035
是千兆位0/0。

137
00:08:18,035 --> 00:08:18,785
所以这是一个数字。

138
00:08:18,785 --> 00:08:20,790
我需要匹配那个。

139
00:08:20,790 --> 00:08:22,370
所以这将是——

140
00:08:22,370 --> 00:08:24,170
这将匹配千兆位。

141
00:08:24,170 --> 00:08:29,850
然后我会说反斜杠
d，它是任意数字，

142
00:08:29,850 --> 00:08:33,049
然后是一个点，反斜杠 d。

143
00:08:33,049 --> 00:08:38,150
所以我在这里所做的
是，在这个小组中，

144
00:08:38,150 --> 00:08:40,380
我正在匹配
接口号。

145
00:08:40,380 --> 00:08:45,470
所以这将是匹配
接口然后是千兆0--

146
00:08:45,470 --> 00:08:50,510
点表示任何东西，所以它
可以是斜线 0、斜线 0。

147
00:08:50,510 --> 00:08:53,550
这将是我的第一组。

148
00:08:53,550 --> 00:08:55,280
下一件事
我要匹配

149
00:08:55,280 --> 00:08:59,960
在这之后
是，比方说，回归

150
00:08:59,960 --> 00:09:04,520
字符，即回车，
所以反斜杠r，然后

151
00:09:04,520 --> 00:09:05,825
反斜杠 n.

152
00:09:08,420 --> 00:09:13,770
反斜杠 n 可以
为零或更多。

153
00:09:13,770 --> 00:09:17,870
其实如果
看命令，

154
00:09:17,870 --> 00:09:20,840
相间0后有nameif


155
00:09:20,840 --> 00:09:23,810
0，因为之后，我
实际上是按 Enter 键。

156
00:09:23,810 --> 00:09:25,580
这就是我的反斜杠 r。

157
00:09:25,580 --> 00:09:27,470
然后这里有一个
空格，那就是

158
00:09:27,470 --> 00:09:36,270
为什么我把
放在反斜杠n中。

159
00:09:36,270 --> 00:09:38,660
然后我有一个
空白，它

160
00:09:38,660 --> 00:09:42,830
将是反斜杠 s。

161
00:09:42,830 --> 00:09:44,870
同样，空白
可以是可选的。

162
00:09:44,870 --> 00:09:46,520
这就是我
提出这个问题的原因

163
00:09:46,520 --> 00:09:48,770
标记，它是零
或更多，所以有

164
00:09:48,770 --> 00:09:51,630
可能是更多的空白。

165
00:09:51,630 --> 00:09:53,060
所以我有返回字符。

166
00:09:53,060 --> 00:09:57,810
我有反斜杠 n,
这又是可选的。

167
00:09:57,810 --> 00:10:01,050
然后我有空格，
这又是可选的。

168
00:10:01,050 --> 00:10:05,930
这将
与我的 Enter 匹配。

169
00:10:05,930 --> 00:10:08,120
现在，我可以匹配我的 nameif。

170
00:10:08,120 --> 00:10:14,390
所以对于nameif，命令
是nameif，然后

171
00:10:14,390 --> 00:10:17,070
任何
不是空格的单词字符。

172
00:10:17,070 --> 00:10:19,610
因此，让我们再次为此创建一个
组——反斜杠。

173
00:10:19,610 --> 00:10:27,060
所以任何不是白色
空格的东西都可以是零或更多。

174
00:10:27,060 --> 00:10:30,070
我认为可能
是一个或多个。

175
00:10:30,070 --> 00:10:33,250
让我们关闭我的小组。

176
00:10:33,250 --> 00:10:38,620
之后，我将再次
按 Enter，这是我的——

177
00:10:38,620 --> 00:10:40,360
在 nameif 之后，我将按 Enter。

178
00:10:40,360 --> 00:10:43,678
再说一次，我会有一个空间。

179
00:10:43,678 --> 00:10:45,470
然后我有
安全级别命令。

180
00:10:45,470 --> 00:10:46,660
那么让我们匹配它。

181
00:10:46,660 --> 00:10:53,840
所以反斜杠 r，并且，
再次，这是可选的。

182
00:10:53,840 --> 00:10:57,870
所以零个或多个，
反斜杠 n，零个或多个，

183
00:10:57,870 --> 00:11:01,290
反斜杠，零
或更多，然后我

184
00:11:01,290 --> 00:11:05,710
有安全级别的命令。

185
00:11:05,710 --> 00:11:08,890
这将再次
在一个组内。

186
00:11:08,890 --> 00:11:11,460
所以我实际上将它放在一个组中的原因

187
00:11:11,460 --> 00:11:14,730
是因为我并不是真的
想要匹配所有东西。

188
00:11:14,730 --> 00:11:16,238
我不想
捕获nameif。

189
00:11:16,238 --> 00:11:18,030
我不想捕获
安全级别。

190
00:11:18,030 --> 00:11:20,970
我只想捕获
接口和IP地址

191
00:11:20,970 --> 00:11:21,630
集体。

192
00:11:21,630 --> 00:11:23,213
这就是我将他们
放在一个组中的原因

193
00:11:23,213 --> 00:11:26,880
因为我稍后会打电话给
这个小组。

194
00:11:26,880 --> 00:11:30,090
我的意思是
把它放在组里，

195
00:11:30,090 --> 00:11:31,750
是我把这个
放在括号里，

196
00:11:31,750 --> 00:11:33,100
这基本上意味着组。

197
00:11:33,100 --> 00:11:41,040
所以这是我的第 1 组，这
是我的第 2 组，到此结束。

198
00:11:41,040 --> 00:11:43,680
这将
成为我的第 3 组。

199
00:11:43,680 --> 00:11:46,480
所以在不安全级别，它
只是数字。

200
00:11:46,480 --> 00:11:52,800
所以这将是反斜杠
d，可以是一个或多个。

201
00:11:52,800 --> 00:11:54,220
再说一次，这是可选的。

202
00:11:54,220 --> 00:11:57,010
所以它可以是一个，
也可以是更多的数字。

203
00:11:57,010 --> 00:12:00,990
因此，它可能类似于安全
级别 1 或安全级别 100。

204
00:12:00,990 --> 00:12:03,862
必须有
某种数字。

205
00:12:03,862 --> 00:12:05,070
这是一个安全级别。

206
00:12:05,070 --> 00:12:09,180
然后我又有了一个
反斜杠 r，反斜杠 n，

207
00:12:09,180 --> 00:12:13,920
和一个反斜杠 s。

208
00:12:13,920 --> 00:12:16,180
然后我有 IP
address 命令。

209
00:12:16,180 --> 00:12:21,610
所以ip地址--再一次，
我会把它放在一个组中，

210
00:12:21,610 --> 00:12:24,510
这将基于-

211
00:12:24,510 --> 00:12:27,840
我有四个八度，
然后是一个空格，

212
00:12:27,840 --> 00:12:30,370
然后我有子网掩码。

213
00:12:30,370 --> 00:12:34,060
所以这将再次
在一个组内。

214
00:12:34,060 --> 00:12:41,860
所以让我们把这个
放在一个组中，

215
00:12:41,860 --> 00:12:51,056
将是反斜杠
d，后跟点，

216
00:12:51,056 --> 00:12:52,830
然后在外面加号。

217
00:12:52,830 --> 00:12:57,690
所以这是要做什么
是，我有一个数字

218
00:12:57,690 --> 00:13:03,940
通过一个点，这可能是
一位或更多位，空格，

219
00:13:03,940 --> 00:13:07,790
比我有我的子网
掩码，这又是，

220
00:13:07,790 --> 00:13:09,010
将是反斜杠 d.

221
00:13:12,470 --> 00:13:15,590
显然，对于
点，我会

222
00:13:15,590 --> 00:13:23,170
必须转义那个
和反斜杠点，

223
00:13:23,170 --> 00:13:25,645
这将再次
成为一个或多个。

224
00:13:28,240 --> 00:13:35,120
让我们最后关闭我的
双引号并关闭

225
00:13:35,120 --> 00:13:36,270
我最后的括号。

226
00:13:36,270 --> 00:13:38,480
所以这是我实际关闭的括号
，

227
00:13:38,480 --> 00:13:41,020
这是在这里。

228
00:13:41,020 --> 00:13:42,600
那么这实际上是做什么的呢？

229
00:13:42,600 --> 00:13:45,540
所以这将
匹配原始数据。

230
00:13:45,540 --> 00:13:48,900
在双引号中，
我有这个字符串

231
00:13:48,900 --> 00:13:53,700
在里面，也就是说，
它将是界面，

232
00:13:53,700 --> 00:13:58,380
空格，任何单词字符，
是一个或多个，

233
00:13:58,380 --> 00:14:03,810
后跟一个数字，
点，一个数字，然后我

234
00:14:03,810 --> 00:14:05,520
有返回字符。

235
00:14:05,520 --> 00:14:08,160
我有空白。

236
00:14:08,160 --> 00:14:10,740
然后我有命令的名称。

237
00:14:10,740 --> 00:14:15,780
我有任何不是
空白的东西——一个或多个——所以

238
00:14:15,780 --> 00:14:18,690
你
在里面，外面有的任何名字。

239
00:14:18,690 --> 00:14:21,960
然后我有返回字符
再次带有空格。

240
00:14:21,960 --> 00:14:24,220
然后我有
安全级别，空间。

241
00:14:27,660 --> 00:14:30,700
在安全级别，
再次，我有一个数字，

242
00:14:30,700 --> 00:14:32,470
这是一个加号。

243
00:14:32,470 --> 00:14:34,440
所以这意味着它是一个
或更多，所以它可以

244
00:14:34,440 --> 00:14:37,320
是个位数或更多。

245
00:14:37,320 --> 00:14:40,830
然后我又有了
返回字符

246
00:14:40,830 --> 00:14:42,000
与白色空间。

247
00:14:42,000 --> 00:14:44,080
然后我有 IP
address 命令，

248
00:14:44,080 --> 00:14:49,170
其中有反斜杠 d,
反斜杠点，其中

249
00:14:49,170 --> 00:14:53,148
基本上意味着它
匹配文字点。

250
00:14:53,148 --> 00:14:54,690
这将
匹配我的 IP 地址。

251
00:14:54,690 --> 00:14:57,870
因为我有加号，
表示一个或多个。

252
00:14:57,870 --> 00:15:01,170
然后我有空间，
我有子网掩码

253
00:15:01,170 --> 00:15:02,290
在这里匹配。

254
00:15:02,290 --> 00:15:06,930
所以这个应该基本上
匹配接口参数

255
00:15:06,930 --> 00:15:10,770
这是我们需要匹配的要求。

256
00:15:10,770 --> 00:15:15,510
现在开始吧——因为
我有多个接口，

257
00:15:15,510 --> 00:15:21,180
我需要说，match
等于pattern.findall。

258
00:15:24,540 --> 00:15:28,690
Findall 从输出。

259
00:15:28,690 --> 00:15:31,660
所以这是我之前使用的输出变量
，

260
00:15:31,660 --> 00:15:33,100
其中有演出。

261
00:15:33,100 --> 00:15:35,190
所以我真正
在这里做的是

262
00:15:35,190 --> 00:15:38,340
使用 findall 搜索
多个接口。

263
00:15:38,340 --> 00:15:40,470
看，早些时候，当我
做演出版时，

264
00:15:40,470 --> 00:15:43,200
我使用了搜索命令
因为搜索命令

265
00:15:43,200 --> 00:15:49,450
仅查找发生的第一个
实例。

266
00:15:49,450 --> 00:15:52,320
但是findall all，因为我会
有多个接口，只是

267
00:15:52,320 --> 00:15:55,910
不只是一个接口，我
会有接口 gig0 为 0，

268
00:15:55,910 --> 00:15:58,590
0 乘 1，也许环回 0。

269
00:15:58,590 --> 00:16:00,090
我会有
多个接口，

270
00:16:00,090 --> 00:16:02,640
所以我需要使用
findall来查找

271
00:16:02,640 --> 00:16:07,770
全部使用变量输出，
具有显示运行输出。

272
00:16:07,770 --> 00:16:11,940
我将使用这个
模式来扫描那个，

273
00:16:11,940 --> 00:16:17,700
并解析数据，然后
将其存储在匹配项中。

274
00:16:17,700 --> 00:16:19,870
现在让我们给出一个
else 语句。

275
00:16:19,870 --> 00:16:24,370
所以我的 else 语句
将适用于路由器。

276
00:16:24,370 --> 00:16:31,990
所以否则——在这里，我会再次
拥有完全相同的东西，

277
00:16:31,990 --> 00:16:39,030
这将是——事实上，让我们复制这个，在哪里，在这里，我

278
00:16:39,030 --> 00:16:42,640
用不着
这么大的图案。

279
00:16:42,640 --> 00:16:48,060
所以第一部分将
几乎相同，即

280
00:16:48,060 --> 00:16:50,020
将是接口名称。

281
00:16:50,020 --> 00:16:58,140
但是，我真的
路由器上没有 gig0/0。

282
00:16:58,140 --> 00:17:00,360
我相信它是 gig1 或 gig2。

283
00:17:00,360 --> 00:17:02,550
让我们回到
路由器并检查一下。

284
00:17:02,550 --> 00:17:07,170
显示运行界面，或
显示ip界面简介。

285
00:17:07,170 --> 00:17:09,730
我所有的接口
只有一个数字。

286
00:17:09,730 --> 00:17:13,619
所以我可以给出一些东西
像反斜杠 d,

287
00:17:13,619 --> 00:17:20,500
让我们关闭这个括号，
我已经有了。

288
00:17:20,500 --> 00:17:25,660
我相信我在这里有一个
额外的括号。

289
00:17:29,490 --> 00:17:35,570
所以这应该匹配
接口 gig1 或 2。

290
00:17:35,570 --> 00:17:38,180
然后我有一个带空格的 Enter
键。

291
00:17:38,180 --> 00:17:40,700
我不需要 nameif
和安全级别，

292
00:17:40,700 --> 00:17:42,080
所以我们可以跳过所有这些。

293
00:17:42,080 --> 00:17:43,580
我们可以删除它。

294
00:17:43,580 --> 00:17:47,570
我可以直接拥有
那个IP地址

295
00:17:47,570 --> 00:17:49,415
匹配完全相同的东西。

296
00:17:52,340 --> 00:17:54,470
而我的匹配模式
将会是，

297
00:17:54,470 --> 00:17:57,680
再次，完全相同的
东西，它说匹配

298
00:17:57,680 --> 00:18:00,290
等于模式.findall。

299
00:18:00,290 --> 00:18:06,010
现在，我可以在其中创建一个
for循环

300
00:18:06,010 --> 00:18:12,460
说比赛中的比赛——

301
00:18:15,180 --> 00:18:23,760
所以对于匹配中的匹配——再次，
这只是一个 for 循环名称。

302
00:18:23,760 --> 00:18:28,390
因此，对于 match
中的匹配匹配我的变量。

303
00:18:28,390 --> 00:18:32,790
所以对于比赛中的比赛，
我会说，打印。

304
00:18:32,790 --> 00:18:34,360
我要打印什么？

305
00:18:34,360 --> 00:18:42,420
我要打印界面，
冒号，空格，让我们

306
00:18:42,420 --> 00:18:51,820
关闭我的双引号，然后
我想打印加匹配。

307
00:18:51,820 --> 00:18:59,150
而在比赛中，我的一个索引
值为0，也就是这里。

308
00:18:59,150 --> 00:19:03,490
所以这是我的界面。

309
00:19:03,490 --> 00:19:05,920
所以这是我的零组。

310
00:19:05,920 --> 00:19:09,640
所以索引值是
零或组零。

311
00:19:09,640 --> 00:19:17,800
然后我想要加反斜杠n。

312
00:19:17,800 --> 00:19:27,370
然后我想要IP
地址，冒号，空格，

313
00:19:27,370 --> 00:19:34,010
我想要匹配
组号 3 的位置。

314
00:19:34,010 --> 00:19:39,390
所以这是1，这是2。

315
00:19:39,390 --> 00:19:41,670
事实上，这是 0。

316
00:19:41,670 --> 00:19:43,360
这是1。

317
00:19:43,360 --> 00:19:44,400
这是2。

318
00:19:44,400 --> 00:19:47,250
IP 地址是组 3。

319
00:19:47,250 --> 00:19:50,670
所以这将是3。

320
00:19:50,670 --> 00:19:59,050
然后我想要下一行
反斜杠 n 加上匹配项——

321
00:20:01,930 --> 00:20:03,955
或者实际上，我想要
面具这个词——

322
00:20:07,150 --> 00:20:14,200
我想要面具的地方，
与第 4 组匹配。

323
00:20:14,200 --> 00:20:19,510
而且我相信
应该足够了——

324
00:20:19,510 --> 00:20:23,310
加上反斜杠 n。

325
00:20:27,420 --> 00:20:31,680
所以我要打印
接口，接口名称，

326
00:20:31,680 --> 00:20:36,030
IP 地址和
子网掩码。

327
00:20:36,030 --> 00:20:40,150
让我们复制这个，
对我的路由器完全相同。

328
00:20:42,850 --> 00:20:48,030
所以再一次，我要打印
索引值，实际上是第 0 组。

329
00:20:48,030 --> 00:20:51,930
这将是路由器的 group
1

330
00:20:51,930 --> 00:20:54,180
因为我的组在这里是 0。

331
00:20:54,180 --> 00:20:56,890
第 1 组在这里，
第 2 组是面具。

332
00:20:56,890 --> 00:21:01,210
所以这将是
第 1 组和第 2 组。

333
00:21:01,210 --> 00:21:02,020
就是这样。

334
00:21:02,020 --> 00:21:04,840
那应该是我的剧本。

335
00:21:04,840 --> 00:21:08,710
所以在我打印设备
名称之后，在我得到版本之前，

336
00:21:08,710 --> 00:21:10,070
我需要打印——

337
00:21:10,070 --> 00:21:18,820
我需要为我的函数做一个 get_ip 和
调用，这

338
00:21:18,820 --> 00:21:21,700
是设备。

339
00:21:21,700 --> 00:21:23,550
再说一次，让我们去 ip 设备。

340
00:21:23,550 --> 00:21:25,060
这应该足够好了。

341
00:21:25,060 --> 00:21:26,530
我认为它应该工作。

342
00:21:26,530 --> 00:21:30,820
事实上，让我们去
试试这个。

343
00:21:30,820 --> 00:21:35,670
所以我真正做的是
我已经使用了show run，

344
00:21:35,670 --> 00:21:38,880
我正在使用正则表达式解析
数据，

345
00:21:38,880 --> 00:21:42,600
我正在匹配
确切的模式

346
00:21:42,600 --> 00:21:50,580
表示接口，接口
名称，槽号，然后

347
00:21:50,580 --> 00:21:52,140
我有名字。

348
00:21:52,140 --> 00:21:53,430
我有安全级别。

349
00:21:53,430 --> 00:21:54,570
我有IP地址。

350
00:21:54,570 --> 00:21:55,530
我有面具。

351
00:21:55,530 --> 00:21:57,990
我已经把它们放在
组中，这样，

352
00:21:57,990 --> 00:22:01,710
我不需要匹配或打印
我的 nameif 或安全级别。

353
00:22:01,710 --> 00:22:04,860
我只打印
界面，然后打印组

354
00:22:04,860 --> 00:22:09,450
0，里面有接口名
和slot，然后是group，

355
00:22:09,450 --> 00:22:12,570
三个具有 IP
地址，组 4，其中

356
00:22:12,570 --> 00:22:13,770
有面具。

357
00:22:13,770 --> 00:22:15,270
我只是要打印那个。

358
00:22:15,270 --> 00:22:17,970
对于我所有的界面，
我使用的是 findall，所以，

359
00:22:17,970 --> 00:22:20,640
基本上，我将
打印所有接口。

360
00:22:20,640 --> 00:22:22,380
事实上，让我们去
测试一下。

361
00:22:22,380 --> 00:22:28,830
我将保存这个并
重新复制到--

362
00:22:28,830 --> 00:22:32,970
让我们做一个 cd 桌面，cd rohit。

363
00:22:32,970 --> 00:22:36,090
我相信它在rohit里面——

364
00:22:36,090 --> 00:22:37,830
罗希特

365
00:22:37,830 --> 00:22:43,930
让我们去
我的 Ubuntu 机器。

366
00:22:46,830 --> 00:22:48,690
我不需要这个。

367
00:22:48,690 --> 00:22:53,890
让我们做一个密码，
我们把它复制到这里。

368
00:22:53,890 --> 00:23:03,555
所以让我们回去
对我的机架说 sftp。

369
00:23:07,290 --> 00:23:10,860
让我们做一个
put regex -lab.py。

370
00:23:15,060 --> 00:23:19,020
而且我相信它
应该是抄袭的。

371
00:23:19,020 --> 00:23:21,400
让我们回去测试一下。

372
00:23:21,400 --> 00:23:24,825
让我们做一个猫正则表达式lab.py。

373
00:23:31,210 --> 00:23:33,610
是的，我有我的剧本。

374
00:23:33,610 --> 00:23:34,810
让我们运行它。

375
00:23:34,810 --> 00:23:37,570
Python3 正则表达式-lab.py。

376
00:23:40,810 --> 00:23:44,590
我看到有问题——

377
00:23:44,590 --> 00:23:46,430
哦，我这里没有
加号。

378
00:23:46,430 --> 00:23:48,830
让我们回到我的脚本。

379
00:23:48,830 --> 00:23:54,040
我这里没有优势——

380
00:23:54,040 --> 00:23:56,770
加。

381
00:23:56,770 --> 00:24:00,220
让我们也在这里添加加号。

382
00:24:00,220 --> 00:24:06,510
让我们保存并重新复制那个
文件，放入 regex-lab.py。

383
00:24:09,190 --> 00:24:11,920
让我们返回并
重新执行它。

384
00:24:15,160 --> 00:24:17,670
所以它应该拉
信息，

385
00:24:17,670 --> 00:24:23,610
这是根据问题的
要求。

386
00:24:23,610 --> 00:24:26,670
它应该得到软件
版本和接口

387
00:24:26,670 --> 00:24:27,850
的所有路由器。

388
00:24:27,850 --> 00:24:30,180
所以我有 Rack102-R1。

389
00:24:30,180 --> 00:24:33,390
我有名称
作为接口信息。

390
00:24:33,390 --> 00:24:37,980
事实上，它并没有
得到我的界面。

391
00:24:37,980 --> 00:24:39,540
唔。

392
00:24:39,540 --> 00:24:42,210
我得到了软件版本，
所以打印了接口信息，

393
00:24:42,210 --> 00:24:44,760
但是界面并没有真正打印出来。

394
00:24:44,760 --> 00:24:47,250
所以让我们返回
测试我们的脚本

395
00:24:47,250 --> 00:24:50,770
看看问题是什么。

396
00:24:50,770 --> 00:24:54,580
那么让我们来看看这个。

397
00:24:54,580 --> 00:25:00,120
所以我有原始的
数据、接口、空间，

398
00:25:00,120 --> 00:25:04,230
我有左括号，
反斜杠 w+，

399
00:25:04,230 --> 00:25:08,940
这是任何单词
字符，反斜杠d，

400
00:25:08,940 --> 00:25:12,570
那我有什么——

401
00:25:12,570 --> 00:25:16,215
所以任何字符，反斜杠
d，所以这匹配我的插槽。

402
00:25:19,850 --> 00:25:22,760
这应该匹配。

403
00:25:22,760 --> 00:25:26,840
然后我有反斜杠 r,
这是返回字符，

404
00:25:26,840 --> 00:25:29,360
反斜杠——

405
00:25:29,360 --> 00:25:32,960
实际上，返回
字符应该是可选的。

406
00:25:32,960 --> 00:25:33,845
我们开工吧。

407
00:25:36,430 --> 00:25:39,760
反斜杠 n，反斜杠 s--

408
00:25:39,760 --> 00:25:41,420
我认为这就是问题所在。

409
00:25:41,420 --> 00:25:46,760
让我，事实上，回去
在这里也改变它

410
00:25:46,760 --> 00:25:48,260
并保存这个。

411
00:25:55,700 --> 00:25:56,975
让我们重新测试一下。

412
00:26:04,740 --> 00:26:07,230
所以现在，它显示了我的
界面信息。

413
00:26:07,230 --> 00:26:10,140
所以我只是缺少
问号，

414
00:26:10,140 --> 00:26:12,260
这是零或更多。

415
00:26:12,260 --> 00:26:15,140
所以它实际上是在寻找
返回字符

416
00:26:15,140 --> 00:26:19,850
或 Enter，
我并没有真正输入。

417
00:26:19,850 --> 00:26:21,560
所以现在，我有了
接口信息

418
00:26:21,560 --> 00:26:24,920
对于防火墙，其
gig0 为 0，具有 IP 地址，

419
00:26:24,920 --> 00:26:28,670
有掩码，有 gig0 加 1，有
IP 地址，有掩码，

420
00:26:28,670 --> 00:26:30,080
有软件版本。

421
00:26:30,080 --> 00:26:33,200
如果我查看路由器，它
有环回信息，

422
00:26:33,200 --> 00:26:36,530

也有物理接口的IP地址。

423
00:26:36,530 --> 00:26:41,150
如果我查看路由器 1，它具有
环回、gig1 和 gig3。

424
00:26:41,150 --> 00:26:43,160
它没有带 gig2
因为 gig2 没有

425
00:26:43,160 --> 00:26:44,390
有一个IP地址。

426
00:26:44,390 --> 00:26:47,060
如果我真的去添加
一个 IP 地址到 gig2，

427
00:26:47,060 --> 00:26:49,380
它也会显示 gig2。

428
00:26:49,380 --> 00:26:54,860
所以这是我的最终脚本，
基本上匹配和满足

429
00:26:54,860 --> 00:26:56,550
问题的要求。

430
00:26:56,550 --> 00:26:59,930
因此，如果您查看我用于防火墙的模式


431
00:26:59,930 --> 00:27:00,930
是不同的。

432
00:27:00,930 --> 00:27:02,840
我用于
路由器的那个不一样

433
00:27:02,840 --> 00:27:04,730
因为，再次，
输出是不同的。

434
00:27:04,730 --> 00:27:07,220
如果您查看防火墙的 show
run 命令，

435
00:27:07,220 --> 00:27:09,380
它有接口，
它有nameif，

436
00:27:09,380 --> 00:27:12,900
如果它具有安全级别，
则具有IP地址。

437
00:27:12,900 --> 00:27:18,860
但是如果你看一下路由器，
它有接口，

438
00:27:18,860 --> 00:27:20,040
然后有IP地址。

439
00:27:20,040 --> 00:27:23,390
因此，如果您查看路由器的
模式，

440
00:27:23,390 --> 00:27:28,400
我是说，好的，根据
里面的原始数据

441
00:27:28,400 --> 00:27:31,940
输出的命令，
我在说什么

442
00:27:31,940 --> 00:27:35,330
那个界面是我的
实际关键字吗

443
00:27:35,330 --> 00:27:39,200
using to match--so match
接口、空格、任意词

444
00:27:39,200 --> 00:27:41,343
字符后跟一个数字。

445
00:27:41,343 --> 00:27:43,010
然后，我有
返回字符，它

446
00:27:43,010 --> 00:27:45,230
是可选的——所以零个或多个。

447
00:27:45,230 --> 00:27:47,910
比我有反斜杠
n，零个或多个。

448
00:27:47,910 --> 00:27:51,350
我有反斜杠 s，它是零个或多个空格。

449
00:27:51,350 --> 00:27:53,390
然后我有
IP 地址命令。

450
00:27:53,390 --> 00:27:56,280
在 IP 地址中，
我这里有第 1 组。

451
00:27:56,280 --> 00:27:57,590
所以这是第 0 组。

452
00:27:57,590 --> 00:27:59,960
那么我括号中的内容，
那是我的第 0 组。

453
00:27:59,960 --> 00:28:03,350
这是第 1 组，
这是第 2 组。

454
00:28:03,350 --> 00:28:06,890
这就是我所说的
这里第 1 组和第 2 组。

455
00:28:06,890 --> 00:28:11,057
这就是我
想要打印的方式。

456
00:28:11,057 --> 00:28:12,640
但是对于防火墙，
就不一样了

457
00:28:12,640 --> 00:28:13,810
因为我必须首先——

458
00:28:13,810 --> 00:28:17,590
我的 IP 地址在 nameif
和安全级别之后。

459
00:28:17,590 --> 00:28:20,495
所以我也必须匹配那个
然后说，

460
00:28:20,495 --> 00:28:21,620
我不需要打印那个。

461
00:28:21,620 --> 00:28:24,110
所以我不会打印那个
因为我把它们分组了。

462
00:28:24,110 --> 00:28:28,480
所以使用打印命令，
我只打印组

463
00:28:28,480 --> 00:28:33,340
0、group 3、group 4，
有IP地址和掩码，

464
00:28:33,340 --> 00:28:35,860
和接口名称。

465
00:28:35,860 --> 00:28:40,870
我在我的定义中使用了一个 for 循环


466
00:28:40,870 --> 00:28:44,470
基本上扫描
所有接口，而不仅仅是

467
00:28:44,470 --> 00:28:45,560
第一次出现。

468
00:28:45,560 --> 00:28:48,970
所以我以前用 findall
而不是搜索命令。

469
00:28:48,970 --> 00:28:51,550
至此，我们基本
满足要求了

470
00:28:51,550 --> 00:28:52,700
的问题。

471
00:28:52,700 --> 00:28:54,650
我希望此视频
对您有所帮助，