1
00:00:03,374 --> 00:00:07,712
[电子音乐]

2
00:00:10,140 --> 00:00:12,240
您好，欢迎来到 INE。

3
00:00:12,240 --> 00:00:14,640
今天在这个视频中，我们将
看看 Netmiko Ultimate

4
00:00:14,640 --> 00:00:15,810
挑战 3。

5
00:00:15,810 --> 00:00:19,230
现在，这个挑战任务
基本一模一样

6
00:00:19,230 --> 00:00:23,880
上一个任务，我们
将创建一个脚本

7
00:00:23,880 --> 00:00:27,270
将被称为
netmiko_challenge3.py。

8
00:00:27,270 --> 00:00:30,780
它应该在
Ubuntu的相应文件夹中

9
00:00:30,780 --> 00:00:31,560
机器。

10
00:00:31,560 --> 00:00:33,300
现在，这个脚本
要实现

11
00:00:33,300 --> 00:00:35,340
或者应该完成
以下事情。

12
00:00:35,340 --> 00:00:37,470
它应该连接到
设备，即Router1，

13
00:00:37,470 --> 00:00:39,300
Router2和防火墙。

14
00:00:39,300 --> 00:00:42,130
现在，我的设置中确实有一个 ASA
防火墙，

15
00:00:42,130 --> 00:00:44,820
所以我们将连接到Router1，
我们将连接到Router2，

16
00:00:44,820 --> 00:00:46,980
以及 ASA 防火墙。

17
00:00:46,980 --> 00:00:48,180
它应该保存配置。

18
00:00:48,180 --> 00:00:50,222
同时，它应该
备份配置——

19
00:00:50,222 --> 00:00:51,480
这是一场表演赛——

20
00:00:51,480 --> 00:00:59,100
到名为 Router1.cfg、
R2.cfg 和 Firewall1.cfg 的文件。

21
00:00:59,100 --> 00:01:03,280
您必须使用 for 循环和
函数来完成此任务。

22
00:01:03,280 --> 00:01:06,220
所以在这个需求中，我们将
使用一个函数，

23
00:01:06,220 --> 00:01:08,620
我们将
使用for循环。

24
00:01:08,620 --> 00:01:10,440
那么让我们看看我们如何做到这一点。

25
00:01:10,440 --> 00:01:12,760
我想说
暂停视频，

26
00:01:12,760 --> 00:01:18,045
自己尝试一下，
看看你能不能做到。

27
00:01:18,045 --> 00:01:19,920
如果没有，您可以随时
回顾视频

28
00:01:19,920 --> 00:01:22,030
看看我是怎么做的。

29
00:01:22,030 --> 00:01:25,330
因此，让我向您展示
我将如何实现这一目标。

30
00:01:25,330 --> 00:01:29,280
所以让我们去 Atom 并
创建一个名为

31
00:01:29,280 --> 00:01:31,610
作为 netmiko_challenge3.py。

32
00:01:38,700 --> 00:01:41,500
在这里，我们将
创建我们的脚本。

33
00:01:41,500 --> 00:01:45,000
所以我们首先需要
显然

34
00:01:45,000 --> 00:01:48,570
从 netmiko 导入 ConnectHandler
。

35
00:01:48,570 --> 00:01:52,740
所以我们会说，从
netmiko 我们基本上会

36
00:01:52,740 --> 00:01:54,300
导入连接处理程序。

37
00:01:54,300 --> 00:02:00,360
所以从 netmiko 进口——

38
00:02:00,360 --> 00:02:01,980
哦，这应该是从。

39
00:02:01,980 --> 00:02:06,910
所以从 netmiko
import ConnectHandler。

40
00:02:09,750 --> 00:02:12,165
所以这将是我们的第一步。

41
00:02:16,520 --> 00:02:18,710
那是来自 netmiko
import ConnectHandler。

42
00:02:18,710 --> 00:02:20,420
下一步是
显然要定义

43
00:02:20,420 --> 00:02:23,030

路由器和防火墙的 IP 地址

44
00:02:23,030 --> 00:02:24,740
连接到这些设备。

45
00:02:24,740 --> 00:02:30,350
所以 r1 将等于
到 ConnectHandler，其中

46
00:02:30,350 --> 00:02:36,590
IP 将是 10.8.102.100。

47
00:02:36,590 --> 00:02:41,840
我的用户名将
等于 cisco。

48
00:02:41,840 --> 00:02:47,120
我的密码
等于cisco。

49
00:02:47,120 --> 00:02:51,680
我的秘密密码
将等于 cisco。

50
00:02:51,680 --> 00:02:58,790
我的 device_type
将等于 cisco_xe。

51
00:02:58,790 --> 00:03:01,310
所以这适用于Router1。

52
00:03:01,310 --> 00:03:04,370
让我们为Router2 做同样的事情。

53
00:03:04,370 --> 00:03:06,830
IP 将更改为 103。

54
00:03:06,830 --> 00:03:08,570
然后我会
做同样的事情

55
00:03:08,570 --> 00:03:14,148
对于防火墙，这里
将更改为防火墙 FW1。

56
00:03:14,148 --> 00:03:16,190
我相信防火墙的 IP 地址
--我们会

57
00:03:16,190 --> 00:03:17,700
必须去检查一下。

58
00:03:17,700 --> 00:03:25,480
那么让我们去验证一下
防火墙IP是什么。

59
00:03:25,480 --> 00:03:27,730
我相信密码是cisco。

60
00:03:27,730 --> 00:03:30,100
显示运行界面。

61
00:03:30,100 --> 00:03:42,200
所以我们有管理
IP是10.8.102.102。

62
00:03:42,200 --> 00:03:44,100
所以让我们把它说出来。

63
00:03:44,100 --> 00:03:46,880
所以 10.8.102.102。

64
00:03:46,880 --> 00:03:48,020
用户名是 cisco。

65
00:03:48,020 --> 00:03:48,860
密码是思科。

66
00:03:48,860 --> 00:03:49,610
秘密是思科。

67
00:03:49,610 --> 00:03:54,013
Device_type 将是 cisco_asa。

68
00:03:54,013 --> 00:03:55,430
这将
成为我的设备类型。

69
00:03:55,430 --> 00:03:57,138
同样，如果您不
知道设备类型，

70
00:03:57,138 --> 00:03:59,420
您可以转到 Python
解释器并输入任何内容

71
00:03:59,420 --> 00:04:01,920
那里，它应该
给你列表。

72
00:04:01,920 --> 00:04:05,600
所以一旦我完成了这件事，接下来我会做的


73
00:04:05,600 --> 00:04:10,560
是创建一个列表，因为
我想使用 for 循环。

74
00:04:10,560 --> 00:04:13,800
所以我需要一个列表，以便它可以遍历所有设备类型。

75
00:04:13,800 --> 00:04:15,270
所以我会创建一个列表。

76
00:04:15,270 --> 00:04:21,500
让我们将列表命名为设备等于 r1--

77
00:04:21,500 --> 00:04:22,890
它应该是方括号。

78
00:04:22,890 --> 00:04:27,020
所以 r1 逗号 r2 逗号 fw1。

79
00:04:27,020 --> 00:04:29,810
所以我有这三个清单——

80
00:04:29,810 --> 00:04:33,380
我列表中的三个项目
称为设备。

81
00:04:33,380 --> 00:04:36,500
接下来我要
创建一个函数。

82
00:04:36,500 --> 00:04:40,100
现在，在函数中，我将
放入常用命令列表

83
00:04:40,100 --> 00:04:43,010
我希望它们
在所有设备上都被执行。

84
00:04:43,010 --> 00:04:44,570
现在，常见的命令是什么？

85
00:04:44,570 --> 00:04:46,310
使能够。

86
00:04:46,310 --> 00:04:50,576
也许我会——

87
00:04:50,576 --> 00:04:52,970
我可能会在里面有一些
if语句

88
00:04:52,970 --> 00:04:54,270
来匹配条件。

89
00:04:54,270 --> 00:04:56,678
所以我会创建一个定义，
并在定义内

90
00:04:56,678 --> 00:04:58,220
我会创建一些
if 语句

91
00:04:58,220 --> 00:05:00,240
匹配各自的设备。

92
00:05:00,240 --> 00:05:01,440
所以让我们这样做。

93
00:05:01,440 --> 00:05:04,460
所以我会创建
一个名为--

94
00:05:04,460 --> 00:05:07,940
def--让我们将其命名为--

95
00:05:10,730 --> 00:05:16,760
也许我们可以将其命名为 devices_configs。

96
00:05:16,760 --> 00:05:18,930
同样，这只是
我的函数名。

97
00:05:18,930 --> 00:05:20,970
然后是一个临时的
占位符。

98
00:05:20,970 --> 00:05:23,660
因此，让我们将其命名为 dev。

99
00:05:23,660 --> 00:05:27,350
所以我做了一个函数
称为devices_configs，

100
00:05:27,350 --> 00:05:30,530
和我的临时占位符
其中将是 dev。

101
00:05:30,530 --> 00:05:33,060
这就是输入
的来源。

102
00:05:33,060 --> 00:05:35,610
所以在定义中，
我会有一些命令。

103
00:05:35,610 --> 00:05:43,020
所以首先是
dev.建立我的连接。

104
00:05:43,020 --> 00:05:44,790
所以建立连接。

105
00:05:47,880 --> 00:05:51,000
所以我会将我的连接
连接到相应的设备。

106
00:05:51,000 --> 00:05:55,160
然后我会有dev.enable。

107
00:05:55,160 --> 00:05:59,366
所以我想启用我的
设备，因为对我来说——

108
00:05:59,366 --> 00:06:01,070
让我跑——

109
00:06:01,070 --> 00:06:05,930
进行一次演出，然后备份
该文件，

110
00:06:05,930 --> 00:06:09,020
那么我需要先启用。

111
00:06:09,020 --> 00:06:14,800
接下来，我将如何
识别我的设备？

112
00:06:14,800 --> 00:06:19,310
所以要识别我的
设备，我可以做到

113
00:06:19,310 --> 00:06:21,920
基于IP地址，
或者我可以做到

114
00:06:21,920 --> 00:06:24,780
基于别的东西。

115
00:06:24,780 --> 00:06:26,120
也许我可以做IP地址。

116
00:06:26,120 --> 00:06:28,280
IP 地址显然
将是唯一的。

117
00:06:28,280 --> 00:06:32,420
或者我什至可以根据主机名进行
。

118
00:06:32,420 --> 00:06:35,660
例如，如果
主机名包含路由器，

119
00:06:35,660 --> 00:06:36,920
我知道是路由器。

120
00:06:36,920 --> 00:06:39,770
或者如果主机名
包含防火墙，

121
00:06:39,770 --> 00:06:40,775
我知道这是防火墙。

122
00:06:40,775 --> 00:06:42,150
所以，让我，
事实上，做一件事。

123
00:06:42,150 --> 00:06:44,310
让我回到我的路由器。

124
00:06:44,310 --> 00:06:49,530
让我们也转到 R1 和 R2
并检查主机名。

125
00:06:49,530 --> 00:06:52,730
所以防火墙，我知道
它包含FW1。

126
00:06:52,730 --> 00:06:55,250
所以它有 Rack102-FW1。

127
00:06:55,250 --> 00:06:57,650
所以我可以根据FW1来匹配它。

128
00:06:57,650 --> 00:07:00,890
对于路由器，我的
主机名是 Router1。

129
00:07:00,890 --> 00:07:04,910
所以我知道它有 Router 作为主机名中的一个关键字。

130
00:07:04,910 --> 00:07:07,840
我有Router2。

131
00:07:07,840 --> 00:07:11,390
或者，事实上，让我们
去改变它。

132
00:07:11,390 --> 00:07:18,180
让我们更改
以使其更简单。

133
00:07:18,180 --> 00:07:20,660
假设主机名Router2。

134
00:07:23,910 --> 00:07:25,280
让我们保存它。

135
00:07:25,280 --> 00:07:34,970
让我们转到 R1 并将主机名更改为 Router1。

136
00:07:34,970 --> 00:07:41,840
并且防火墙已经有FW1，
所以我们可能会保留它

137
00:07:41,840 --> 00:07:44,870
Rack102-FW1。

138
00:07:44,870 --> 00:07:46,820
或者我们可以将其更改为 FW1。

139
00:07:46,820 --> 00:07:47,940
这真的取决于你。

140
00:07:47,940 --> 00:07:51,100
我们可以根据主机名匹配它
。

141
00:07:51,100 --> 00:07:56,340
所以我现在要做的是
我会回到这里，我会

142
00:07:56,340 --> 00:08:02,646
说主机名等于
dev.send_command。

143
00:08:06,580 --> 00:08:07,987
所以我要发送一个命令。

144
00:08:07,987 --> 00:08:09,570
所以我要
要做的是，首先，我是

145
00:08:09,570 --> 00:08:15,120
将确定什么是
设备的主机名。

146
00:08:15,120 --> 00:08:18,990
所以 dev.send_command。

147
00:08:18,990 --> 00:08:20,220
我要寄什么？

148
00:08:20,220 --> 00:08:25,890
让我们发送一个节目。

149
00:08:25,890 --> 00:08:36,000
所以显示运行管道
包括主机名。

150
00:08:36,000 --> 00:08:39,980
所以如果我发送-- 让我们先
测试这个命令。

151
00:08:39,980 --> 00:08:44,750
所以让我们去Firewall1
测试这个命令，

152
00:08:44,750 --> 00:08:46,290
如果这个命令有效。

153
00:08:46,290 --> 00:08:50,300
所以当我做节目时
运行包括主机名，

154
00:08:50,300 --> 00:08:57,530
它确实向我显示了主机名
作为 Rack102 仪表板防火墙。

155
00:08:57,530 --> 00:08:59,610
它确实向我展示了这一点。

156
00:08:59,610 --> 00:09:02,030
如果我看看Router1——

157
00:09:02,030 --> 00:09:07,490
显示运行管道包括
主机名——它显示给我

158
00:09:07,490 --> 00:09:09,620
主机名为Router1。

159
00:09:09,620 --> 00:09:11,220
它确实向我展示了这一点。

160
00:09:11,220 --> 00:09:13,340
所以我能
做的就是我能说

161
00:09:13,340 --> 00:09:16,490
做一个表演包括管道——

162
00:09:16,490 --> 00:09:18,360
管道包括主机名。

163
00:09:18,360 --> 00:09:22,400
一旦你得到
输出，分裂。

164
00:09:22,400 --> 00:09:24,800
所以.split。

165
00:09:24,800 --> 00:09:27,080
现在，如果你还记得，
默认分割

166
00:09:27,080 --> 00:09:29,570
确实根据空格进行拆分。

167
00:09:29,570 --> 00:09:33,720
你可以放，像，
一个逗号之类的，

168
00:09:33,720 --> 00:09:34,970
但我们想要空格。

169
00:09:34,970 --> 00:09:36,470
因为如果您查看
主机名，

170
00:09:36,470 --> 00:09:40,500
有一个主机名空间
主机名值。

171
00:09:40,500 --> 00:09:42,385
所以我想把这个分开。

172
00:09:42,385 --> 00:09:47,000
因此，无论我们从
show run pipe 获得的任何值都包括主机名，

173
00:09:47,000 --> 00:09:49,910
把它分开——

174
00:09:49,910 --> 00:09:56,540
into-- 根据
空格，索引值 1 进行拆分。

175
00:09:56,540 --> 00:10:00,830
所以这要做的是--
如果我不给索引值 1，

176
00:10:00,830 --> 00:10:03,440
那么索引值 0 将
是关键字主机名，

177
00:10:03,440 --> 00:10:08,390
和索引值 1
将是关键值

178
00:10:08,390 --> 00:10:09,980
的实际主机名。

179
00:10:09,980 --> 00:10:12,320
所以路由器1。

180
00:10:12,320 --> 00:10:14,150
所以我实际上
在这里做的是

181
00:10:14,150 --> 00:10:16,490
我是说你
将发送命令

182
00:10:16,490 --> 00:10:18,860
显示运行管道包括主机名。

183
00:10:18,860 --> 00:10:22,370
无论您从
那里得到什么输出，拆分该输出

184
00:10:22,370 --> 00:10:26,810
并且只取第一个，
我只取索引

185
00:10:26,810 --> 00:10:31,400
value 1，表示 index
value 0 就是这个关键字。

186
00:10:31,400 --> 00:10:33,350
索引值 1 将是 Router1。

187
00:10:33,350 --> 00:10:36,200
因此，只需将其
放入主机名中即可。

188
00:10:36,200 --> 00:10:42,050
所以 hostname 等于 show run include 的
输出——

189
00:10:42,050 --> 00:10:46,790
管道包括主机名，
并且只有索引

190
00:10:46,790 --> 00:10:48,560
值 1，这意味着——

191
00:10:48,560 --> 00:10:49,430
它是分裂的。

192
00:10:49,430 --> 00:10:53,720
无论您从
显示运行管道中获得什么值，都包括主机名，

193
00:10:53,720 --> 00:10:57,470
将其拆分并仅获取
实际值，即

194
00:10:57,470 --> 00:10:58,520
是实际的主机名。

195
00:10:58,520 --> 00:11:01,320
不要使用关键字主机名。

196
00:11:01,320 --> 00:11:03,260
我们正在根据空格分割它。

197
00:11:03,260 --> 00:11:08,640
默认情况下，split 会根据空格拆分
它。

198
00:11:08,640 --> 00:11:10,010
所以现在我知道主机名了。

199
00:11:10,010 --> 00:11:12,530
现在我可以把 if
条件，一个条件，

200
00:11:12,530 --> 00:11:13,170
基本上。

201
00:11:13,170 --> 00:11:22,370
所以如果防火墙——如果 fw
在主机名中——

202
00:11:22,370 --> 00:11:26,690
如果 fw 存在于
hostname.lower--

203
00:11:26,690 --> 00:11:29,300
因为我们不希望他
为防火墙输入大写字母，

204
00:11:29,300 --> 00:11:29,910
或小写。

205
00:11:29,910 --> 00:11:30,680
所以我们真的不在乎。

206
00:11:30,680 --> 00:11:32,360
即使他输入
大写，它也会

207
00:11:32,360 --> 00:11:34,220
将其视为小写。

208
00:11:34,220 --> 00:11:38,900
所以如果 fw 存在
在hostname.lower中，

209
00:11:38,900 --> 00:11:42,590
那么我们应该
发送命令——

210
00:11:42,590 --> 00:11:44,900
我们需要发送什么命令？

211
00:11:44,900 --> 00:11:48,710
我们需要发送给他，首先
终端长度。

212
00:11:48,710 --> 00:11:51,500
现在，我相信 ASA 上的
终端长度

213
00:11:51,500 --> 00:11:53,580
与路由器不同。

214
00:11:53,580 --> 00:11:56,600
所以对于路由器来说，
终端长度为0。

215
00:11:56,600 --> 00:12:01,130
我认为对于 ASA，命令
是不同的——终端——

216
00:12:01,130 --> 00:12:03,560
我认为
没有长度命令。

217
00:12:03,560 --> 00:12:08,000
我认为它是终端页面 0。

218
00:12:08,000 --> 00:12:09,840
这就是终端长度的命令
。

219
00:12:09,840 --> 00:12:14,050
所以如果是防火墙，
那么我应该发送——

220
00:12:14,050 --> 00:12:19,680
所以 dev.send_command-- 我们应该发送哪个
命令？

221
00:12:19,680 --> 00:12:25,580
我们应该发送终端页面 0。

222
00:12:25,580 --> 00:12:29,240
否则，我会发送--
所以如果是路由器，

223
00:12:29,240 --> 00:12:33,470
我会发送 dev.send_command--

224
00:12:33,470 --> 00:12:35,390
我们应该发送什么命令？

225
00:12:35,390 --> 00:12:38,670
我们将发送终端长度 0。

226
00:12:41,690 --> 00:12:43,970
所以这将是我的 if 语句。

227
00:12:46,600 --> 00:12:48,370
接下来
我要做的事

228
00:12:48,370 --> 00:12:51,470
现在连接到我的设备。

229
00:12:51,470 --> 00:12:55,180
那么要连接到我的
设备，我们想要做什么？

230
00:12:55,180 --> 00:12:58,370
我们要连接到我们的
设备并首先进行保存

231
00:12:58,370 --> 00:12:58,870
我们的配置。

232
00:12:58,870 --> 00:13:01,330
我们要保存我们的
配置，也就是write mem。

233
00:13:01,330 --> 00:13:03,550
所以我想说——

234
00:13:03,550 --> 00:13:06,800
让我们先打印一下，只是
告诉我们它在做什么。

235
00:13:06,800 --> 00:13:12,100
所以打印——让我们使用
格式字符串。

236
00:13:12,100 --> 00:13:13,850
我们可以使用格式
字符串或者我们可以

237
00:13:13,850 --> 00:13:16,640
使用内置格式方法。

238
00:13:16,640 --> 00:13:18,030
让我们使用格式字符串。

239
00:13:18,030 --> 00:13:28,160
所以打印连接到设备。

240
00:13:28,160 --> 00:13:29,840

我们想连接哪个设备？

241
00:13:29,840 --> 00:13:31,985
所以我想
连接到主机名。

242
00:13:34,668 --> 00:13:35,585
这应该足够了。

243
00:13:38,850 --> 00:13:40,370
所以连接到主机名。

244
00:13:40,370 --> 00:13:43,710
现在，这个主机名
基本上就在这里了。

245
00:13:43,710 --> 00:13:45,140
它是如何获得主机名的？

246
00:13:45,140 --> 00:13:47,960
通过进行演示，然后
拆分该值

247
00:13:47,960 --> 00:13:50,130
并获取主机名。

248
00:13:50,130 --> 00:13:52,010
所以如果防火墙
在主机名中，

249
00:13:52,010 --> 00:13:54,620
然后发送终端页面 0。

250
00:13:54,620 --> 00:13:57,110
否则，发送终端长度 0。

251
00:13:57,110 --> 00:13:58,885
现在，打印连接到设备。

252
00:13:58,885 --> 00:14:00,260
因此，如果它连接
到 R1，它是

253
00:14:00,260 --> 00:14:02,300
将打印
连接到设备 R1。

254
00:14:02,300 --> 00:14:05,240
否则，它会打印
connecting to device Firewall1,

255
00:14:05,240 --> 00:14:08,540
无论主机名是什么。

256
00:14:08,540 --> 00:14:11,690
接下来我
要做的是写内存。

257
00:14:11,690 --> 00:14:13,754
所以我会说 dev.send_command。

258
00:14:16,520 --> 00:14:18,200
我们应该发送什么命令？

259
00:14:18,200 --> 00:14:21,147
写内存。

260
00:14:21,147 --> 00:14:22,605
这就是我们要发送的命令
。

261
00:14:25,230 --> 00:14:28,080
接下来，我们会——

262
00:14:28,080 --> 00:14:31,180
我们想做一场演出。

263
00:14:31,180 --> 00:14:33,570
所以让我们做一个表演。

264
00:14:33,570 --> 00:14:36,090
也许我们可以做一个
打印备份。

265
00:14:36,090 --> 00:14:38,980
让我们再做一次。

266
00:14:38,980 --> 00:14:45,940
所以备份设备——

267
00:14:45,940 --> 00:14:53,590
支持设备的配置，
然后是主机名。

268
00:14:53,590 --> 00:14:55,900
然后我们将发送
命令 show run。

269
00:14:55,900 --> 00:14:59,920
我们将在变量中捕获 show
run 输出，

270
00:14:59,920 --> 00:15:05,590
然后把那个变量
发送到一个文件中，

271
00:15:05,590 --> 00:15:09,890
因为我们要将
配置备份到一个文件中。

272
00:15:09,890 --> 00:15:12,160
所以我想说——

273
00:15:12,160 --> 00:15:14,140
让我们给一些名字。

274
00:15:14,140 --> 00:15:16,060
同样，我们可以使用
任何变量名。

275
00:15:16,060 --> 00:15:23,074
假设 temp 等于
dev.send_command。

276
00:15:27,810 --> 00:15:33,630
我们应该发送
命令show run。

277
00:15:33,630 --> 00:15:35,580
所以，基本上，show run 的
输出

278
00:15:35,580 --> 00:15:36,960
暂时
将被放置

279
00:15:36,960 --> 00:15:41,160
在一个名为 temp 的临时占位符
中。

280
00:15:41,160 --> 00:15:44,610
完成后，现在我
可以使用宽度语句了

281
00:15:44,610 --> 00:15:47,080
写入文件。

282
00:15:47,080 --> 00:15:49,450
所以让我们这样做。

283
00:15:49,450 --> 00:15:53,580
所以随着开放——

284
00:15:53,580 --> 00:15:56,940
我想说-
我们的文件名应该是什么？

285
00:15:56,940 --> 00:16:00,180
我们的文件名
将是 R1.cfg。

286
00:16:00,180 --> 00:16:06,240
它将是 R2.cfg，
它将是 Firewall1.cfg。

287
00:16:06,240 --> 00:16:09,630
现在，我们不会得到 Firewall1.cfg，
因为我们的主机名

288
00:16:09,630 --> 00:16:13,290
防火墙是 Rack102-FW1。

289
00:16:13,290 --> 00:16:18,540
所以我们会得到文件
名称为 Rack102-FW1。

290
00:16:18,540 --> 00:16:21,952
对于 R1，我们将获得 R1.cfg
因为我们已经更改了名称。

291
00:16:21,952 --> 00:16:23,910
或者，事实上，我们已经将
名称改为Router1，

292
00:16:23,910 --> 00:16:26,760
所以我们的文件名
应该是Router1.cfg。

293
00:16:26,760 --> 00:16:29,490
所以为了我们满足
我们的要求，

294
00:16:29,490 --> 00:16:33,540
我们首先要确保
我的主机名是Router1，

295
00:16:33,540 --> 00:16:41,280
我的路由器 2 的主机名是 R2，
我的防火墙主机名

296
00:16:41,280 --> 00:16:43,010
是FW1。

297
00:16:43,010 --> 00:16:44,760
因此，请确保您的
主机名类型匹配

298
00:16:44,760 --> 00:16:46,350
如果您使用
主机名作为脚本。

299
00:16:46,350 --> 00:16:48,960
如果您使用 IP
地址进行连接--

300
00:16:48,960 --> 00:16:53,250
匹配，那么 - 所以如果你在你的 if 中使用 IP 地址


301
00:16:53,250 --> 00:16:55,180
语句，那么
这不是问题。

302
00:16:55,180 --> 00:17:01,500
所以你可以做一个 show
run interface management 0

303
00:17:01,500 --> 00:17:03,250
并获取 IP 地址。

304
00:17:03,250 --> 00:17:06,501
一旦你有了
IP地址，

305
00:17:06,501 --> 00:17:10,200
您可以获取该信息
并将其存储在变量中。

306
00:17:10,200 --> 00:17:12,630
所以我们实际上使用了主机名。

307
00:17:12,630 --> 00:17:15,960
所以如果我使用 IP 地址，
我只会说 IP 地址

308
00:17:15,960 --> 00:17:23,400
等于 dev.send_command show
运行接口管理0/0，

309
00:17:23,400 --> 00:17:28,410
然后.split，根据IP地址拆分
--

310
00:17:28,410 --> 00:17:30,960
基于空格分割。

311
00:17:30,960 --> 00:17:35,040
我的索引值将是--
所以 IP 将是索引值 0。

312
00:17:35,040 --> 00:17:38,010
关键字地址
将是索引值 1。

313
00:17:38,010 --> 00:17:42,060
然后是实际的 IP，
这将是索引值 3。

314
00:17:42,060 --> 00:17:44,820
所以我会在这里给3。

315
00:17:44,820 --> 00:17:47,780
无论如何，我们正在根据主机名进行
，

316
00:17:47,780 --> 00:17:51,540
所以请确保您的主机名
在路由器上匹配。

317
00:17:51,540 --> 00:17:57,300
或者你让你的脚本
匹配任何主机名。

318
00:17:57,300 --> 00:17:58,980
所以随着开放——

319
00:17:58,980 --> 00:18:03,740
我会说格式字符串——

320
00:18:07,050 --> 00:18:14,560
格式字符串——让我们
做主机名.cfg。

321
00:18:14,560 --> 00:18:21,820
所以我的文件名将
基于主机名和.cfg。

322
00:18:21,820 --> 00:18:24,130
这就是我的文件名。

323
00:18:24,130 --> 00:18:27,352
逗号写权限为--

324
00:18:29,950 --> 00:18:36,871
让我们给--让我们
给一个名字，dev_file，

325
00:18:36,871 --> 00:18:39,010
无论你想给什么名字。

326
00:18:39,010 --> 00:18:41,120
同样，这是一个
临时占位符。

327
00:18:41,120 --> 00:18:45,168
所以在 with 语句中，我
会说 dev_file.write--

328
00:18:50,600 --> 00:18:52,070
里面写什么？

329
00:18:52,070 --> 00:18:57,020
我基本上会
编写我的开发配置，

330
00:18:57,020 --> 00:18:59,570
这将是我的临时工。

331
00:18:59,570 --> 00:19:01,250
所以我的温度有演出。

332
00:19:01,250 --> 00:19:03,635
所以写在这个温度里。

333
00:19:10,340 --> 00:19:12,710
最后，我将断开连接。

334
00:19:12,710 --> 00:19:17,350
所以 dev.disconnect 我的会话。

335
00:19:17,350 --> 00:19:18,380
这应该足够了。

336
00:19:18,380 --> 00:19:21,020
这基本上是我的功能。

337
00:19:21,020 --> 00:19:24,110
完成后，我将解释整个
脚本。

338
00:19:24,110 --> 00:19:26,530
所以现在让我们创建一个
for循环来实际运行

339
00:19:26,530 --> 00:19:27,700
通过这个定义。

340
00:19:27,700 --> 00:19:29,200
所以我会创建
一个for循环说，

341
00:19:29,200 --> 00:19:37,730
让我们说，对于，让我们
说，设备中的项目——

342
00:19:37,730 --> 00:19:41,480
所以对于设备中的项目，
这是我的清单--

343
00:19:41,480 --> 00:19:43,500
所以对于设备中的项目，做--

344
00:19:47,470 --> 00:19:49,570
应该是一个冒号。

345
00:19:49,570 --> 00:19:55,090
我应该说运行名为 device_configs 的定义
。

346
00:19:58,040 --> 00:20:00,050
所以 device_configs。

347
00:20:00,050 --> 00:20:07,930
我的输入应该是路由器——

348
00:20:07,930 --> 00:20:08,555
应该是项目。

349
00:20:11,270 --> 00:20:12,410
这就是我的全部剧本。

350
00:20:12,410 --> 00:20:14,640
现在让我们了解脚本。

351
00:20:14,640 --> 00:20:16,460
那么 for 是怎么说的呢？

352
00:20:16,460 --> 00:20:20,300
对于设备中的项目，
表示for循环

353
00:20:20,300 --> 00:20:22,040
将通过列表。

354
00:20:22,040 --> 00:20:23,900
列表中的第一个
项是什么？

355
00:20:23,900 --> 00:20:24,560
R1。

356
00:20:24,560 --> 00:20:26,750
所以项目变成了R1。

357
00:20:26,750 --> 00:20:31,280
所以对于设备中的 R1
config_devices--

358
00:20:31,280 --> 00:20:33,530
我的物品变成了 R1。

359
00:20:33,530 --> 00:20:34,610
这是什么？

360
00:20:34,610 --> 00:20:36,030
这是为函数调用
。

361
00:20:36,030 --> 00:20:38,300
而这个项目是
R1，意思是现在

362
00:20:38,300 --> 00:20:42,050
它运行——它运行这个东西，
它说明了定义

363
00:20:42,050 --> 00:20:43,280
设备配置。

364
00:20:43,280 --> 00:20:46,490
而不是 dev，
您会看到 R1。

365
00:20:46,490 --> 00:20:49,790
所以现在是
R1.establish_connection，

366
00:20:49,790 --> 00:20:51,710
R1.启用。

367
00:20:51,710 --> 00:20:57,923
它会得到 R1 的主机名
，它不会

368
00:20:57,923 --> 00:20:59,590
匹配这个语句
因为它不

369
00:20:59,590 --> 00:21:02,350
在主机名中包含 R1。

370
00:21:02,350 --> 00:21:03,790
它会匹配
else语句

371
00:21:03,790 --> 00:21:07,360
并将终端
长度0发送到R1。

372
00:21:07,360 --> 00:21:12,460
它会打印 Connecting to
设备主机名，即 R1，

373
00:21:12,460 --> 00:21:18,040
然后将write mem发送到
R1，然后打印Backing up

374
00:21:18,040 --> 00:21:21,190
设备 R1 的配置。

375
00:21:21,190 --> 00:21:25,840
然后 R1 的 show run
的输出将存储在 temp 中。

376
00:21:25,840 --> 00:21:29,500
并且打开文件，
我说的是 R1.cfg--

377
00:21:29,500 --> 00:21:34,780
打开这个文件并临时
把它放在 dev_file 中。

378
00:21:34,780 --> 00:21:36,970
dev_file，从 temp 写入。

379
00:21:36,970 --> 00:21:40,090
所以无论 temp 里面是什么，
这就是演出，

380
00:21:40,090 --> 00:21:43,340
把它放在这个文件中，然后
断开会话。

381
00:21:43,340 --> 00:21:45,770
然后 for 循环再次
执行下一项，

382
00:21:45,770 --> 00:21:48,340
这将是R2。

383
00:21:48,340 --> 00:21:51,080
所以这应该是--
这应该可行。

384
00:21:51,080 --> 00:21:53,710
我们还需要一件事
，

385
00:21:53,710 --> 00:21:58,450
我们需要导入操作系统吗？

386
00:21:58,450 --> 00:22:03,265
我们需要 os.chdir。

387
00:22:06,920 --> 00:22:08,860
我将
目录改成路径

388
00:22:08,860 --> 00:22:11,847
我们希望在
Ubuntu机器中。

389
00:22:11,847 --> 00:22:13,930
所以关于这个问题，
我们应该存储它

390
00:22:13,930 --> 00:22:15,350
在特定文件夹中。

391
00:22:15,350 --> 00:22:18,850
所以对于你们来说，
无论你的文件夹是什么，

392
00:22:18,850 --> 00:22:20,470
您会将
存储在您的文件夹中。

393
00:22:20,470 --> 00:22:23,440
至于我，我的机架
是102，所以我应该

394
00:22:23,440 --> 00:22:26,380
根据问题将其存储在特定的
文件夹中。

395
00:22:26,380 --> 00:22:29,230
所以 cd Desktop，cd rohit。

396
00:22:29,230 --> 00:22:31,030
那是我的文件夹。

397
00:22:31,030 --> 00:22:36,230
让我们复制这个
并把它放在这里。

398
00:22:36,230 --> 00:22:39,740
所以将我的目录
更改为这个文件夹。

399
00:22:39,740 --> 00:22:41,200
这就是
我基本上会

400
00:22:41,200 --> 00:22:44,200
正在执行脚本
并存储文件。

401
00:22:44,200 --> 00:22:51,110
现在让我们保存这个
文件并复制它。

402
00:22:51,110 --> 00:22:55,150
所以让我们做 cd
Desktop, cd rohit,

403
00:22:55,150 --> 00:23:03,140
然后对我的 Ubuntu 机器执行 sftp，

404
00:23:03,140 --> 00:23:05,010
这是密码是cisco。

405
00:23:08,030 --> 00:23:12,008
我会说把
netmiko_challenge3.py--

406
00:23:15,530 --> 00:23:18,150
把它放在这个文件夹中。

407
00:23:18,150 --> 00:23:19,110
所以它应该复制那个。

408
00:23:19,110 --> 00:23:20,750
让我们回到
我的 Ubuntu 机器。

409
00:23:20,750 --> 00:23:24,290
我应该有
netmiko3_challenge3。

410
00:23:24,290 --> 00:23:25,770
让我们执行这个。

411
00:23:25,770 --> 00:23:29,120
所以python3 netmiko_challeng3.py。

412
00:23:33,200 --> 00:23:39,080
我发现我的脚本中有
错误

413
00:23:39,080 --> 00:23:40,190
在连接处理程序中。

414
00:23:40,190 --> 00:23:42,260
我想我一定是
拼错了。

415
00:23:42,260 --> 00:23:43,760
是的。

416
00:23:43,760 --> 00:23:46,820
所以我有一个错字。

417
00:23:46,820 --> 00:23:52,840
让我们再次保存它
并重新复制它。

418
00:23:59,020 --> 00:24:01,020
所以它上传我的文件。

419
00:24:01,020 --> 00:24:03,935
让我们返回并
执行脚本。

420
00:24:19,840 --> 00:24:25,050
所以我应该看到一些
打印语句

421
00:24:25,050 --> 00:24:26,685
如果它执行正确。

422
00:25:20,180 --> 00:25:23,560
让我们同时返回
并再次检查我们的脚本。

423
00:25:23,560 --> 00:25:27,880
所以这看起来不错。

424
00:25:27,880 --> 00:25:33,970
devices 有 r1, r2, fw1,
和这个同名。

425
00:25:33,970 --> 00:25:36,850
函数名
是device_configs。

426
00:25:36,850 --> 00:25:39,100
dev 被替换为 item。

427
00:25:39,100 --> 00:25:42,920
项目被替换
列表。

428
00:25:42,920 --> 00:25:48,180
它看起来不错。

429
00:25:48,180 --> 00:25:49,470
所以让我们回去检查一下。

430
00:25:54,210 --> 00:25:58,700
所以我收到了一些错误
说连接

431
00:25:58,700 --> 00:26:02,790
到设备 asa 超时。

432
00:26:02,790 --> 00:26:04,340
我们去看看我的 ASA。

433
00:26:07,742 --> 00:26:11,220
所以我相信一个是ASA问题。

434
00:26:11,220 --> 00:26:17,350
而且，是的，我相信这是唯一的


435
00:26:17,350 --> 00:26:20,360
问题，连接到 ASA。

436
00:26:20,360 --> 00:26:22,610
所以现在防火墙，
默认情况下，不

437
00:26:22,610 --> 00:26:28,770
允许 ssh 或任何远程
连接到设备。

438
00:26:28,770 --> 00:26:30,560
默认情况下，它不允许。

439
00:26:30,560 --> 00:26:35,570
因此，如果我进行演出
ssh，我应该——

440
00:26:35,570 --> 00:26:41,330
我看到只允许 10.6.0.0
做 ssh。

441
00:26:41,330 --> 00:26:46,130
我只是要添加
我的 ssh 以允许

442
00:26:46,130 --> 00:26:53,670
来自
管理界面上的任何人，

443
00:26:53,670 --> 00:26:57,540
或接口管理0。

444
00:26:57,540 --> 00:27:00,630
让我们再试一次
运行脚本。

445
00:27:00,630 --> 00:27:04,400
让我们返回并
重新运行脚本。

446
00:27:07,332 --> 00:27:09,540
因为默认情况下，
防火墙不允许 ssh。

447
00:27:09,540 --> 00:27:13,010
所以你必须在防火墙上启用
ssh

448
00:27:13,010 --> 00:27:15,470
如果您希望
脚本实际上是

449
00:27:15,470 --> 00:27:17,015
能够连接到设备。

450
00:27:21,340 --> 00:27:23,750
如您现在所见，我
看到一条打印消息

451
00:27:23,750 --> 00:27:25,650
说连接设备 R1。

452
00:27:25,650 --> 00:27:28,290
备份设备 R1 的配置。

453
00:27:28,290 --> 00:27:30,000
连接到设备 R2。

454
00:27:30,000 --> 00:27:32,670
备份 R2 的配置。

455
00:27:32,670 --> 00:27:33,990
连接到防火墙。

456
00:27:33,990 --> 00:27:36,280
备份设备防火墙的配置
。

457
00:27:36,280 --> 00:27:39,390
所以现在它已经基本
连接到所有设备了

458
00:27:39,390 --> 00:27:42,630
并运行我的脚本，它
应该已经备份了文件。

459
00:27:42,630 --> 00:27:45,040
让我们回去做一个ls。

460
00:27:45,040 --> 00:27:49,770
我应该看到 R1.cfg、
R2.cfg 和 FW1,cfg。

461
00:27:49,770 --> 00:27:55,290
因此，如果我执行 cat FW1.cfg，我
应该会看到正在运行的配置

462
00:27:55,290 --> 00:27:56,820
我的防火墙。

463
00:27:56,820 --> 00:27:59,770
至此，我们基本上
完成了我们的任务。

464
00:27:59,770 --> 00:28:02,680
所以，很快，我会
再次向您展示我的脚本。

465
00:28:02,680 --> 00:28:05,940
这正是我们所做的，
我们使用了一个函数，

466
00:28:05,940 --> 00:28:09,030
我们使用 for 循环
遍历所有列表。

467
00:28:09,030 --> 00:28:11,730
现在，我根据主机名匹配它
，

468
00:28:11,730 --> 00:28:16,050
但如果您愿意，您可以根据 IP 地址进行匹配
。

469
00:28:16,050 --> 00:28:21,040
唯一的区别
是这个变量名，

470
00:28:21,040 --> 00:28:22,560
你可以给ip_address。

471
00:28:22,560 --> 00:28:28,940
这将是一个表演运行
接口管理0/0，

472
00:28:28,940 --> 00:28:30,960
或您的
管理界面。

473
00:28:30,960 --> 00:28:34,860
.split--再次基于空格分割它。

474
00:28:34,860 --> 00:28:37,800
你会选择3号。

475
00:28:37,800 --> 00:28:40,650
因为如果您查看 IP
地址--让我们做一个演示--

476
00:28:40,650 --> 00:28:44,880
让我们去防火墙做一个显示运行界面管理

477
00:28:44,880 --> 00:28:46,350
0/0。

478
00:28:46,350 --> 00:28:49,200
您实际上会看到 IP
地址——

479
00:28:49,200 --> 00:28:50,670
这是索引值 0。

480
00:28:50,670 --> 00:28:53,130
这是索引值 1。

481
00:28:53,130 --> 00:28:54,510
这是索引值 2。

482
00:28:54,510 --> 00:28:57,780
所以你会给索引值2。

483
00:28:57,780 --> 00:29:02,500
再说一次，如果我真的
拆分这个——让我们事实上

484
00:29:02,500 --> 00:29:03,390
试试这个。

485
00:29:03,390 --> 00:29:07,410
我要做的是，只是
看看价值是多少，

486
00:29:07,410 --> 00:29:10,740
让我们发送一个命令。

487
00:29:10,740 --> 00:29:17,690
让我们带着这个
去我们的 Ubuntu 机器。

488
00:29:17,690 --> 00:29:20,370
我们先上Python
，python3。

489
00:29:20,370 --> 00:29:27,210
我们将导入
ConnectHandler。

490
00:29:27,210 --> 00:29:29,460
所以我正在导入 ConnectHandler。

491
00:29:29,460 --> 00:29:34,740
我会连接到
我的防火墙，只是

492
00:29:34,740 --> 00:29:38,790
测试我应该给出什么 index
值。

493
00:29:38,790 --> 00:29:48,510
让我们也给
ip_address等于--

494
00:29:48,510 --> 00:29:53,250
我们会给fw1。

495
00:29:53,250 --> 00:29:54,768
所以 fw1.send_command。

496
00:29:58,050 --> 00:30:08,700
我会发送命令
show run interface management

497
00:30:08,700 --> 00:30:10,230
0/0。

498
00:30:10,230 --> 00:30:12,420
所以我要
发送这个命令。

499
00:30:12,420 --> 00:30:14,190
我会说.split。

500
00:30:17,670 --> 00:30:20,820
我不会给出任何
索引值，就这么多。

501
00:30:20,820 --> 00:30:22,670
让我们看看
它分裂了什么。

502
00:30:22,670 --> 00:30:26,040
所以让我们做 ip_address
只是为了看看。

503
00:30:26,040 --> 00:30:27,370
所以我得到了这个信息。

504
00:30:27,370 --> 00:30:28,930
那么IP地址在哪里呢？

505
00:30:28,930 --> 00:30:38,450
所以这是索引值 0, 1,
2, 3, 4, 5, 6, 7, 8, 9, 10, 11。

506
00:30:38,450 --> 00:30:39,868
所以我会给索引值 11。

507
00:30:39,868 --> 00:30:41,910
所以如果我是根据IP地址拆分它
，

508
00:30:41,910 --> 00:30:44,010
我会给索引值 11。

509
00:30:44,010 --> 00:30:47,410
这就是你需要
基本上使用

510
00:30:47,410 --> 00:30:49,060
定义和功能。

511
00:30:49,060 --> 00:30:52,740
而我——如果你
认识他，项目是

512
00:30:52,740 --> 00:30:54,520
将浏览列表。

513
00:30:54,520 --> 00:30:58,500
所以列表中的第一项
是R1，所以item变成了R1。

514
00:30:58,500 --> 00:31:00,390
然后我运行
函数，

515
00:31:00,390 --> 00:31:03,420
并且 dev 被替换为
item，这

516
00:31:03,420 --> 00:31:04,950
意味着它将是R1。

517
00:31:04,950 --> 00:31:08,700
所以它变成了
R1.建立，R1.启用，

518
00:31:08,700 --> 00:31:13,620
然后是 R1.send 命令，
并获取 R1 的主机名。

519
00:31:13,620 --> 00:31:17,130
如果是——

520
00:31:17,130 --> 00:31:18,720
它不会是
Firewall1，所以它

521
00:31:18,720 --> 00:31:20,430
匹配 else 语句。

522
00:31:20,430 --> 00:31:21,930
因此，终端长度为 0。

523
00:31:21,930 --> 00:31:24,300
然后将 Connecting
打印到设备主机名。

524
00:31:24,300 --> 00:31:26,400
主机名等于 R1。

525
00:31:26,400 --> 00:31:33,210
并写入内存，
将节目运行发送到 temp。

526
00:31:33,210 --> 00:31:37,260
然后我们打开
文件并写入 temp

527
00:31:37,260 --> 00:31:38,232
进入那个文件。

528
00:31:38,232 --> 00:31:39,190
这就是我们正在做的。

529
00:31:39,190 --> 00:31:42,720
然后我们也在为其他设备运行 for
循环。

530
00:31:42,720 --> 00:31:44,680
我希望此视频
对您有所帮助，