1
00:00:03,493 --> 00:00:07,984
[电子音乐]

2
00:00:09,990 --> 00:00:12,510
您好，欢迎来到 INE。

3
00:00:12,510 --> 00:00:15,120
今天在这个视频中，我们将
看看内置输入

4
00:00:15,120 --> 00:00:15,690
功能。

5
00:00:15,690 --> 00:00:17,820
基本上，我们会
做一个实验任务。

6
00:00:17,820 --> 00:00:20,880
那么让我们快速浏览一下
我们的问题要求。

7
00:00:20,880 --> 00:00:23,880
现在，这个问题变得有点困难了。

8
00:00:23,880 --> 00:00:26,400
我真的希望你们
试一试

9
00:00:26,400 --> 00:00:27,960
不看解决方案。

10
00:00:27,960 --> 00:00:29,400
我想让你们试试看。

11
00:00:29,400 --> 00:00:31,470
我有一些
东西

12
00:00:31,470 --> 00:00:33,510
在这个你
还没有真正学过的问题中，

13
00:00:33,510 --> 00:00:36,010
但我还是希望你
考虑一下。

14
00:00:36,010 --> 00:00:38,610
那么让我们来看看
题型要求。

15
00:00:38,610 --> 00:00:42,510
它说创建一个名为 Lab11.py 的 Python
脚本

16
00:00:42,510 --> 00:00:45,060
在相应的
文件夹中，以及此脚本

17
00:00:45,060 --> 00:00:46,860
必须完成以下工作。

18
00:00:46,860 --> 00:00:49,930
它必须要求用户提供
输入，

19
00:00:49,930 --> 00:00:51,780
例如输入
路由器显示

20
00:00:51,780 --> 00:00:53,910
要显示的命令。

21
00:00:53,910 --> 00:00:56,690
它还应该要求
用户输入，

22
00:00:56,690 --> 00:00:58,680
例如输入
防火墙显示

23
00:00:58,680 --> 00:01:00,690
要显示的命令。

24
00:01:00,690 --> 00:01:04,860
连接到每个设备、
R1、R2 和防火墙。

25
00:01:04,860 --> 00:01:06,840
打印请求的输出。

26
00:01:06,840 --> 00:01:10,470
确保脚本要求
用户名和密码

27
00:01:10,470 --> 00:01:11,980
连接到这些设备。

28
00:01:11,980 --> 00:01:15,120
所以它基本上必须提示
您输入用户名/密码。

29
00:01:15,120 --> 00:01:19,150
您必须使用 for 循环和
函数来完成此任务。

30
00:01:19,150 --> 00:01:22,750
一旦
您匹配了输出，您的任务就完成了。

31
00:01:22,750 --> 00:01:25,330
那么让我们来看看
输出。

32
00:01:25,330 --> 00:01:30,030
因此，这是您需要匹配的
输出。

33
00:01:30,030 --> 00:01:32,040
所以第一件事，
基本上应该

34
00:01:32,040 --> 00:01:34,680
给你一个输入
问题，

35
00:01:34,680 --> 00:01:36,990
将要输入
路由器显示命令

36
00:01:36,990 --> 00:01:38,310
你想显示。

37
00:01:38,310 --> 00:01:42,060
然后你会输入 show
ip interface brief。

38
00:01:42,060 --> 00:01:44,550
然后它说，输入
firewall show 命令

39
00:01:44,550 --> 00:01:45,590
你想显示。

40
00:01:45,590 --> 00:01:49,560
您将输入 show
interface ip brief。

41
00:01:49,560 --> 00:01:52,000
然后它应该要求您
输入用户名/密码。

42
00:01:52,000 --> 00:01:54,000
一旦您
通过身份验证，它

43
00:01:54,000 --> 00:01:57,810
应该显示您请求的命令
。

44
00:01:57,810 --> 00:02:00,090
但是，在它
显示之前，它还应该

45
00:02:00,090 --> 00:02:02,580
给你一个打印
声明说，

46
00:02:02,580 --> 00:02:06,720
这是Rack102-R1的输出
，

47
00:02:06,720 --> 00:02:10,199
这是Rack102-R2的输出
，

48
00:02:10,199 --> 00:02:14,400
然后这是 Rack102 dash firewall 1 的输出
。

49
00:02:14,400 --> 00:02:16,140
现在，这是从哪里来的？

50
00:02:16,140 --> 00:02:18,280
这是来自主机名的
。

51
00:02:18,280 --> 00:02:22,800
所以我希望你通过获取信息来做到这一点，

52
00:02:22,800 --> 00:02:24,720
获取设备的主机名
，

53
00:02:24,720 --> 00:02:26,680
并打印该值。

54
00:02:26,680 --> 00:02:29,720
所以无论主机名是什么，
它实际上都会打印出来。

55
00:02:29,720 --> 00:02:34,270
所以请注意，这不仅仅是一个简单的打印语句。

56
00:02:34,270 --> 00:02:38,130
必须通过从路由器获取
信息来完成，

57
00:02:38,130 --> 00:02:40,300
获取设备的主机名
。

58
00:02:40,300 --> 00:02:43,350
因此，如果主机名更改，
您的输出打印语句

59
00:02:43,350 --> 00:02:44,590
会有所不同。

60
00:02:44,590 --> 00:02:48,190
所以它必须基于主机名来完成。

61
00:02:48,190 --> 00:02:50,200
所以试试这个。

62
00:02:50,200 --> 00:02:51,040
暂停视频。

63
00:02:51,040 --> 00:02:52,600
自己尝试一下。

64
00:02:52,600 --> 00:02:55,080
如果你被卡住了，你可以
总是回看我的视频

65
00:02:55,080 --> 00:02:57,850
看看我是如何实现的。

66
00:02:57,850 --> 00:03:01,930
那么现在让我向您展示
我将如何做到这一点。

67
00:03:01,930 --> 00:03:05,910
所以我会去
我的 Atom 并创建

68
00:03:05,910 --> 00:03:12,580
一个名为 Lab11.py 的文件，
我将在这里编写一个脚本。

69
00:03:12,580 --> 00:03:14,550
现在，其实有
两种不同的方式

70
00:03:14,550 --> 00:03:16,230
我可以做到这一点。

71
00:03:16,230 --> 00:03:20,610
我可以把这个脚本变成
一个非常静态的脚本

72
00:03:20,610 --> 00:03:22,290
符合问题
要求，

73
00:03:22,290 --> 00:03:24,360
给我完全
相同的输出，

74
00:03:24,360 --> 00:03:26,250
但这将是非常静态的。

75
00:03:26,250 --> 00:03:29,700
这意味着如果我的设备数量
增加

76
00:03:29,700 --> 00:03:32,250
如果我的
防火墙数量增加，

77
00:03:32,250 --> 00:03:34,270
我会有问题。

78
00:03:34,270 --> 00:03:35,970
第二种方法是


79
00:03:35,970 --> 00:03:38,320
可扩展的方式。

80
00:03:38,320 --> 00:03:39,720
我会告诉你两个。

81
00:03:39,720 --> 00:03:42,480
所以我们先用
静态的方式来做。

82
00:03:42,480 --> 00:03:44,760
我的问题是我
必须使用 for 循环，

83
00:03:44,760 --> 00:03:46,480
我必须使用一个定义。

84
00:03:46,480 --> 00:03:50,876
所以我会先用静态的方式


85
00:03:50,876 --> 00:03:53,890
然后我将向您展示
可扩展的实现方式。

86
00:03:53,890 --> 00:03:55,030
所以让我们开始吧。

87
00:03:55,030 --> 00:03:56,760
所以我要做的第一件事


88
00:03:56,760 --> 00:04:01,020
是，从 netmiko 我将
导入 ConnectHandler。

89
00:04:01,020 --> 00:04:09,060
所以从 netmiko 让我们
导入 ConnectHandler。

90
00:04:09,060 --> 00:04:14,610
接下来我
会说——

91
00:04:14,610 --> 00:04:17,430
我会说导入getpass。

92
00:04:17,430 --> 00:04:20,440
现在，这是
你还没有真正学到的东西，

93
00:04:20,440 --> 00:04:21,510
这是getpass。

94
00:04:21,510 --> 00:04:24,960
现在，为什么我们需要
来做import getpass？

95
00:04:24,960 --> 00:04:28,080
Getpass 是一个可用的内置
模块

96
00:04:28,080 --> 00:04:29,730
你可以导入。

97
00:04:29,730 --> 00:04:34,980
基本上，如果您想询问
用户名作为输入，

98
00:04:34,980 --> 00:04:37,230
和一个密码作为
输入，那么你

99
00:04:37,230 --> 00:04:40,470
可以导入这个模块，
称为getpass。

100
00:04:40,470 --> 00:04:43,320
如果您还记得，请看
我们之前所有的视频，

101
00:04:43,320 --> 00:04:46,830
当我们为连接创建
ConnectHandler

102
00:04:46,830 --> 00:04:49,320
对于路由器，我们
实际上是在指定

103
00:04:49,320 --> 00:04:53,740
该变量中的用户名/密码
。

104
00:04:53,740 --> 00:04:55,350
所以我们在
ConnectHandler里面。

105
00:04:55,350 --> 00:04:57,360
我们指定
用户名/密码。

106
00:04:57,360 --> 00:05:00,480
但想象一下，如果我真的
把剧本交给某人

107
00:05:00,480 --> 00:05:01,980
他打开脚本。

108
00:05:01,980 --> 00:05:04,260
他会看到我的
用户名/密码。

109
00:05:04,260 --> 00:05:05,410
你不想要那个。

110
00:05:05,410 --> 00:05:09,130
因此，您希望他们
输入他们的用户名/密码。

111
00:05:09,130 --> 00:05:11,850
因此，如果他们在某处有一个
RADIUS 服务器

112
00:05:11,850 --> 00:05:14,370
如果他们有
用户名/密码，

113
00:05:14,370 --> 00:05:16,530
然后他们可以使用
他们的用户名/密码登录。

114
00:05:16,530 --> 00:05:19,740
您无需向他们提供
您的用户名/密码。

115
00:05:19,740 --> 00:05:22,530
所以因为我的问题说
它应该提示你

116
00:05:22,530 --> 00:05:24,720
对于用户名/密码，
我不会

117
00:05:24,720 --> 00:05:28,170
将用户名/密码
放在 ConnectHandler 中。

118
00:05:28,170 --> 00:05:31,410
这就是为什么我要
导入getpass。

119
00:05:31,410 --> 00:05:34,650
接下来我要做的
是创建一个输入函数，

120
00:05:34,650 --> 00:05:36,910
因为我想问他们两个问题。

121
00:05:36,910 --> 00:05:40,710
第一个问题是输入
路由器显示命令

122
00:05:40,710 --> 00:05:42,280
你想显示的。

123
00:05:42,280 --> 00:05:46,200
第二个是输入
防火墙显示命令

124
00:05:46,200 --> 00:05:47,770
你想显示的。

125
00:05:47,770 --> 00:05:50,670
所以我会——

126
00:05:50,670 --> 00:05:53,580
我会创建两个变量，
基本上

127
00:05:53,580 --> 00:05:54,970
是一个输入函数。

128
00:05:54,970 --> 00:05:55,690
所以让我们这样做。

129
00:05:55,690 --> 00:06:00,880
假设 rtr_cmd 等于--

130
00:06:00,880 --> 00:06:03,290
我会说输入——

131
00:06:03,290 --> 00:06:06,400
所以这将是一个输入——

132
00:06:06,400 --> 00:06:08,000
我们可以把我们的字符串放在那里。

133
00:06:08,000 --> 00:06:13,600
所以输入路由器
show命令——

134
00:06:13,600 --> 00:06:16,240
我相信是
你要展示的，

135
00:06:16,240 --> 00:06:18,590
你想显示的。

136
00:06:18,590 --> 00:06:25,820
让你想显示，
问号和空格，

137
00:06:25,820 --> 00:06:30,560
只是让我们在实际值之间有一个空格


138
00:06:30,560 --> 00:06:31,790
他进入。

139
00:06:31,790 --> 00:06:34,050
否则，他们会
粘在一起。

140
00:06:34,050 --> 00:06:37,910
所以如果你真的看到这里，
之间的show ip界面

141
00:06:37,910 --> 00:06:40,820
简介，这是用户将提供的输入
，

142
00:06:40,820 --> 00:06:44,010
和实际的问题，
他们之间有一个空格。

143
00:06:44,010 --> 00:06:46,940
所以我要创建
一个字符串，上面写着，

144
00:06:46,940 --> 00:06:49,665
输入要显示的路由器显示命令
。

145
00:06:49,665 --> 00:06:52,040
我在那里放了一个空格，
然后结束我的引用

146
00:06:52,040 --> 00:06:53,870
并结束我的括号。

147
00:06:53,870 --> 00:06:56,900
这是我的第一个输入命令。

148
00:06:56,900 --> 00:06:59,450
第二个是
防火墙命令。

149
00:06:59,450 --> 00:07:05,210
所以 fw_cmd 等于-- 让我们
输入--

150
00:07:05,210 --> 00:07:08,960
我相信这将是相同的
事情，除了事实会

151
00:07:08,960 --> 00:07:13,560
如果这会是——

152
00:07:13,560 --> 00:07:17,400
我应该用双引号和双引号括起来。

153
00:07:17,400 --> 00:07:21,330
进入防火墙
show命令

154
00:07:21,330 --> 00:07:22,840
你想显示的。

155
00:07:22,840 --> 00:07:27,310
所以现在我有了我的
两个输入变量。

156
00:07:27,310 --> 00:07:30,150
所以我创建了
我的输入函数。

157
00:07:30,150 --> 00:07:34,470
它会问这个问题，
它会期待

158
00:07:34,470 --> 00:07:37,690
你输入一些命令。

159
00:07:37,690 --> 00:07:38,650
让我们按 Enter。

160
00:07:38,650 --> 00:07:41,270
接下来我要做的是创建一个函数，

161
00:07:41,270 --> 00:07:43,375
这将基于-

162
00:07:46,960 --> 00:07:50,290
这将基于它是
防火墙还是路由器。

163
00:07:50,290 --> 00:07:53,620
因为我的
防火墙命令不同。

164
00:07:53,620 --> 00:07:55,900
我对路由器的命令，
那是不同的。

165
00:07:55,900 --> 00:08:01,420
我的意思是，思科，如果你看看
思科，思科非常——

166
00:08:01,420 --> 00:08:02,733
如果你能说——

167
00:08:02,733 --> 00:08:04,150
我不知道我是否应该
这样说，

168
00:08:04,150 --> 00:08:10,510
但 Cisco 路由器命令、
ASA 命令、Nexus 命令、

169
00:08:10,510 --> 00:08:12,250
切换命令，
它们都是不同的

170
00:08:12,250 --> 00:08:14,420
取决于您正在运行的平台
。

171
00:08:14,420 --> 00:08:20,170
所以IOS XE和IOS XR，它们可能都有不同的命令。

172
00:08:20,170 --> 00:08:24,550
这就是为什么我需要匹配
我要输入什么命令

173
00:08:24,550 --> 00:08:27,070
基于设备类型。

174
00:08:27,070 --> 00:08:28,570
所以我要去
要做的是我要去

175
00:08:28,570 --> 00:08:31,442
立即创建一个函数
，因为你

176
00:08:31,442 --> 00:08:34,809
知道思科在不一致方面是非常一致的。

177
00:08:34,809 --> 00:08:37,429
所以我要做的是创建一个函数。

178
00:08:37,429 --> 00:08:42,455
所以def--让我们说
我会说路由器--

179
00:08:45,300 --> 00:08:46,965
哦，让我们做 get_rtr_cmd。

180
00:08:50,500 --> 00:08:52,000
同样，这只是
一个函数名。

181
00:08:52,000 --> 00:08:54,090
它可以是您想要的任何
名称。

182
00:08:54,090 --> 00:08:57,120
然后，在这个里面，我会
有我的临时占位符，

183
00:08:57,120 --> 00:08:58,650
这是开发。

184
00:08:58,650 --> 00:09:02,400
所以我有一个函数
叫做get_rtr_cmd，

185
00:09:02,400 --> 00:09:04,680
我的临时
占位符是 dev。

186
00:09:04,680 --> 00:09:06,540
在此，我将提出一个条件。

187
00:09:06,540 --> 00:09:11,370
如果 dev 等于 等于--

188
00:09:11,370 --> 00:09:15,720
如果等于等于fw1，
如果是防火墙1--

189
00:09:15,720 --> 00:09:19,920
我将定义这个
变量或这个名字

190
00:09:19,920 --> 00:09:22,170
稍后当我创建
我的 ConnectHandler 时。

191
00:09:22,170 --> 00:09:26,640
所以如果dev等于equals
fw1，那么什么命令

192
00:09:26,640 --> 00:09:27,990
我要执行吗？

193
00:09:27,990 --> 00:09:31,650
我想执行
dev.enable 来做

194
00:09:31,650 --> 00:09:33,570
启用到 ASA 防火墙。

195
00:09:33,570 --> 00:09:36,420
我想做
终端长度为0。

196
00:09:36,420 --> 00:09:39,930
如果您还记得，ASA 的命令
是终端页面 0。

197
00:09:39,930 --> 00:09:43,980
所以我会说 dev.send_command。

198
00:09:43,980 --> 00:09:49,570
我将
发送的命令将是终端页面 0。

199
00:09:52,440 --> 00:09:53,100
点击输入。

200
00:09:53,100 --> 00:09:59,850
我想要
执行的下一个命令是我想向他们发送--

201
00:09:59,850 --> 00:10:03,090
我希望他们发送
任何命令

202
00:10:03,090 --> 00:10:08,020
由用户
在输入函数中输入。

203
00:10:08,020 --> 00:10:11,470
该命令需要发送
到防火墙执行。

204
00:10:11,470 --> 00:10:14,350
所以我会说输出——

205
00:10:14,350 --> 00:10:18,280
所以输出等于--再次，
因为我想捕获它。

206
00:10:18,280 --> 00:10:23,920
所以输出等于
dev.send_command，

207
00:10:23,920 --> 00:10:29,020
我想把我的——

208
00:10:29,020 --> 00:10:34,630
这个实例名，这个
变量名，就是fw_cmd。

209
00:10:34,630 --> 00:10:40,000
所以无论他在
输入函数里面输入什么

210
00:10:40,000 --> 00:10:43,300
被称为 fw_cmd，这是我要发送的命令。

211
00:10:43,300 --> 00:10:46,630
因此，如果我确实显示运行，它会将
显示运行发送到防火墙。

212
00:10:46,630 --> 00:10:48,580
如果我确实显示 ip
interface brief，它

213
00:10:48,580 --> 00:10:52,340
向防火墙发送 show ip interface
简介。

214
00:10:52,340 --> 00:10:57,680
接下来我要
做的是我需要打印——

215
00:10:57,680 --> 00:11:01,190
在我打印这个
输出之前，我需要发送——

216
00:11:01,190 --> 00:11:02,270
我需要打印这个。

217
00:11:02,270 --> 00:11:03,890
如果你看
问题，我需要

218
00:11:03,890 --> 00:11:05,450
打印 this
值，即 This

219
00:11:05,450 --> 00:11:08,640
是防火墙的输出。

220
00:11:08,640 --> 00:11:13,340
因此，为此，我需要获取
防火墙的主机名。

221
00:11:13,340 --> 00:11:16,740
要获取主机名，我
会再次说主机名，

222
00:11:16,740 --> 00:11:20,550
只是一个变量——
等于 dev.send_command。

223
00:11:24,320 --> 00:11:25,880
我应该发送哪个命令？

224
00:11:25,880 --> 00:11:30,950
这将是 show run
pipe 包括主机名。

225
00:11:30,950 --> 00:11:33,110
我应该发送这个。

226
00:11:33,110 --> 00:11:38,740
一旦我发送了这个命令，我
应该拆分它，然后拆分它

227
00:11:38,740 --> 00:11:40,138
基于空格。

228
00:11:40,138 --> 00:11:41,680
所以我并没有真正
指定任何东西

229
00:11:41,680 --> 00:11:43,780
在括号内，
因为默认情况下，

230
00:11:43,780 --> 00:11:46,240
如果你知道 split
内置方法，

231
00:11:46,240 --> 00:11:49,240
根据空格拆分它。

232
00:11:49,240 --> 00:11:52,210

我想存储哪个值？

233
00:11:52,210 --> 00:11:55,960
我想存储索引值 1。

234
00:11:55,960 --> 00:11:57,700
我怎么知道它的
索引值为 1？

235
00:11:57,700 --> 00:11:59,440
如果你真的去
到你的防火墙—​​—

236
00:11:59,440 --> 00:12:03,930
假设我去
到我的防火墙。

237
00:12:03,930 --> 00:12:10,410
让我们启用，思科。

238
00:12:10,410 --> 00:12:15,510
如果我做一个显示运行管道包括
主机名，你会看到它

239
00:12:15,510 --> 00:12:17,580
捕捉到这个，对吧？

240
00:12:17,580 --> 00:12:21,060
在它捕捉到之后——
这是他得到的输出——

241
00:12:21,060 --> 00:12:24,940
他做了一个拆分，
拆分是基于空格的。

242
00:12:24,940 --> 00:12:27,930
所以在主机名
和实际主机名之间，

243
00:12:27,930 --> 00:12:29,440
有一个空间。

244
00:12:29,440 --> 00:12:32,640
所以这是索引值 0，
这是索引值 1。

245
00:12:32,640 --> 00:12:35,040
如果您还记得
之前的视频，

246
00:12:35,040 --> 00:12:38,530
从我的基础课程中，
内置的拆分方法，

247
00:12:38,530 --> 00:12:41,820
默认情况下，它基于
空格分割它，

248
00:12:41,820 --> 00:12:43,950
它形成一个列表。

249
00:12:43,950 --> 00:12:45,240
它创建一个列表。

250
00:12:45,240 --> 00:12:46,930
类型变为列表。

251
00:12:46,930 --> 00:12:49,140
所以这成为索引值 1。

252
00:12:49,140 --> 00:12:53,280
所以我在这里实际上要说的是发送一个显示运行管道包括

253
00:12:53,280 --> 00:12:56,970
主机名，然后
拆分任何输出

254
00:12:56,970 --> 00:12:59,010
你从设备回来。

255
00:12:59,010 --> 00:13:02,190
拆分它并捕获
索引值 1，

256
00:13:02,190 --> 00:13:05,040
并将其存储在主机名中。

257
00:13:05,040 --> 00:13:08,320
所以现在我有了设备的
主机名。

258
00:13:08,320 --> 00:13:09,460
现在我可以打印了。

259
00:13:09,460 --> 00:13:12,080
所以我可以说打印——

260
00:13:12,080 --> 00:13:14,510
让我们使用格式字符串。

261
00:13:14,510 --> 00:13:16,310
所以格式化字符串。

262
00:13:16,310 --> 00:13:17,060
我会说——

263
00:13:17,060 --> 00:13:22,370
我相信要求
是This is the output of。

264
00:13:22,370 --> 00:13:30,215
所以这是输出，
在这里我会调用主机名。

265
00:13:33,720 --> 00:13:36,630
所以现在我有了主机名。

266
00:13:36,630 --> 00:13:39,750
我有打印语句


267
00:13:39,750 --> 00:13:41,670
是主机名的输出。

268
00:13:41,670 --> 00:13:43,590
并且主机名
将被动态获取。

269
00:13:43,590 --> 00:13:45,750
因此，如果我在
设备上的主机名发生了变化，

270
00:13:45,750 --> 00:13:48,760
它会自动打印新的
主机名。

271
00:13:48,760 --> 00:13:51,150
接下来我会
打印这个输出。

272
00:13:51,150 --> 00:13:53,280
因为我已经发送了
show ip interface brief

273
00:13:53,280 --> 00:13:57,910
使用输入函数，我
现在将打印该输出。

274
00:13:57,910 --> 00:14:01,900
所以我会说打印输出。

275
00:14:01,900 --> 00:14:03,540
所以现在如果你看——

276
00:14:03,540 --> 00:14:07,440
它实际上打印了这个
字符串并提取了主机名

277
00:14:07,440 --> 00:14:09,000
从防火墙，
然后打印

278
00:14:09,000 --> 00:14:11,400
输出，无论您使用什么
输出命令

279
00:14:11,400 --> 00:14:13,860
已使用
输入函数 fw_cmd 发送。

280
00:14:16,410 --> 00:14:16,930
就是这样。

281
00:14:16,930 --> 00:14:17,790
这就是我们所需要的。

282
00:14:17,790 --> 00:14:19,440
然后我们应该
断开我们的会话。

283
00:14:19,440 --> 00:14:22,770
所以 dev.disconnect。

284
00:14:22,770 --> 00:14:24,730
我们应该断开
我们的会话。

285
00:14:24,730 --> 00:14:28,030
让我们再写一个
陈述 else--

286
00:14:28,030 --> 00:14:33,150
所以如果不是防火墙，
那我会说——

287
00:14:33,150 --> 00:14:36,550
我会完全
做同样的事情。

288
00:14:36,550 --> 00:14:39,540
让我们回去复制这个。

289
00:14:39,540 --> 00:14:44,520
dev.enable——这将
是终端长度 0。

290
00:14:44,520 --> 00:14:48,900
发送
rtr的命令，即输入

291
00:14:48,900 --> 00:14:51,440
路由器的功能。

292
00:14:51,440 --> 00:14:54,530
和 show run
完全一样。

293
00:14:54,530 --> 00:14:56,400
并断开我的会话。

294
00:14:56,400 --> 00:14:59,360
所以现在我的函数被创建了。

295
00:14:59,360 --> 00:15:02,320
接下来我要
做的是——如果你看到了，

296
00:15:02,320 --> 00:15:03,700
我的条件是什么？

297
00:15:03,700 --> 00:15:06,940
我的条件是如果 dev
equals 等于防火墙，

298
00:15:06,940 --> 00:15:09,220
否则它是一个路由器。

299
00:15:09,220 --> 00:15:12,630
我们假设它是一个路由器。

300
00:15:12,630 --> 00:15:17,390
所以如果 dev 等于 等于
防火墙——我定义了吗？

301
00:15:17,390 --> 00:15:18,980
我还没有定义fw1。

302
00:15:18,980 --> 00:15:21,200
我没有定义
路由器 1 或路由器 2。

303
00:15:21,200 --> 00:15:23,520
如何将
连接到这些设备？

304
00:15:23,520 --> 00:15:30,620
所以现在我基本上会
创建我的脚本。

305
00:15:30,620 --> 00:15:38,690
所以这将是 r1
等于 ConnectHandler，

306
00:15:38,690 --> 00:15:41,460
我将拥有我的路由器的 IP
地址。

307
00:15:41,460 --> 00:15:50,660
所以ip等于10.8.102.100，
就是路由器1。

308
00:15:50,660 --> 00:15:56,360
然后我的用户名等于，
比方说，uname。

309
00:15:56,360 --> 00:15:58,260
同样，这可以是任何名称。

310
00:15:58,260 --> 00:16:00,200
这只是一个变量名。

311
00:16:00,200 --> 00:16:02,540
我还没有定义
那个变量。

312
00:16:02,540 --> 00:16:03,990
我将对此进行定义。

313
00:16:03,990 --> 00:16:07,390
所以用户名等于uname。

314
00:16:07,390 --> 00:16:14,380
并且密码等于，
比方说，passwd。

315
00:16:14,380 --> 00:16:16,630
同样，这是一个变量名。

316
00:16:16,630 --> 00:16:18,520
可以是任何东西。

317
00:16:18,520 --> 00:16:21,490
并注意一件事——
我没有

318
00:16:21,490 --> 00:16:23,920
用双引号定义它。

319
00:16:23,920 --> 00:16:27,820
通常，如果我们
不想要脚本

320
00:16:27,820 --> 00:16:30,790
提示您输入
用户名，我们会怎么做？

321
00:16:30,790 --> 00:16:32,110
我们只想说——

322
00:16:32,110 --> 00:16:36,280
在双引号中，我
会说等于 cisco。

323
00:16:36,280 --> 00:16:38,740
和密码，我会说 cisco。

324
00:16:38,740 --> 00:16:41,350
但是
这样做的问题

325
00:16:41,350 --> 00:16:43,870
如果有人
打开我的脚本，

326
00:16:43,870 --> 00:16:45,890
他们知道我的用户名/密码。

327
00:16:45,890 --> 00:16:49,390
所以这显然是你不想做的事情。

328
00:16:49,390 --> 00:16:51,580
因为我的问题是，
它应该提示你

329
00:16:51,580 --> 00:16:54,470
对于用户名/密码，
基本上是输入。

330
00:16:54,470 --> 00:16:56,560
所以我会做的是，
而不是双引号

331
00:16:56,560 --> 00:16:58,210
我实际上是在
输入密码的地方，

332
00:16:58,210 --> 00:17:01,900
我只想给出一个变量
名称，比如说 uname。

333
00:17:01,900 --> 00:17:03,250
我会给一个密码。

334
00:17:03,250 --> 00:17:07,480
同样，我会给出一个变量
名称，比如说 P-A-S-S-W-D，

335
00:17:07,480 --> 00:17:08,920
密码。

336
00:17:08,920 --> 00:17:15,579
然后我的
device_type 等于 cisco_xe。

337
00:17:15,579 --> 00:17:16,220
就是这样。

338
00:17:16,220 --> 00:17:17,829
这就是我的路由器1。

339
00:17:17,829 --> 00:17:27,963
让我们复制这个并拥有路由器
2，其 IP 为 10.8.102.103。

340
00:17:27,963 --> 00:17:28,880
这保持不变。

341
00:17:28,880 --> 00:17:31,190
然后我有一个
作为我的防火墙，

342
00:17:31,190 --> 00:17:34,460
这将是fw1。

343
00:17:34,460 --> 00:17:38,360
IP是10.8.102.102。

344
00:17:38,360 --> 00:17:40,400
同样，用户名是 uname，
密码是 passwd，

345
00:17:40,400 --> 00:17:42,650
device_type 是 cisco_xe。

346
00:17:45,440 --> 00:17:48,810
而且，我还应该
提供秘密密码。

347
00:17:48,810 --> 00:17:57,820
所以让我们给秘密等于--

348
00:17:57,820 --> 00:18:01,520
现在，再次，我可以
给出一个变量名。

349
00:18:01,520 --> 00:18:05,660
因此，如果我确实想提出
那个--或者，如果你愿意，

350
00:18:05,660 --> 00:18:07,600
您可以直接在这里输入
启用密码。

351
00:18:07,600 --> 00:18:10,310
你可以问--你可以让他们
输入启用密码

352
00:18:10,310 --> 00:18:11,530
如果他们知道的话。

353
00:18:11,530 --> 00:18:13,600
或者假设
路由器是否已配置

354
00:18:13,600 --> 00:18:15,880
使用权限级别，
然后一旦他登录

355
00:18:15,880 --> 00:18:17,890
用他各自的
用户名/密码，

356
00:18:17,890 --> 00:18:20,140
他被分配了一个
特权，所以它不会问他

357
00:18:20,140 --> 00:18:22,120
为启用密码。

358
00:18:22,120 --> 00:18:26,350
但是我们可以把密码
放在这里，比如说cisco。

359
00:18:26,350 --> 00:18:28,720
所以我输入了我的
启用密码。

360
00:18:28,720 --> 00:18:30,310
让我们也把它放在这里——

361
00:18:30,310 --> 00:18:36,970
secret 等于 cisco 逗号。

362
00:18:36,970 --> 00:18:38,980
让我们也把它放在这里——

363
00:18:38,980 --> 00:18:43,630
秘密等于思科。

364
00:18:43,630 --> 00:18:47,500
所以现在我有我的——

365
00:18:47,500 --> 00:18:50,630
创建了所有三个 ConnectHandler
变量。

366
00:18:50,630 --> 00:18:56,840
所以如果是fw1，这里是
那么如果device等于fw1，

367
00:18:56,840 --> 00:19:01,280
然后它匹配 this
并执行它。

368
00:19:01,280 --> 00:19:06,470
否则，如果是 r1 或 r2，
它将匹配这个。

369
00:19:06,470 --> 00:19:11,030
然而，我们还没有真正
定义uname和passwd，

370
00:19:11,030 --> 00:19:12,030
变量。

371
00:19:12,030 --> 00:19:14,280
所以这必须是一个输入函数。

372
00:19:14,280 --> 00:19:16,260
所以，再次，我会做
输入功能。

373
00:19:16,260 --> 00:19:18,180
让我们在
连接上执行此操作。

374
00:19:18,180 --> 00:19:20,540
所以我会说 uname--

375
00:19:20,540 --> 00:19:27,230
它应该是相同的
name--等于输入--

376
00:19:27,230 --> 00:19:29,810
我们想问他用户名。

377
00:19:29,810 --> 00:19:31,760
我相信输出说 -

378
00:19:31,760 --> 00:19:32,630
让我们检查。

379
00:19:32,630 --> 00:19:35,760
它说用户名冒号。

380
00:19:35,760 --> 00:19:36,980
所以我们应该这样做。

381
00:19:39,710 --> 00:19:46,560
所以用户名冒号和空格。

382
00:19:46,560 --> 00:19:50,310
让我们也把 passwd 等于 -

383
00:19:50,310 --> 00:19:52,740
这是我在这里给出的变量
——

384
00:19:52,740 --> 00:19:55,440
等于getpass。

385
00:19:55,440 --> 00:20:00,400
如果您还记得，我们已经导入了
名为 getpass 的 OS 模块。

386
00:20:00,400 --> 00:20:05,490
所以对于passwd，我们使用
getpass的模块。

387
00:20:05,490 --> 00:20:10,360
对于用户名，我们只是使用了
input，作为输入函数。

388
00:20:10,360 --> 00:20:13,950
所以 getpass 是模块。

389
00:20:13,950 --> 00:20:19,990
.getpass 是 getpass 模块的内置
方法。

390
00:20:19,990 --> 00:20:22,890
所以我会说
getpass.getpass，然后我

391
00:20:22,890 --> 00:20:27,177
会问他这个问题，
是密码冒号。

392
00:20:27,177 --> 00:20:29,010
这是我想问他的问题


393
00:20:29,010 --> 00:20:33,190
他基本上会
提供那个输入。

394
00:20:33,190 --> 00:20:33,720
就是这样。

395
00:20:33,720 --> 00:20:37,230
接下来我需要
创建一个 for 循环

396
00:20:37,230 --> 00:20:38,860
通过
这个函数来执行。

397
00:20:38,860 --> 00:20:40,870
我的函数还没有
被调用。

398
00:20:40,870 --> 00:20:45,900
所以现在我会有设备
等于一个列表，基本上

399
00:20:45,900 --> 00:20:50,520
r1 逗号 r2 逗号 fw1。

400
00:20:50,520 --> 00:20:55,560
所以我的列表中有三个这样的
设备。

401
00:20:55,560 --> 00:20:57,160
现在我创建了一个 for 循环。

402
00:20:57,160 --> 00:21:03,140
所以对于设备中的项目——

403
00:21:03,140 --> 00:21:08,320
所以对于设备中的项目，
我会说 get--

404
00:21:08,320 --> 00:21:11,200
让我们将其更改为 get_cmd。

405
00:21:11,200 --> 00:21:14,530
因为它是 if 和 else 的通用
定义，

406
00:21:14,530 --> 00:21:16,660
让我们将
名称更改为get_cmd。

407
00:21:16,660 --> 00:21:22,250
所以我会说对于设备中的 item
，请执行 get_cmd。

408
00:21:22,250 --> 00:21:26,740
所以执行我的函数，
我提供的值

409
00:21:26,740 --> 00:21:29,710
将成为项目。

410
00:21:29,710 --> 00:21:30,640
就是这样。

411
00:21:30,640 --> 00:21:31,840
那是我的剧本。

412
00:21:31,840 --> 00:21:34,350
那么这将如何运作呢？

413
00:21:34,350 --> 00:21:37,320
当我执行 Lab11.py--

414
00:21:37,320 --> 00:21:39,480
事实上，让我们先保存它。

415
00:21:39,480 --> 00:21:43,970
所以当我执行这个
文件时，它显然会

416
00:21:43,970 --> 00:21:47,120
导入netmiko，getpass。

417
00:21:47,120 --> 00:21:48,630
执行所有这些。

418
00:21:48,630 --> 00:21:50,810
但是，它还没有
运行该函数，

419
00:21:50,810 --> 00:21:52,970
因为 function
必须被调用。

420
00:21:52,970 --> 00:22:01,560
现在，当 for 循环运行
时，项目编号 0--

421
00:22:01,560 --> 00:22:02,890
所以索引值 0--

422
00:22:02,890 --> 00:22:04,930
所以项目将是r1。

423
00:22:04,930 --> 00:22:10,720
所以对于设备中的 r1，
get_cmd 项。

424
00:22:10,720 --> 00:22:11,890
那么什么是物品？

425
00:22:11,890 --> 00:22:13,000
r1。

426
00:22:13,000 --> 00:22:14,470
所以它首先经过 r1。

427
00:22:14,470 --> 00:22:18,400
所以现在我的项目
等于r1，对吧？

428
00:22:18,400 --> 00:22:21,970
所以我提供
输入项等于

429
00:22:21,970 --> 00:22:25,810
r1，这意味着 dev 变为 r1。

430
00:22:25,810 --> 00:22:29,740
现在如果 dev 等于 r1，它将执行
。

431
00:22:29,740 --> 00:22:33,790
它不匹配，所以跳过
这个并转到其他，

432
00:22:33,790 --> 00:22:36,670
并匹配所有
这些东西，执行

433
00:22:36,670 --> 00:22:40,720
我的命令，无论我在脚本中指定的任何命令


434
00:22:40,720 --> 00:22:43,390
在这个输入函数中。

435
00:22:43,390 --> 00:22:47,170
然后它返回到列表中的下一个
项，即 r2。

436
00:22:47,170 --> 00:22:49,000
所以现在项目变成了 r2。

437
00:22:49,000 --> 00:22:50,710
所以 dev 变成了 r2。

438
00:22:50,710 --> 00:22:52,600
再次，不匹配
if语句，

439
00:22:52,600 --> 00:22:54,670
并匹配 else 语句。

440
00:22:54,670 --> 00:22:58,780
然后经过
下一项，也就是fw1。

441
00:22:58,780 --> 00:23:02,860
所以现在dev变成了fw1，
匹配第一条语句，

442
00:23:02,860 --> 00:23:04,340
并执行。

443
00:23:04,340 --> 00:23:06,400
所以让我们试试这个。

444
00:23:06,400 --> 00:23:12,580
我要做的是
转到我的文件夹。

445
00:23:12,580 --> 00:23:17,470
让我们把它复制到我的
机器上，到我的 Ubuntu 机器上，

446
00:23:17,470 --> 00:23:18,715
并执行此脚本。

447
00:23:24,490 --> 00:23:25,980
所以让我们放——

448
00:23:25,980 --> 00:23:28,860
首先，让我们检查一下
我是否在正确的文件夹中。

449
00:23:28,860 --> 00:23:29,490
我是。

450
00:23:29,490 --> 00:23:32,100
所以让我们做一下Lab11.py。

451
00:23:37,847 --> 00:23:39,430
它实际上已经
进入了错误的文件夹。

452
00:23:39,430 --> 00:23:41,680
所以让我们改变
给路径。

453
00:23:41,680 --> 00:23:49,350
所以把 Lab11.py 放到这个文件夹中。

454
00:23:53,600 --> 00:23:55,800
所以现在我的 Ubuntu 机器上有文件
。

455
00:23:55,800 --> 00:23:57,210
让我们执行它。

456
00:23:57,210 --> 00:24:01,700
所以python3 Lab11.py。

457
00:24:01,700 --> 00:24:04,250
它要求我输入
路由器显示命令

458
00:24:04,250 --> 00:24:05,880
你想显示的。

459
00:24:05,880 --> 00:24:10,250
所以我想显示 ip
接口简介。

460
00:24:10,250 --> 00:24:12,290
输入防火墙
显示您的命令

461
00:24:12,290 --> 00:24:17,240
想显示--show
interface ip brief。

462
00:24:17,240 --> 00:24:20,060
用户名，思科。

463
00:24:20,060 --> 00:24:23,530
密码，思科。

464
00:24:23,530 --> 00:24:28,180
现在它应该执行
定义，函数，

465
00:24:28,180 --> 00:24:31,920
它应该显示所有
show ip interface brief。

466
00:24:31,920 --> 00:24:34,480
所以现在我确实得到了——

467
00:24:34,480 --> 00:24:35,900
我有一个错误。

468
00:24:35,900 --> 00:24:36,910
让我们检查一下原因。

469
00:24:36,910 --> 00:24:39,460
我看到我的拼写错误。

470
00:24:39,460 --> 00:24:40,810
所以它说错字。

471
00:24:40,810 --> 00:24:47,050
让我们返回并更改
这个--secret 等于 cisco。

472
00:24:47,050 --> 00:24:49,900
让我们再次保存它。

473
00:24:49,900 --> 00:24:53,140
返回并重新复制此内容。

474
00:24:56,470 --> 00:25:01,200
好的，让我们
再次执行此操作。

475
00:25:01,200 --> 00:25:05,760
所以这将是 show
ip interface brief，

476
00:25:05,760 --> 00:25:09,920
显示接口 ip--

477
00:25:09,920 --> 00:25:11,100
现在，你看到了吗？

478
00:25:11,100 --> 00:25:13,500
我实际上在输入时犯了一个错误。

479
00:25:13,500 --> 00:25:15,960
最糟糕的是
我不能回去。

480
00:25:15,960 --> 00:25:18,730
这是最糟糕的部分，
我无法回头。

481
00:25:18,730 --> 00:25:22,950
所以现在我必须退出
正在运行的脚本，

482
00:25:22,950 --> 00:25:25,620
然后重新执行脚本。

483
00:25:25,620 --> 00:25:28,080
但是有一种方法
你可以真正解决这个问题。

484
00:25:28,080 --> 00:25:32,170
这是一个非常令人沮丧的
你不能做的问题

485
00:25:32,170 --> 00:25:32,670
退格。

486
00:25:32,670 --> 00:25:34,680
假设您
输入错误，

487
00:25:34,680 --> 00:25:36,880
那么您不能使用
退格键来纠正它。

488
00:25:36,880 --> 00:25:38,950
所以这是一个非常
令人沮丧的问题。

489
00:25:38,950 --> 00:25:42,000
所以你可以做的是
回到你的脚本

490
00:25:42,000 --> 00:25:44,400
并且还导入一个
更多的模块，它

491
00:25:44,400 --> 00:25:47,070
称为导入读取线。

492
00:25:49,860 --> 00:25:52,320
所以也导入 readline 。

493
00:25:52,320 --> 00:25:55,800
这允许您返回
并进行更改。

494
00:25:55,800 --> 00:25:58,470
让我们继续
再次复制脚本。

495
00:25:58,470 --> 00:25:59,190
这么说吧。

496
00:26:02,350 --> 00:26:04,030
让我们回到这里。

497
00:26:04,030 --> 00:26:06,790
让我退出脚本，
让我们重新运行脚本。

498
00:26:06,790 --> 00:26:08,620
我现在会犯错。

499
00:26:08,620 --> 00:26:11,380
假设我犯了一些
错误。

500
00:26:11,380 --> 00:26:14,290
现在我可以按 Backspace
并进行更改——

501
00:26:14,290 --> 00:26:20,980
show ip interface brief,
和show interface ip brief。

502
00:26:20,980 --> 00:26:22,720
用户名，思科。

503
00:26:22,720 --> 00:26:24,040
密码，思科。

504
00:26:27,400 --> 00:26:31,030
它应该显示
脚本没问题。

505
00:26:31,030 --> 00:26:38,300
它应该根据问题向我显示输出
。

506
00:26:38,300 --> 00:26:40,450
所以我们知道第一部分是可以的。

507
00:26:40,450 --> 00:26:43,330
于是我看到了Rack102-R1的输出
，

508
00:26:43,330 --> 00:26:46,370
这是主机名，是这个。

509
00:26:46,370 --> 00:26:48,200
这是Rack102-R2的输出
，

510
00:26:48,200 --> 00:26:51,170
这是 Rack102-FW1 的
输出。

511
00:26:51,170 --> 00:26:53,780
所以现在我们已经匹配了
问题的要求，

512
00:26:53,780 --> 00:26:57,270
我们已经成功
完成了我们的任务。

513
00:26:57,270 --> 00:27:00,140
但是，如果你
还记得，我告诉过你

514
00:27:00,140 --> 00:27:04,130
之前我不太喜欢这种方法，因为它是

515
00:27:04,130 --> 00:27:04,820
非常静态。

516
00:27:04,820 --> 00:27:10,760
现在想象一下，如果我有一个
防火墙，fw2。

517
00:27:10,760 --> 00:27:11,910
会发生什么？

518
00:27:11,910 --> 00:27:14,360
我必须写
另一个 if 语句——

519
00:27:14,360 --> 00:27:17,060
如果 dev 等于防火墙 2。

520
00:27:17,060 --> 00:27:18,770
如果我有，让我们
说，防火墙 3，我

521
00:27:18,770 --> 00:27:24,120
必须再写一个——如果dev
等于firewall 3，以此类推。

522
00:27:24,120 --> 00:27:28,160
所以这变得
具有挑战性，因为现在我

523
00:27:28,160 --> 00:27:32,150
必须为每个设备编写一个 if
语句。

524
00:27:32,150 --> 00:27:33,710
如果我有 10 个
防火墙，那么

525
00:27:33,710 --> 00:27:35,490
将是 10 个 if 语句。

526
00:27:35,490 --> 00:27:38,130
所以我真的不喜欢这个。

527
00:27:38,130 --> 00:27:40,730
所以我认为
会有更好的可扩展性

528
00:27:40,730 --> 00:27:44,360
这样做的方式。

529
00:27:44,360 --> 00:27:46,500
让我们看看如何做到这一点。

530
00:27:46,500 --> 00:27:48,810
让我们看看我们可以在这里做出哪些改变。

531
00:27:48,810 --> 00:27:50,880
所以，很明显，第一部分保持不变。

532
00:27:50,880 --> 00:27:52,890
所以这将保持不变。

533
00:27:52,890 --> 00:27:54,770
这将保持不变。

534
00:27:54,770 --> 00:27:58,260
但我的职能
要改变了。

535
00:27:58,260 --> 00:28:01,370
所以我要做的是创建两个单独的函数，

536
00:28:01,370 --> 00:28:04,790
一个用于路由器，
一个用于防火墙，

537
00:28:04,790 --> 00:28:09,950
一个用于 Nexus 交换机，一个用于
可能是其他设备类型。

538
00:28:09,950 --> 00:28:11,940
所以我可以制作
不同的功能。

539
00:28:11,940 --> 00:28:14,780
所以现在，如果你
看到了，我有一个功能

540
00:28:14,780 --> 00:28:16,950
其中有 if 语句。

541
00:28:16,950 --> 00:28:22,850
但我能做的是我可以拥有
多种功能、定义

542
00:28:22,850 --> 00:28:25,580
为每种设备类型创建。

543
00:28:25,580 --> 00:28:27,110
这将使
它更具可扩展性。

544
00:28:27,110 --> 00:28:28,470
让我告诉你。

545
00:28:28,470 --> 00:28:31,220
所以我会把它改成——

546
00:28:31,220 --> 00:28:34,160
或者说 rtr--

547
00:28:34,160 --> 00:28:38,600
或者，事实上，让我们
制作这个 fw_get_cmd。

548
00:28:38,600 --> 00:28:41,540
所以这纯粹是为了防火墙。

549
00:28:41,540 --> 00:28:45,920
在我要说
启用的地方，我会--

550
00:28:45,920 --> 00:28:49,380
所有这些
都将完全相同。

551
00:28:49,380 --> 00:28:54,240
而且我不需要在其中包含
if 语句。

552
00:28:54,240 --> 00:28:57,435
我可以——事实上，让我们
去移动它。

553
00:29:03,500 --> 00:29:07,980
让我们把它移回到这里。

554
00:29:07,980 --> 00:29:13,930
这将是
另一个功能。

555
00:29:13,930 --> 00:29:16,890
所以定义 rtr_get_cmd。

556
00:29:21,600 --> 00:29:27,240
而且，这
将是开发冒号。

557
00:29:27,240 --> 00:29:29,970
所以我里面没有任何 if
语句。

558
00:29:29,970 --> 00:29:33,330
我只有一个单独的
防火墙功能。

559
00:29:33,330 --> 00:29:36,930
我有一个单独的
路由器功能。

560
00:29:36,930 --> 00:29:39,660
这个是调用防火墙的
输入功能。

561
00:29:39,660 --> 00:29:43,740
这个是调用路由器的
输入函数。

562
00:29:43,740 --> 00:29:46,180
这保持原样
完全一样。

563
00:29:46,180 --> 00:29:49,300
我不会在那里进行任何更改。

564
00:29:49,300 --> 00:29:51,960
但是我的 for 循环
要改变了。

565
00:29:51,960 --> 00:29:55,800
我会说
设备中的项目，

566
00:29:55,800 --> 00:29:59,690
我会首先获得设备的
主机名。

567
00:30:03,650 --> 00:30:09,640
所以如果主机名 where
item.send_command--

568
00:30:09,640 --> 00:30:13,390
获取设备的主机名。

569
00:30:13,390 --> 00:30:19,620
在这里我想说
如果防火墙，fw--

570
00:30:19,620 --> 00:30:22,980
所以我知道我的主机名
会有防火墙。

571
00:30:22,980 --> 00:30:24,720
同样，它不需要
是主机名。

572
00:30:24,720 --> 00:30:29,790
您可以像显示版本一样
并解析数据，

573
00:30:29,790 --> 00:30:34,800
也许看看
版本是否是防火墙，

574
00:30:34,800 --> 00:30:36,540
或者如果图像是防火墙。

575
00:30:36,540 --> 00:30:39,810
您可以使用正则表达式解析
数据。

576
00:30:39,810 --> 00:30:43,840
我们还没有真正了解
，所以我不会那样做。

577
00:30:43,840 --> 00:30:44,640
我只想说——

578
00:30:44,640 --> 00:30:46,140
我将再次使用
主机名。

579
00:30:46,140 --> 00:30:50,370
因此，如果防火墙——那么一旦我得到
设备的主机名，

580
00:30:50,370 --> 00:30:52,590
我知道我的
主机名包含什么？

581
00:30:52,590 --> 00:30:57,120
它包含 R1、R2 或
可能是路由器关键字。

582
00:30:57,120 --> 00:30:58,560
它包含固件。

583
00:30:58,560 --> 00:31:03,168
所以我所有的防火墙，主机名
是，比方说，FW1 或 FW2。

584
00:31:03,168 --> 00:31:07,730
我的意思是，这是我实际给予的某种东西，

585
00:31:07,730 --> 00:31:09,480
但通常你不会
没有这种情况。

586
00:31:09,480 --> 00:31:12,345
但是，假设我是根据主机名进行
。

587
00:31:12,345 --> 00:31:14,220
通常情况下，如果我这样做
是为了生产，

588
00:31:14,220 --> 00:31:15,930
我不会根据主机名这样做
。

589
00:31:15,930 --> 00:31:18,390
我可能会看
版本

590
00:31:18,390 --> 00:31:21,390
并使用正则表达式解析该
数据。

591
00:31:21,390 --> 00:31:25,980
然后我会做出决定
我想做什么，

592
00:31:25,980 --> 00:31:28,560
我要执行什么功能。

593
00:31:28,560 --> 00:31:30,280
但是现在我们
还没有了解到，

594
00:31:30,280 --> 00:31:33,570
所以我们会根据主机名来做
。

595
00:31:33,570 --> 00:31:39,390
所以我会说 if
fw in hostname--

596
00:31:39,390 --> 00:31:41,170
所以这是我的
主机名变量。

597
00:31:41,170 --> 00:31:53,020
所以如果 fw 在 hostname.lower 中，那么
你会执行 fw_get_cmd。

598
00:31:53,020 --> 00:31:54,565
你会执行这个。

599
00:32:01,380 --> 00:32:10,810
否则，您将执行
路由器 rtr_cmd。

600
00:32:13,980 --> 00:32:18,800
而这显然
应该是item。

601
00:32:18,800 --> 00:32:19,850
就是这样。

602
00:32:19,850 --> 00:32:22,130
这就是你所需要的。

603
00:32:22,130 --> 00:32:23,690
这使它更加模块化。

604
00:32:23,690 --> 00:32:28,610
所以现在就算我有FW1,
FW2,FW3也没关系，

605
00:32:28,610 --> 00:32:32,740
因为我知道我的主机名
有关键字防火墙。

606
00:32:32,740 --> 00:32:36,850
如果是防火墙，它会
给我show ip interface

607
00:32:36,850 --> 00:32:38,860
所有这些防火墙的简要说明。

608
00:32:38,860 --> 00:32:41,680
如果是路由器，它会
给我show ip interface

609
00:32:41,680 --> 00:32:43,450
这些路由器的简介。

610
00:32:43,450 --> 00:32:45,020
让我们试试这个。

611
00:32:45,020 --> 00:32:47,860
我会保存这个。

612
00:32:47,860 --> 00:32:50,670
现在让我们复制脚本。

613
00:32:50,670 --> 00:32:58,350
所以我会将这个
复制到我的 Ubuntu 机器上。

614
00:32:58,350 --> 00:33:01,150
让我们重新执行这个。

615
00:33:01,150 --> 00:33:07,110
所以python3——所以如果你
实际看cat Lab11.py，

616
00:33:07,110 --> 00:33:09,750
这是我更新的脚本，
更加模块化。

617
00:33:09,750 --> 00:33:13,020
我有两个独立的
函数，我

618
00:33:13,020 --> 00:33:16,560
我正在调用 for 循环中的那些
函数

619
00:33:16,560 --> 00:33:18,090
基于主机名。

620
00:33:18,090 --> 00:33:24,420
如果它在主机名中包含 fw
关键字，

621
00:33:24,420 --> 00:33:26,970
然后执行这个函数。

622
00:33:26,970 --> 00:33:28,640
否则，执行此功能。

623
00:33:28,640 --> 00:33:29,890
所以让我们试试这个。

624
00:33:29,890 --> 00:33:32,520
所以python3 Lab11.py。

625
00:33:35,610 --> 00:33:38,320
输入您要执行的路由器显示命令
。

626
00:33:38,320 --> 00:33:45,870
所以show ip interface brief，
show interface ip brief。

627
00:33:45,870 --> 00:33:50,460
然后我会说用户名
cisco，密码cisco。

628
00:33:50,460 --> 00:33:55,260
它现在应该给我我们想要的完全相同的输出，

629
00:33:55,260 --> 00:33:58,290
但这是一种
更具可扩展性的方式。

630
00:33:58,290 --> 00:34:01,800
是的，很多人
有不同的做法。

631
00:34:01,800 --> 00:34:04,500
看，脚本是一件事，如果你

632
00:34:04,500 --> 00:34:07,410
要求一个人
成就某事，

633
00:34:07,410 --> 00:34:10,350
总会有 10
种不同的方式来做这件事。

634
00:34:10,350 --> 00:34:12,880
这是你觉得
舒服的。

635
00:34:12,880 --> 00:34:23,100
所以我看到我的 Rack102 输出有一个
错误。

636
00:34:23,100 --> 00:34:26,699
所以让我们再次检查一下。

637
00:34:26,699 --> 00:34:28,020
脚本看起来不错。

638
00:34:28,020 --> 00:34:30,719
让我们看看
ConnectHandler。

639
00:34:30,719 --> 00:34:31,394
这看起来不错。

640
00:34:31,394 --> 00:34:32,730
哦，你知道吗？

641
00:34:32,730 --> 00:34:34,500
我在这里看到了错误。

642
00:34:34,500 --> 00:34:37,719
我的设备类型不正确。

643
00:34:37,719 --> 00:34:40,080
这应该是asa。

644
00:34:40,080 --> 00:34:47,670
让我们再次保存这个
然后把这个文件放回去

645
00:34:47,670 --> 00:34:51,650
到 Ubuntu 机器。

646
00:34:51,650 --> 00:34:56,880
让我们重新执行--
python3 Lab11.py。

647
00:35:00,160 --> 00:35:06,910
所以show ip interface brief，
show interface ip brief。

648
00:35:09,710 --> 00:35:14,030
和用户名cisco，
密码cisco。

649
00:35:14,030 --> 00:35:16,040
这应该给我输出。

650
00:35:16,040 --> 00:35:17,030
让我们拭目以待。

651
00:35:27,720 --> 00:35:31,420
所以我看到了R1的输出。

652
00:35:31,420 --> 00:35:35,200
我看到了 R2 的输出。

653
00:35:35,200 --> 00:35:37,490
我看到了我的防火墙的输出
。

654
00:35:37,490 --> 00:35:40,870
所以脚本现在可以工作了。

655
00:35:40,870 --> 00:35:43,960
这是我的整个脚本，
更加模块化。

656
00:35:43,960 --> 00:35:47,770
而且不是——即使
我添加了更多防火墙，

657
00:35:47,770 --> 00:35:49,990
我所要做的就是
添加一个连接

658
00:35:49,990 --> 00:35:52,960
新
防火墙的处理程序，就是这样。

659
00:35:52,960 --> 00:35:54,220
它变得更加模块化。

660
00:35:54,220 --> 00:35:56,080
但如果我按照之前的方式做了
，

661
00:35:56,080 --> 00:35:59,090
我必须有每个防火墙的 if
语句。

662
00:35:59,090 --> 00:36:00,790
所以这使它更加模块化。

663
00:36:00,790 --> 00:36:04,280
至此，我们已经完成了
我们的所有要求。

664
00:36:04,280 --> 00:36:06,110
我希望此视频
对您有所帮助，