1
00:00:03,437 --> 00:00:07,856
[标志嗖嗖声]

2
00:00:12,770 --> 00:00:15,182
您好，欢迎来到 INE。

3
00:00:15,182 --> 00:00:16,640
今天，在这个
视频中，我们将看看

4
00:00:16,640 --> 00:00:19,340
在使用正则表达式解析数据时。

5
00:00:19,340 --> 00:00:21,210
现在，我们再次
将做一个实验任务。

6
00:00:21,210 --> 00:00:25,170
那么让我们快速浏览一下
我们的问题要求。

7
00:00:25,170 --> 00:00:28,250
所以在这里，任务说我们需要创建一个Python脚本

8
00:00:28,250 --> 00:00:32,840
在 Ubuntu 的本地目录中称为 regex-lab.py

9
00:00:32,840 --> 00:00:33,680
机器。

10
00:00:33,680 --> 00:00:36,440
此脚本必须获取
软件版本和IP

11
00:00:36,440 --> 00:00:39,350
地址，以及任何接口的子网
掩码

12
00:00:39,350 --> 00:00:41,630
已配置 IP 地址。

13
00:00:41,630 --> 00:00:43,830
确保您匹配
给定的输出。

14
00:00:43,830 --> 00:00:47,520
所以让我们快速
看一下输出。

15
00:00:47,520 --> 00:00:49,880
所以这里我有一个
输出给我，

16
00:00:49,880 --> 00:00:54,710
上面写着
device:rack101-r1。

17
00:00:54,710 --> 00:00:57,200
显然，对您而言，它
将是您的机架号。

18
00:00:57,200 --> 00:00:59,700
整个想法是
匹配输出。

19
00:00:59,700 --> 00:01:01,760
所以我们想要主机名。

20
00:01:01,760 --> 00:01:03,830
在那之后，我们想要
一个叫做

21
00:01:03,830 --> 00:01:07,010
作为接口信息列出
所有接口列表

22
00:01:07,010 --> 00:01:08,460
它有一个IP地址。

23
00:01:08,460 --> 00:01:11,450
所以它显示了接口
loopback 0，IP地址，

24
00:01:11,450 --> 00:01:14,840
面具，界面
演出1，界面演出3，

25
00:01:14,840 --> 00:01:18,320
然后是相应路由器的软件版本
。

26
00:01:18,320 --> 00:01:21,530
现在，在这个输出中，我们
看到我们有路由器 1，

27
00:01:21,530 --> 00:01:25,570
我们有路由器 2，并且
我们有一个 ASA 防火墙。

28
00:01:25,570 --> 00:01:29,960
所以我们需要获取软件
版本和IP地址

29
00:01:29,960 --> 00:01:33,290

配置了 IP 的所有接口中的

30
00:01:33,290 --> 00:01:37,580
具有三个设备的子网掩码：路由器 1、路由器 2、

31
00:01:37,580 --> 00:01:39,320
和防火墙 1。

32
00:01:39,320 --> 00:01:40,790
因此，让我们快速执行此操作。

33
00:01:40,790 --> 00:01:43,230
现在，我建议
暂停视频，

34
00:01:43,230 --> 00:01:44,940
自己尝试一下。

35
00:01:44,940 --> 00:01:46,940
如果您有
问题，您可以随时

36
00:01:46,940 --> 00:01:50,790
回顾视频，
看看我将如何实现这一目标。

37
00:01:50,790 --> 00:01:53,340
所以让我们开始构建它。

38
00:01:53,340 --> 00:01:56,120
所以
我要做的第一件事是，

39
00:01:56,120 --> 00:02:00,740
让我们打开Atom，让我们
把这个文件保存为文件名

40
00:02:00,740 --> 00:02:02,990
我们想要的，
是regex-lab.py。

41
00:02:08,690 --> 00:02:10,740
现在，我们将开始
创建脚本。

42
00:02:10,740 --> 00:02:13,050
现在，我们需要的第一个
东西是什么？

43
00:02:13,050 --> 00:02:15,450
事实上，让我扩展一下。

44
00:02:15,450 --> 00:02:19,130
所以我们需要的第一件事是

45
00:02:19,130 --> 00:02:24,770
将从 netmiko 导入
ConnectHandler。

46
00:02:24,770 --> 00:02:25,830
所以让我们这样做。

47
00:02:25,830 --> 00:02:34,040
所以从netmiko，我会
导入ConnectHandler。

48
00:02:34,040 --> 00:02:36,170
所以这是我的第一件事


49
00:02:36,170 --> 00:02:39,770
如果我能
拼写正确的话就去做。

50
00:02:39,770 --> 00:02:40,790
连接处理程序。

51
00:02:43,940 --> 00:02:45,440
接下来
我们要做的是

52
00:02:45,440 --> 00:02:49,220
我们将导入正则表达式
模块，因为我们再次

53
00:02:49,220 --> 00:02:50,760
需要通过数据解析。

54
00:02:50,760 --> 00:02:54,140
所以我们基本上会发送
show version 命令，

55
00:02:54,140 --> 00:02:57,890
和路由器的 show interface
命令

56
00:02:57,890 --> 00:02:59,700
并获取该信息。

57
00:02:59,700 --> 00:03:02,420
所以我们需要
获取这些信息。

58
00:03:02,420 --> 00:03:05,450
我们需要发送
那些命令，获取输出，

59
00:03:05,450 --> 00:03:07,200
并解析该数据。

60
00:03:07,200 --> 00:03:09,830
所以我们需要
导入正则表达式模块。

61
00:03:09,830 --> 00:03:11,460
所以这将是
接下来的事情。

62
00:03:11,460 --> 00:03:16,535
所以 import re，这
将成为我的正则表达式模块。

63
00:03:19,460 --> 00:03:21,920
接下来，我可以
定义我的 ConnectHandlers

64
00:03:21,920 --> 00:03:25,575
连接到我的路由器 1、
路由器 2 和我的防火墙。

65
00:03:25,575 --> 00:03:27,950
现在，很明显，我需要
先去检查一下

66
00:03:27,950 --> 00:03:29,820
路由器的IP地址。

67
00:03:29,820 --> 00:03:33,330
所以我相信我
这里有路由器 1。

68
00:03:33,330 --> 00:03:35,840
让我们做一个展示IP
接口简介。

69
00:03:35,840 --> 00:03:41,990
我有一个具有
IP 地址 10.0.102.2 的演出 1。

70
00:03:41,990 --> 00:03:44,810
它有一个环回0。

71
00:03:44,810 --> 00:03:48,290
如果我回头看输出，
有一个环回 0。

72
00:03:48,290 --> 00:03:51,080
有演出 1 和演出 3。

73
00:03:51,080 --> 00:03:59,810
Gig 3 的 IP 地址为
10.10.10.1/32，实际上是 30。

74
00:03:59,810 --> 00:04:02,940
所以让我们去
添加那个接口。

75
00:04:02,940 --> 00:04:05,420
所以界面——我会
快速配置

76
00:04:05,420 --> 00:04:06,870
以匹配输出。

77
00:04:06,870 --> 00:04:10,730
所以接口gig 3,
IP地址10.10.10.--

78
00:04:10,730 --> 00:04:20,800
我相信它是 10.10.10.1，
255.255.255.252，并且没有关闭。

79
00:04:20,800 --> 00:04:23,260
所以现在，如果我做一个展示
IP接口简介，

80
00:04:23,260 --> 00:04:28,240
我有三个接口，
有一个 IP 地址：gig 1, gig 3,

81
00:04:28,240 --> 00:04:30,190
和环回0。

82
00:04:30,190 --> 00:04:31,970
Gig 2 没有
IP 地址，

83
00:04:31,970 --> 00:04:35,980
这意味着不应该
出现在输出中。

84
00:04:35,980 --> 00:04:38,810
如果您查看
输出，它只显示

85
00:04:38,810 --> 00:04:41,050
环回 0、演出 1 和演出 3。

86
00:04:41,050 --> 00:04:43,420
如果你看
问题，问题

87
00:04:43,420 --> 00:04:48,100
声明它应该只显示
IP地址和子网

88
00:04:48,100 --> 00:04:51,490

配置了IP地址的接口掩码。

89
00:04:51,490 --> 00:04:53,330
Gig 2 没有
IP 地址，

90
00:04:53,330 --> 00:04:54,980
所以它不会出现。

91
00:04:54,980 --> 00:04:56,110
我们不想要演出 2。

92
00:04:56,110 --> 00:04:58,990
我们只想要任何具有 IP 地址的接口


93
00:04:58,990 --> 00:05:01,510
和软件版本。

94
00:05:01,510 --> 00:05:04,930
所以回顾一下
输出，让我们检查一下r2。

95
00:05:04,930 --> 00:05:08,500
此外，r2 有 gig 1
并且有环回 0。

96
00:05:08,500 --> 00:05:12,580
所以让我们去路由器 2，
只是这样我们就可以设置它

97
00:05:12,580 --> 00:05:15,730
在我们开始
创建脚本之前。

98
00:05:15,730 --> 00:05:19,600
在 r2 上，让我们做一个 show
IP 接口简介。

99
00:05:19,600 --> 00:05:24,940
我有演出 1，其
IP 为 10.0.102.3。

100
00:05:24,940 --> 00:05:27,730
让我们做
interface loopback 0。

101
00:05:27,730 --> 00:05:37,648
我相信loopback
0的IP是10.101.10.1。

102
00:05:37,648 --> 00:05:49,730
所以IP地址为10.101.10.1
255.255.255.255。

103
00:05:49,730 --> 00:05:56,150
所以现在我有我的接口
gig 1 和 loopback 0，

104
00:05:56,150 --> 00:05:59,720
这将在 r2 上匹配。

105
00:05:59,720 --> 00:06:01,290
最后，我有防火墙。

106
00:06:01,290 --> 00:06:04,160
我们的防火墙有两个
接口 gig 0 x 0，

107
00:06:04,160 --> 00:06:07,130
我有 0 乘 1 的演出。

108
00:06:07,130 --> 00:06:08,400
让我们检查一下。

109
00:06:08,400 --> 00:06:15,800
所以，在防火墙 1 上，让我们做一个
show run interface gig 0 by 0。

110
00:06:15,800 --> 00:06:19,220
只是为了检查一下，在 gig 0 by 0 上的
IP 地址是什么。

111
00:06:19,220 --> 00:06:28,740
它是 10.0.102.4、10.0.101.6。

112
00:06:28,740 --> 00:06:32,330
现在，再次，您可能无法
像这样完全匹配它

113
00:06:32,330 --> 00:06:34,910
因为，再次，
IP 地址是

114
00:06:34,910 --> 00:06:38,200
将基于
您的机架号。

115
00:06:38,200 --> 00:06:39,200
所以这不是问题。

116
00:06:39,200 --> 00:06:42,050
整个想法是
获取接口——

117
00:06:42,050 --> 00:06:44,480
从界面获取信息
。

118
00:06:44,480 --> 00:06:48,350
所以我有两个接口
gig o 和 gig 1。

119
00:06:48,350 --> 00:06:52,310
让我检查一下我的第二个接口上是否有 IP
地址。

120
00:06:52,310 --> 00:06:52,970
我不。

121
00:06:52,970 --> 00:06:56,630
让我快速配置
那个接口 gig 0 by 1。

122
00:06:56,630 --> 00:07:01,145
我相信，IP 地址是 10.10.1.1。

123
00:07:01,145 --> 00:07:07,550
所以 10.10.1.1 255.255.255.0。

124
00:07:07,550 --> 00:07:14,190
Nameif，让我们给——
事实上，它是 252。

125
00:07:14,190 --> 00:07:18,690
所以让我把它改成 252。

126
00:07:18,690 --> 00:07:25,680
Nameif 可以是任何东西，让我们
说，在安全级别 100 内

127
00:07:25,680 --> 00:07:27,120
并且没有关闭。

128
00:07:27,120 --> 00:07:30,400
所以现在，显示接口 IP 简介。

129
00:07:30,400 --> 00:07:33,840
我有两个接口，
都有一个 IP 地址，

130
00:07:33,840 --> 00:07:36,690
是 gig 0 乘 0 和 gig 0 乘 1。

131
00:07:36,690 --> 00:07:40,290
我真的不关心
0乘0的内部数据

132
00:07:40,290 --> 00:07:42,520
因为我的输出
没有显示。

133
00:07:42,520 --> 00:07:44,020
所以我只关心这个。

134
00:07:44,020 --> 00:07:45,630
所以现在我的 IP
地址在那里。

135
00:07:45,630 --> 00:07:47,550
我在防火墙上有两个接口
。

136
00:07:47,550 --> 00:07:49,620
我在路由器 2 上有两个接口
，

137
00:07:49,620 --> 00:07:52,110
我在 r1 上有三个
接口。

138
00:07:52,110 --> 00:07:55,210
现在，我们可以返回并
从脚本开始。

139
00:07:55,210 --> 00:07:57,060
所以我要做的第一件事


140
00:07:57,060 --> 00:07:59,820
是，我将创建
我的 ConnectHandler，

141
00:07:59,820 --> 00:08:01,570
基本上，连接到我的路由器。

142
00:08:01,570 --> 00:08:04,650
所以这将是
r1 等于--

143
00:08:04,650 --> 00:08:11,130
让我们做 ConnectHandler，
和 IP 是

144
00:08:11,130 --> 00:08:18,690
将等于
等于 10.0.102.2，即

145
00:08:18,690 --> 00:08:24,400
是路由器 1 的 IP 地址。

146
00:08:24,400 --> 00:08:30,330
用户名等于，我相信，它是 cisco。

147
00:08:30,330 --> 00:08:36,390
然后我有密码
等于cisco。

148
00:08:36,390 --> 00:08:42,220
我有秘密等于思科。

149
00:08:42,220 --> 00:08:49,240
然后我有设备类型，
device_type 等于，我相信，

150
00:08:49,240 --> 00:08:51,790
也就是cisco _xe。

151
00:08:51,790 --> 00:08:54,280
所以我有一个XE路由器IOS XE。

152
00:08:54,280 --> 00:08:55,810
那是我的设备类型。

153
00:08:55,810 --> 00:08:57,867
那是路由器1。

154
00:08:57,867 --> 00:08:59,200
让我们做同样的事情。

155
00:08:59,200 --> 00:09:02,260
让我们为路由器 2 复制这个。

156
00:09:02,260 --> 00:09:04,270
所以这将是r2。

157
00:09:04,270 --> 00:09:06,640
我相信IP是3。

158
00:09:06,640 --> 00:09:09,430
现在，再次为你，
你的第三个八位位组

159
00:09:09,430 --> 00:09:11,600
可能是
您的机架号。

160
00:09:11,600 --> 00:09:13,990
所以我真的不关心这个。

161
00:09:13,990 --> 00:09:16,810
在这个视频中我需要
你

162
00:09:16,810 --> 00:09:19,360
你是否能够
解析数据，

163
00:09:19,360 --> 00:09:21,890
你能
获得这些信息吗？

164
00:09:21,890 --> 00:09:23,930
我真的不关心IP 地址。

165
00:09:23,930 --> 00:09:26,020
所以，只要你
能通过数据解析

166
00:09:26,020 --> 00:09:29,900
并得到信息，你的
任务基本完成。

167
00:09:29,900 --> 00:09:31,630
所以，对我来说，我的
机架号是 102。

168
00:09:31,630 --> 00:09:37,150
对你来说，它可能是
103或104或105。

169
00:09:37,150 --> 00:09:41,020
所以让我们去添加ASA。

170
00:09:41,020 --> 00:09:49,360
所以 fw1 等于-- 让我们将其添加到 fw1 的 ConnectHandler 中。

171
00:09:49,360 --> 00:09:54,310
我相信 IP 是 4，但是
让我们去验证一下。

172
00:09:54,310 --> 00:09:58,990
它是 4，10.0.102.4。

173
00:09:58,990 --> 00:10:03,190
用户名是cisco，密码
是cisco，密码是cisco，

174
00:10:03,190 --> 00:10:07,060
但设备
类型将是 asa。

175
00:10:07,060 --> 00:10:10,090
所以现在我有了我的 ConnectHandler。

176
00:10:10,090 --> 00:10:11,800
我应该能够
连接到我的路由器

177
00:10:11,800 --> 00:10:14,420
在这个时间点。

178
00:10:14,420 --> 00:10:15,650
现在，我需要什么？

179
00:10:15,650 --> 00:10:18,790
如果您仔细查看
输出，

180
00:10:18,790 --> 00:10:24,760
我需要设备主机名，并且
我需要软件版本。

181
00:10:24,760 --> 00:10:28,780
软件版本
来自 show version 命令。

182
00:10:28,780 --> 00:10:34,450
并且接口信息可以来自一个显示 IP 接口简介
，

183
00:10:34,450 --> 00:10:37,930
但问题会显示 IP
接口简介是它会

184
00:10:37,930 --> 00:10:39,310
只显示IP地址。

185
00:10:39,310 --> 00:10:41,640
它不会显示
子网掩码。

186
00:10:41,640 --> 00:10:44,500
所以一个更好的命令来
查看子网掩码

187
00:10:44,500 --> 00:10:46,270
将是一个显示界面。

188
00:10:46,270 --> 00:10:48,110
如果你回头看看路由器。

189
00:10:48,110 --> 00:10:50,740
比方说，如果我去
一个新的路由器，路由器 1，

190
00:10:50,740 --> 00:10:53,590
并做一个show IP
接口简介，

191
00:10:53,590 --> 00:10:55,280
它只显示IP地址。

192
00:10:55,280 --> 00:10:57,942
但是如果我做一个展示
界面并且——

193
00:10:57,942 --> 00:10:58,900
看显示界面。

194
00:10:58,900 --> 00:11:02,140
它向我展示了界面，
这是演出 1 或演出 2。

195
00:11:02,140 --> 00:11:06,580
它显示了 IP 地址
并显示了子网掩码，

196
00:11:06,580 --> 00:11:09,780
这是/ 24。

197
00:11:09,780 --> 00:11:13,830
或者我什至可以从 showrun 获取
信息。

198
00:11:13,830 --> 00:11:16,920
如果我做一个 showrun，在
showrunning 配置中，

199
00:11:16,920 --> 00:11:20,790
你可以看到接口
那里有接口。

200
00:11:20,790 --> 00:11:24,100
我们有 IP 地址，
我们有子网掩码。

201
00:11:24,100 --> 00:11:25,280
所以这真的取决于你。

202
00:11:25,280 --> 00:11:28,440
您可以做一个显示界面
并捕获该输出

203
00:11:28,440 --> 00:11:32,760
并解析该数据以找到子网掩码和 IP

204
00:11:32,760 --> 00:11:33,450
地址。

205
00:11:33,450 --> 00:11:36,510
将其与
一个接口相关联，或者您

206
00:11:36,510 --> 00:11:40,420
可以进行表演运行
并获得输出——

207
00:11:40,420 --> 00:11:43,950
获取与该接口关联的IP地址
使用

208
00:11:43,950 --> 00:11:45,030
显示运行命令。

209
00:11:45,030 --> 00:11:46,180
这真的取决于你。

210
00:11:46,180 --> 00:11:48,120
所以我会使用
showrun 命令

211
00:11:48,120 --> 00:11:51,100
获取接口
和IP地址。

212
00:11:51,100 --> 00:11:54,060
因此，任何具有 IP
地址的接口，我都会捕获它。

213
00:11:54,060 --> 00:11:58,170
而对于版本，我
会做showversion，

214
00:11:58,170 --> 00:12:02,620
这向我显示了我正在运行的软件
版本。

215
00:12:02,620 --> 00:12:05,850
所以如果我看
showversion，你应该

216
00:12:05,850 --> 00:12:10,030
能够看到我当前正在运行的版本
。

217
00:12:10,030 --> 00:12:17,490
所以如果你看到，我可以看到
我正在运行软件版本

218
00:12:17,490 --> 00:12:22,580
16.0.9.07。

219
00:12:22,580 --> 00:12:24,760
所以我是 16.09.07。

220
00:12:24,760 --> 00:12:25,510
那是我的版本。

221
00:12:25,510 --> 00:12:28,900
所以我需要为这个路由器捕获这个
信息。

222
00:12:28,900 --> 00:12:31,270
因此，为此，我将使用
showversion 命令。

223
00:12:31,270 --> 00:12:33,060
所以让我们现在构建它。

224
00:12:33,060 --> 00:12:37,230
所以我现在要做的是我将首先构建版本，

225
00:12:37,230 --> 00:12:41,100
但是因为接口
部分有点复杂。

226
00:12:41,100 --> 00:12:44,850
但我将首先构建一个版本
部分，我们将对其进行测试。

227
00:12:44,850 --> 00:12:47,520
我们将测试它是否有效。

228
00:12:47,520 --> 00:12:51,250
然后我们也可以添加
接口部分。

229
00:12:51,250 --> 00:12:54,210
所以让我们回到我的脚本。

230
00:12:54,210 --> 00:12:58,480
在这里，我将首先获取设备的主机名。

231
00:12:58,480 --> 00:13:01,390
我会得到设备的
版本。

232
00:13:01,390 --> 00:13:03,580
因此，为此，我将
创建两个函数。

233
00:13:03,580 --> 00:13:08,460
所以让我们创建一个函数
调用，比如说get_hostname。

234
00:13:08,460 --> 00:13:13,990
同样，这可以是任何名称，
让我们将 dev 放入其中。

235
00:13:13,990 --> 00:13:22,220
所以我有一个名为
get_hostname 的函数，它有dev。

236
00:13:22,220 --> 00:13:25,190
Dev 就像一个
临时占位符。

237
00:13:25,190 --> 00:13:26,705
让我们放一个冒号。

238
00:13:31,110 --> 00:13:36,140
所以在这里面，我
会说，dev_enable。

239
00:13:36,140 --> 00:13:38,480
所以因为一旦我
连接到路由器，

240
00:13:38,480 --> 00:13:40,790
让我运行
showversion 命令，

241
00:13:40,790 --> 00:13:42,320
我必须做一个启用。

242
00:13:42,320 --> 00:13:46,370
例如，假设
我断开此会话，

243
00:13:46,370 --> 00:13:48,170
假设我再次连接。

244
00:13:48,170 --> 00:13:50,750
当我连接
到路由器 1 时，你

245
00:13:50,750 --> 00:13:55,160
会看到我没有进入
特权模式。

246
00:13:55,160 --> 00:13:56,940
我基本上进入
非特权模式。

247
00:13:56,940 --> 00:13:59,660
所以我必须输入 enable
然后输入密码。

248
00:13:59,660 --> 00:14:03,290
所以我需要发送
enable for 实际上

249
00:14:03,290 --> 00:14:07,775
让我获得主机名
因为 showrun 管道

250
00:14:07,775 --> 00:14:09,440
部分主机名
不起作用

251
00:14:09,440 --> 00:14:10,980
从非特权模式。

252
00:14:10,980 --> 00:14:13,610
所以假设我选择 r1。

253
00:14:13,610 --> 00:14:16,680
现在，我在——让
我，事实上，退出。

254
00:14:16,680 --> 00:14:18,500
所以基本上，我
会到达这里。

255
00:14:18,500 --> 00:14:20,870
我必须输入
enable 才能真正去

256
00:14:20,870 --> 00:14:24,110
在特权
模式中，现在我

257
00:14:24,110 --> 00:14:30,560
可以通过
主机名键入 showrun 部分并获取主机名。

258
00:14:30,560 --> 00:14:32,280
所以我需要快速启用。

259
00:14:32,280 --> 00:14:38,930
所以让我们做一个 dev_enable
而在启用之后，显然，

260
00:14:38,930 --> 00:14:42,380
密码将来自这里的
secret，它已经

261
00:14:42,380 --> 00:14:44,720
已为路由器 1 提供。

262
00:14:44,720 --> 00:14:51,080
因此，让我们执行 dev_enable，并且
让我们执行 hostname equals--

263
00:14:51,080 --> 00:14:55,970
让我们发送一个命令
dev.send_command。

264
00:14:55,970 --> 00:14:58,460
让我们发送
调用的命令

265
00:14:58,460 --> 00:15:06,380
showrun 管道包括主机名。

266
00:15:06,380 --> 00:15:11,405
所以我要发送
主机名和.split。

267
00:15:11,405 --> 00:15:13,650
把它分成一组。

268
00:15:13,650 --> 00:15:17,210
现在，如果您
还记得，默认情况下，

269
00:15:17,210 --> 00:15:20,977
它会根据空格进行拆分。

270
00:15:20,977 --> 00:15:23,060
所以我没有在括号中指定
任何内容。

271
00:15:23,060 --> 00:15:31,280
我要说我
只需要列出第一名。

272
00:15:31,280 --> 00:15:34,880
所以如果你回头看，其实
在命令show hostname

273
00:15:34,880 --> 00:15:39,500
这是一个空间Rack102-R1。

274
00:15:39,500 --> 00:15:41,810
所以，它
要做的是我

275
00:15:41,810 --> 00:15:45,860
创建一个变量
称为主机名，

276
00:15:45,860 --> 00:15:47,190
我正在发送命令。

277
00:15:47,190 --> 00:15:48,924
所以无论我发送什么命令


278
00:15:48,924 --> 00:15:50,132
将其存储在变量中。

279
00:15:50,132 --> 00:15:52,760
所以 dev.send_command。

280
00:15:52,760 --> 00:15:54,680
我正在发送
命令 showrun 管道

281
00:15:54,680 --> 00:15:57,560
包括主机名，这
意味着输出将

282
00:15:57,560 --> 00:16:02,660
是主机名空间 Rack102-R1。

283
00:16:02,660 --> 00:16:06,920
我正在从列表中拆分
。

284
00:16:06,920 --> 00:16:09,740
我将基本上
只取索引

285
00:16:09,740 --> 00:16:13,160
值 1 因为索引值
0 将是主机名。

286
00:16:13,160 --> 00:16:14,610
索引值 1 是这个。

287
00:16:14,610 --> 00:16:17,420
所以我只想要
索引值1。

288
00:16:17,420 --> 00:16:20,690
只需根据空格分割它


289
00:16:20,690 --> 00:16:23,000
并且只取 ​​index
值 1，即

290
00:16:23,000 --> 00:16:24,800
意味着只有
主机名是，

291
00:16:24,800 --> 00:16:29,870
是 Rack102-R1 将
存储在主机名中。

292
00:16:29,870 --> 00:16:34,290
一旦我有了那个，
我可以说打印。

293
00:16:34,290 --> 00:16:40,400
我相信输出
是设备：Rack102。

294
00:16:40,400 --> 00:16:46,520
所以它将
成为打印设备：--

295
00:16:46,520 --> 00:16:51,815
然后我们想要加上主机名。

296
00:16:55,390 --> 00:16:58,090
我相信它应该在这里。

297
00:17:04,410 --> 00:17:07,020
所以我基本上是
说打印设备。

298
00:17:07,020 --> 00:17:08,910
设备只是一个字符串。

299
00:17:08,910 --> 00:17:11,609
设备：只是一个字符串，
加上主机名。

300
00:17:11,609 --> 00:17:16,650
主机名包含设备的主机名
，它有

301
00:17:16,650 --> 00:17:19,470
使用索引值 1 进行拆分。

302
00:17:19,470 --> 00:17:21,430
所以它包含该信息。

303
00:17:21,430 --> 00:17:24,460
所以我应该
能够打印出来。

304
00:17:24,460 --> 00:17:26,410
接下来我要
做的是创建

305
00:17:26,410 --> 00:17:30,413
多了一项功能，现在
是软件版本的时候了。

306
00:17:30,413 --> 00:17:32,080
所以让我们再创建一个
函数，叫做

307
00:17:32,080 --> 00:17:34,330
def，即定义。

308
00:17:34,330 --> 00:17:37,390
让我们做 get_version。

309
00:17:37,390 --> 00:17:41,470
再次，让我们
在其中开发。

310
00:17:41,470 --> 00:17:43,790
这又是一个
临时占位符。

311
00:17:43,790 --> 00:17:47,330
那么，在版本中，再次，
我要做什么？

312
00:17:47,330 --> 00:17:51,340
我要发送 dev.enable。

313
00:17:51,340 --> 00:17:53,380
这是我要发送的第一个
命令。

314
00:17:53,380 --> 00:17:57,980
我将重新获取主机名。

315
00:17:57,980 --> 00:18:01,990
现在，
我们想要真正采取行动是有原因的

316
00:18:01,990 --> 00:18:05,920
版本，因为这次，
我需要获取软件

317
00:18:05,920 --> 00:18:07,000
版本正确。

318
00:18:07,000 --> 00:18:08,860

软件版本的命令是什么？

319
00:18:08,860 --> 00:18:14,200
在 Cisco 路由器上，
命令是 showversion。

320
00:18:14,200 --> 00:18:19,930
它会显示软件、
版本，然后

321
00:18:19,930 --> 00:18:21,490
版本号。

322
00:18:21,490 --> 00:18:25,090
如果我查看
防火墙展示版本，

323
00:18:25,090 --> 00:18:28,540
命令是相同的，但
它显示不同。

324
00:18:28,540 --> 00:18:32,758
您将看到命令
ASA 软件版本，然后

325
00:18:32,758 --> 00:18:33,550
版本号。

326
00:18:33,550 --> 00:18:34,910
没有逗号。

327
00:18:34,910 --> 00:18:37,790
所以如果你看这个对比——

328
00:18:37,790 --> 00:18:41,380
其实看看这个
软件空间版本

329
00:18:41,380 --> 00:18:47,140
与路由器相比，
它是软件，版本。

330
00:18:47,140 --> 00:18:48,980
所以这是两个不同的东西。

331
00:18:48,980 --> 00:18:53,260
所以我需要基本上
创建一个If条件，它

332
00:18:53,260 --> 00:18:57,580
说，如果它是一个
防火墙，那么你应该

333
00:18:57,580 --> 00:19:00,100
捕获软件空间版本。

334
00:19:00,100 --> 00:19:03,760
如果是路由器，则
应捕获软件逗号

335
00:19:03,760 --> 00:19:05,620
太空版。

336
00:19:05,620 --> 00:19:07,520
所以我需要制作
一个If条件。

337
00:19:07,520 --> 00:19:11,630
所以我会根据主机名制作 If
条件。

338
00:19:11,630 --> 00:19:13,720
因此，如果主机名
包含，比方说，

339
00:19:13,720 --> 00:19:16,540
防火墙，同样，您也可以根据 IP 地址进行
。

340
00:19:16,540 --> 00:19:18,050
这真的取决于你。

341
00:19:18,050 --> 00:19:21,460
所以我知道我所有
路由器的主机名

342
00:19:21,460 --> 00:19:24,970
从 Rack102-R1 开始，
和防火墙

343
00:19:24,970 --> 00:19:27,340
开头——如果您查看
我的防火墙主机名，

344
00:19:27,340 --> 00:19:29,540
它是 Rack102-FW1。

345
00:19:29,540 --> 00:19:32,660
所以里面有一个叫做
防火墙的东西。

346
00:19:32,660 --> 00:19:36,520
所以我能做的是
回到我的脚本

347
00:19:36,520 --> 00:19:39,970
并说主机名 dev
send showrun pipe include

348
00:19:39,970 --> 00:19:41,605
主机名拆分 1。

349
00:19:41,605 --> 00:19:44,020
所以基本上，它再次捕获
主机名。

350
00:19:44,020 --> 00:19:51,610
在这里，我会说如果FW，
这是防火墙名称。

351
00:19:51,610 --> 00:19:58,420
所以如果FW在hostname.lower中，
是小写的——

352
00:19:58,420 --> 00:20:01,810
因此，如果主机名中有
FW，

353
00:20:01,810 --> 00:20:07,510
我的
防火墙主机名是 Rack102-FW1。

354
00:20:07,510 --> 00:20:09,020
所以FW就在那里。

355
00:20:09,020 --> 00:20:12,400
所以如果有FW关键字
或FW词

356
00:20:12,400 --> 00:20:18,070
在hostname.lower小写，
那我们该怎么办呢？

357
00:20:18,070 --> 00:20:26,380
我们要发送
命令调用showversion

358
00:20:26,380 --> 00:20:29,950
和抓拍软件
空间版。

359
00:20:29,950 --> 00:20:32,650
因此，为此，我将创建
另一个名为的变量，

360
00:20:32,650 --> 00:20:41,525
比方说，模式等于，
让我们做，regex.compile。

361
00:20:44,380 --> 00:20:48,550
我们会说我
需要你捕捉

362
00:20:48,550 --> 00:20:51,250
从原始数据中，
是演出版本，

363
00:20:51,250 --> 00:20:56,440
我需要你捕获
软件空间版本。

364
00:20:56,440 --> 00:21:03,010
所以原始数据，即r，
捕获软件空间版本。

365
00:21:05,520 --> 00:21:09,740
在版本之后，我需要
捕获数字，无论如何

366
00:21:09,740 --> 00:21:10,640
数是。

367
00:21:10,640 --> 00:21:13,950
如果您查看防火墙的
命令，

368
00:21:13,950 --> 00:21:18,260
它是软件版本
空格一些版本号。

369
00:21:18,260 --> 00:21:23,370
所以我能做的是
也许创建一个组。

370
00:21:23,370 --> 00:21:27,380
所以我可以创建一个组
称为任何东西

371
00:21:27,380 --> 00:21:30,410
哪个不是空白
空格，哪个

372
00:21:30,410 --> 00:21:37,880
可能像一个或多个。

373
00:21:37,880 --> 00:21:40,850
所以基本上不是
空格的任何东西。

374
00:21:40,850 --> 00:21:49,420
让我们返回
并关闭我的报价。

375
00:21:49,420 --> 00:21:52,360
所以我有软件版本。

376
00:21:52,360 --> 00:21:54,730
我有一个小组，
什么都说

377
00:21:54,730 --> 00:22:00,070
这不是空格
并关闭我的括号。

378
00:22:00,070 --> 00:22:05,260
好的，现在问题是我将如何
捕捉它？

379
00:22:05,260 --> 00:22:08,300
通过发送命令
调用showversion。

380
00:22:08,300 --> 00:22:11,750
所以我需要 showversion
也在那里。

381
00:22:11,750 --> 00:22:14,050
所以我会创建
一个更多变量。

382
00:22:14,050 --> 00:22:19,400
假设输出等于 dev_--

383
00:22:19,400 --> 00:22:21,132
哦，dev.send_command。

384
00:22:25,550 --> 00:22:32,840
我们希望发送名为 showversion 的
命令。

385
00:22:36,650 --> 00:22:38,890
所以我要发送showversion。

386
00:22:38,890 --> 00:22:43,450
我正在发送 showrun
管道包括主机名。

387
00:22:43,450 --> 00:22:45,640
主机名在
变量主机名中。

388
00:22:45,640 --> 00:22:48,730
showversion 将
在输出中被捕获。

389
00:22:48,730 --> 00:22:52,040
现在我说如果防火墙
在hostname.lower中，

390
00:22:52,040 --> 00:22:56,800
然后我想捕获软件
版本空间中的任何东西

391
00:22:56,800 --> 00:22:59,950
不是空格。

392
00:22:59,950 --> 00:23:04,250
然后我会有一个 Else
语句，否则用于路由器。

393
00:23:04,250 --> 00:23:08,470
所以其他-- 让我们
放同样的东西。

394
00:23:14,600 --> 00:23:19,000
这将是
软件，太空版

395
00:23:19,000 --> 00:23:22,250
捕捉它。

396
00:23:22,250 --> 00:23:26,810
现在我们要打印它。

397
00:23:26,810 --> 00:23:29,500
所以我必须基本上
搜索——

398
00:23:29,500 --> 00:23:32,210
我需要通过数据解析
。

399
00:23:32,210 --> 00:23:35,200
所以这将通过说版本来完成


400
00:23:35,200 --> 00:23:38,800
再次，创建一个
变量version_match

401
00:23:38,800 --> 00:23:43,330
等于模式搜索。

402
00:23:43,330 --> 00:23:47,050
现在，我可以使用 find
all，也可以使用搜索。

403
00:23:47,050 --> 00:23:49,210
不同的是，
有了搜索，它只

404
00:23:49,210 --> 00:23:53,710
搜索模式的第一个
出现。

405
00:23:53,710 --> 00:23:56,380
所以这意味着软件版本的第一次
出现

406
00:23:56,380 --> 00:23:57,490
它会匹配的。

407
00:23:57,490 --> 00:24:00,400
但如果我确实找到了所有，它
匹配所有出现

408
00:24:00,400 --> 00:24:03,160
的关键字软件版本。

409
00:24:03,160 --> 00:24:06,100
那么pattern.search 搜索什么？

410
00:24:06,100 --> 00:24:08,230
在输出中搜索。

411
00:24:08,230 --> 00:24:11,840
输出是我的变量，
包含显示版本。

412
00:24:11,840 --> 00:24:25,810
然后我们可以说
打印软件版本：

413
00:24:25,810 --> 00:24:27,180
将是 -

414
00:24:29,770 --> 00:24:34,470
所以软件版本加上
version_match.group。

415
00:24:40,660 --> 00:24:44,890
我的组将是 1。

416
00:24:44,890 --> 00:24:45,520
就是这样。

417
00:24:45,520 --> 00:24:46,870
我认为这应该足够了。

418
00:24:46,870 --> 00:24:48,640
如果你回头看
我的剧本，它

419
00:24:48,640 --> 00:24:52,010
表示软件空间版本：
和版本号。

420
00:24:52,010 --> 00:24:54,770
所以这应该
足够了，这个脚本，

421
00:24:54,770 --> 00:24:58,910
这基本上说明了这个命令将如何发生？

422
00:24:58,910 --> 00:25:01,120
所以当这个函数
要被调用时，

423
00:25:01,120 --> 00:25:02,590
它将发送启用。

424
00:25:02,590 --> 00:25:05,170
它将捕获主机名中的
主机名。

425
00:25:05,170 --> 00:25:07,690
它将捕获
showversion的输出

426
00:25:07,690 --> 00:25:09,520
内输出。

427
00:25:09,520 --> 00:25:16,030
然后版本匹配将
扫描输出，

428
00:25:16,030 --> 00:25:19,150
以及他
将根据哪个命令扫描

429
00:25:19,150 --> 00:25:22,810
如果主机名包含 FW？

430
00:25:22,810 --> 00:25:26,140
然后他会扫描
软件空间版本。

431
00:25:26,140 --> 00:25:29,800
如果主机名中不是firewall
，

432
00:25:29,800 --> 00:25:33,160
然后他会搜索
软件、版本，然后

433
00:25:33,160 --> 00:25:34,990
数字。

434
00:25:34,990 --> 00:25:38,860
然后我说
打印软件版本

435
00:25:38,860 --> 00:25:41,150
只是一个字符串。

436
00:25:41,150 --> 00:25:44,320
这应该
事实上，加号。

437
00:25:44,320 --> 00:25:48,330
所以加上version_match，
这是第1组。

438
00:25:48,330 --> 00:25:49,510
现在，什么是第 1 组？

439
00:25:49,510 --> 00:25:52,210
第 1 组是我的字符串。

440
00:25:52,210 --> 00:25:55,310
第 1 组是我的非空白
，它在一个组内。

441
00:25:55,310 --> 00:25:58,270
所以版本号，
正在被捕获

442
00:25:58,270 --> 00:26:00,740
将被显示。

443
00:26:00,740 --> 00:26:04,850
现在，假设我没有
把它放到组中。

444
00:26:04,850 --> 00:26:08,050
假设我给了
类似的东西——

445
00:26:08,050 --> 00:26:09,850
事实上，让我复制一下。

446
00:26:09,850 --> 00:26:12,040
假设我
没有组团，

447
00:26:12,040 --> 00:26:13,450
我只是给了这样的东西。

448
00:26:13,450 --> 00:26:19,640
加上version_match，
我没有创建组。

449
00:26:19,640 --> 00:26:25,400
我给了这样的东西。

450
00:26:25,400 --> 00:26:29,390
在那种情况下，我的
输出会是什么？

451
00:26:29,390 --> 00:26:33,710
软件版本：和
这里，version_match

452
00:26:33,710 --> 00:26:39,710
将捕获整个事物，
这意味着软件、版本、

453
00:26:39,710 --> 00:26:41,240
然后是版本号。

454
00:26:41,240 --> 00:26:44,970
根据我的
输出，我想要的是软件版本，

455
00:26:44,970 --> 00:26:46,230
这只是一个字符串。

456
00:26:46,230 --> 00:26:47,960
然后我想要那个
只是数字。

457
00:26:47,960 --> 00:26:50,190
我只想
捕获号码。

458
00:26:50,190 --> 00:26:57,020
所以这就是
我给小组的原因。

459
00:26:57,020 --> 00:27:01,370
我正在创建一个组以匹配我的非空格，

460
00:27:01,370 --> 00:27:03,890
并将其放入群组
并呼叫群组号码

461
00:27:03,890 --> 00:27:07,010
这里有一个，上面写着，
好的，软件版本：

462
00:27:07,010 --> 00:27:08,660
版本号。

463
00:27:08,660 --> 00:27:15,670
版本号在此处被
捕获或解析。

464
00:27:15,670 --> 00:27:19,510
我们会说--
我们基本上会打电话给

465
00:27:19,510 --> 00:27:21,148
在打印语句中。

466
00:27:21,148 --> 00:27:22,190
所以这应该足够了。

467
00:27:22,190 --> 00:27:25,190
现在让我们使用 for 循环调用我们的
函数。

468
00:27:25,190 --> 00:27:30,410
所以让我们在设备中做一个for
设备。

469
00:27:34,820 --> 00:27:38,020
在这里，我会说打印。

470
00:27:38,020 --> 00:27:39,310
我要打印什么？

471
00:27:39,310 --> 00:27:43,600
如果我查看我的输出，
我有一些哈希值

472
00:27:43,600 --> 00:27:45,200
在主机名之前。

473
00:27:45,200 --> 00:27:46,480
所以让我们放一些哈希。

474
00:27:46,480 --> 00:27:51,850
所以打印——让我们
放一些哈希值。

475
00:27:51,850 --> 00:27:57,130
所以先打印这个，
然后执行函数

476
00:27:57,130 --> 00:28:00,130
这是获取主机名。

477
00:28:00,130 --> 00:28:08,380
再一次，打印这个，这
意味着我会有哈希值，

478
00:28:08,380 --> 00:28:12,070
然后我会有主机名。

479
00:28:12,070 --> 00:28:17,060
这基本上会说
设备：加上主机名。

480
00:28:17,060 --> 00:28:20,680
它基本上执行了那个，
然后我又得到了哈希值。

481
00:28:20,680 --> 00:28:23,210
我们想要
获取的下一件事是版本。

482
00:28:23,210 --> 00:28:24,940
所以让我们做get_version。

483
00:28:27,490 --> 00:28:31,990
事实上，在 get
主机名中，我应该说 device.

484
00:28:35,330 --> 00:28:38,560
所以获取主机名 - 所以
对于设备中的设备，

485
00:28:38,560 --> 00:28:40,450
获取主机名是
设备，基本上就是

486
00:28:40,450 --> 00:28:45,490
表示我基于此连接到的任何设备，

487
00:28:45,490 --> 00:28:48,980
它应该执行该功能。

488
00:28:48,980 --> 00:28:55,280
获取版本设备，我认为应该足够了。

489
00:28:55,280 --> 00:29:03,040
让我们为空行做一个 print/n
。

490
00:29:03,040 --> 00:29:04,870
让我们断开连接。

491
00:29:07,520 --> 00:29:09,680
所以device.disconnect。

492
00:29:16,630 --> 00:29:17,880
我认为这应该足够了。

493
00:29:17,880 --> 00:29:22,070
让我们保存一下，
让我复制一下。

494
00:29:26,250 --> 00:29:29,620
让我们放置 regex-lab.py。

495
00:29:34,200 --> 00:29:40,260
好的，现在我的 Ubuntu 机器上有我的
脚本。

496
00:29:40,260 --> 00:29:44,910
如果我做 Ls，我应该
有 regex-lab.py。

497
00:29:44,910 --> 00:29:52,290
让我们做 Python3 regex-lab.py
并执行这个脚本

498
00:29:52,290 --> 00:29:54,070
看看它是否有效。

499
00:29:54,070 --> 00:29:56,670
所以它应该打印
我的主机名。

500
00:29:56,670 --> 00:30:03,483
它应该为我打印设备的软件
版本。

501
00:30:03,483 --> 00:30:05,650
此时它不会打印 IP 地址
。

502
00:30:05,650 --> 00:30:09,840
所以它说它在设备中的设备失败
。

503
00:30:09,840 --> 00:30:13,420
未定义命名设备。

504
00:30:13,420 --> 00:30:17,670
我没有定义。

505
00:30:17,670 --> 00:30:19,950
事实上，让我来定义它。

506
00:30:19,950 --> 00:30:21,850
让我回到我的剧本。

507
00:30:21,850 --> 00:30:23,867
我没有在这里。

508
00:30:23,867 --> 00:30:25,450
所以我有所有这些
连接正确，

509
00:30:25,450 --> 00:30:29,190
所以让我创建一个变量
称为 devices equals--

510
00:30:29,190 --> 00:30:36,120
我有我的路由器 1、
路由器 2 和防火墙 1。

511
00:30:36,120 --> 00:30:38,530
好的，让我们保存这个。

512
00:30:38,530 --> 00:30:40,050
所以我实际上
在这里做的是

513
00:30:40,050 --> 00:30:43,060
我说的是获取主机名设备。

514
00:30:43,060 --> 00:30:48,690
所以对于设备中的设备，
即r1、r2和防火墙1

515
00:30:48,690 --> 00:30:49,950
获取主机名。

516
00:30:49,950 --> 00:30:53,370
所以基本上，它得到
路由器1的主机名，

517
00:30:53,370 --> 00:30:55,470
获取路由器 2 的主机名
，获取

518
00:30:55,470 --> 00:30:59,160
防火墙 1 的主机名。

519
00:30:59,160 --> 00:31:02,190
然后我说
获取版本。

520
00:31:02,190 --> 00:31:06,570
于是得到了
防火墙和路由器1的版本，

521
00:31:06,570 --> 00:31:07,290
和路由器2。

522
00:31:07,290 --> 00:31:11,790
如果主机名包含
防火墙，它将扫描--

523
00:31:11,790 --> 00:31:14,640
它将通过数据
使用命令软件

524
00:31:14,640 --> 00:31:19,020
空格版本，然后是任何
非空白字符。

525
00:31:19,020 --> 00:31:22,110
如果是路由器，它
做软件，版本

526
00:31:22,110 --> 00:31:24,330
和任何非空白
字符。

527
00:31:24,330 --> 00:31:27,510
并打印软件版本：
加version_match，

528
00:31:27,510 --> 00:31:29,560
这是第1组，
仅表示此。

529
00:31:29,560 --> 00:31:31,560
所以我并没有真正
打印整件事。

530
00:31:31,560 --> 00:31:33,450
我只打印这部分。

531
00:31:33,450 --> 00:31:35,700
无论
版本号是什么，我都是

532
00:31:35,700 --> 00:31:39,390
在此处打印
使用组 1。

533
00:31:39,390 --> 00:31:43,660
让我们保存并重新复制它。

534
00:31:43,660 --> 00:31:51,750
让我们执行一个 put regex-lab.py，然后
让我们重新执行该脚本。

535
00:31:51,750 --> 00:31:58,080
让我们做一个明确的并
重新执行脚本。

536
00:31:58,080 --> 00:32:00,450
它现在应该连接
到路由器

537
00:32:00,450 --> 00:32:07,125
并且应该打印主机名
和软件版本。

538
00:32:09,830 --> 00:32:17,030
它说我没有定义
dev_enable。

539
00:32:17,030 --> 00:32:24,180
让我们回到脚本
看看错误是什么。

540
00:32:24,180 --> 00:32:26,750
好的，所以我有——

541
00:32:26,750 --> 00:32:30,200
我相信，我的
ConnectHandler 没问题。

542
00:32:30,200 --> 00:32:34,010
获取主机名 dev_enable。

543
00:32:34,010 --> 00:32:37,010
其实是开发..

544
00:32:37,010 --> 00:32:41,355
它不应该是
dev_、dev.enable。

545
00:32:41,355 --> 00:32:45,810
让我们重新检查
其他所有内容。

546
00:32:45,810 --> 00:32:47,720
看起来不错。