1
00:00:03,409 --> 00:00:07,792
[电子音乐]

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

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

4
00:00:14,730 --> 00:00:16,170
挑战 2。

5
00:00:16,170 --> 00:00:19,500
所以在这里我们将再次
完成一项成熟的任务，

6
00:00:19,500 --> 00:00:21,450
我们将在哪里连接
思科路由器，

7
00:00:21,450 --> 00:00:25,680
或许执行一些命令，
看一下show run，

8
00:00:25,680 --> 00:00:26,940
也许备份文件。

9
00:00:26,940 --> 00:00:30,330
与我们
在上一个视频中所做的完全一样。

10
00:00:30,330 --> 00:00:33,130
然而，这一次我们
将采取不同的做法。

11
00:00:33,130 --> 00:00:35,310
那么让我们看看
任务需求。

12
00:00:35,310 --> 00:00:37,150
任务是创建一个名为
Python 脚本

13
00:00:37,150 --> 00:00:41,940
作为 netmiko_challenge2.py
在特定文件夹中，

14
00:00:41,940 --> 00:00:44,520
并且此脚本必须
完成以下任务。

15
00:00:44,520 --> 00:00:47,670
它必须连接到每个
路由器Router1 和Router2。

16
00:00:47,670 --> 00:00:50,790
它必须保存每个路由器的
配置。

17
00:00:50,790 --> 00:00:52,620
它必须备份配置——

18
00:00:52,620 --> 00:00:54,660
这是显示
运行- 到一个文件

19
00:00:54,660 --> 00:00:59,940
在 Ubuntu 机器上的一个
文件夹中调用 R1.cfg 和 R2.cfg。

20
00:00:59,940 --> 00:01:02,220
不要使用函数或
条件来实现

21
00:01:02,220 --> 00:01:06,370
这个任务，你必须使用一个
for循环来完成这个任务。

22
00:01:06,370 --> 00:01:10,170
所以这个任务和之前的视频一模一样。

23
00:01:10,170 --> 00:01:13,110
但是，不同的是
这一次我们会

24
00:01:13,110 --> 00:01:16,270
使用 for 循环来实现这一点。

25
00:01:16,270 --> 00:01:19,090
所以让我们快点去做吧。

26
00:01:19,090 --> 00:01:21,760
所以我想说的是
暂停视频，

27
00:01:21,760 --> 00:01:23,680
自己尝试一下。

28
00:01:23,680 --> 00:01:26,940
如果您遇到困难，您可以
随时回顾视频

29
00:01:26,940 --> 00:01:29,500
看看我是怎么做的。

30
00:01:29,500 --> 00:01:33,660
整个想法是了解
不同的做法。

31
00:01:33,660 --> 00:01:36,690
在上一个视频中，我
没有使用 for 循环。

32
00:01:36,690 --> 00:01:41,280
我没有使用任何
函数或条件。

33
00:01:41,280 --> 00:01:45,150
所以我不得不为每个路由器创建单独的
行。

34
00:01:45,150 --> 00:01:47,910
现在，想象一下如果我有
数百个路由器。

35
00:01:47,910 --> 00:01:49,800
我将不得不
编写那个代码——

36
00:01:49,800 --> 00:01:52,530
事实上，让我们回到那个解决方案


37
00:01:52,530 --> 00:01:54,190
我们为
上一个视频准备的，

38
00:01:54,190 --> 00:01:57,810
我将不得不为每个路由器编写这个
很多代码。

39
00:01:57,810 --> 00:01:59,560
这将适用于每个路由器。

40
00:01:59,560 --> 00:02:01,140
所以想象一下，如果我有 100 个路由器。

41
00:02:01,140 --> 00:02:03,180
我的剧本会很大。

42
00:02:03,180 --> 00:02:05,340
这就是 for
循环可以发挥作用的地方，

43
00:02:05,340 --> 00:02:10,380
我们也许可以通过
所有路由器列表

44
00:02:10,380 --> 00:02:14,140
并为所有这些运行完全相同的
命令。

45
00:02:14,140 --> 00:02:17,320
因此，让我们尝试使用 for 循环来实现
。

46
00:02:17,320 --> 00:02:21,000
所以我现在要做的是创建一个新文件。

47
00:02:21,000 --> 00:02:26,144
我们将这个文件命名为
netmiko_challenge2.py。

48
00:02:31,350 --> 00:02:36,700
让我们尝试完全按照要求执行
。

49
00:02:36,700 --> 00:02:38,880
所以
我要做的第一件事——这个

50
00:02:38,880 --> 00:02:40,600
将是一样的。

51
00:02:40,600 --> 00:02:45,660
所以这部分将是
完全一样的，我不是

52
00:02:45,660 --> 00:02:47,020
将做出任何改变。

53
00:02:47,020 --> 00:02:50,280
所以我会导入
os 模块，制作

54
00:02:50,280 --> 00:02:52,230
确定我的文件夹是
正确的文件夹。

55
00:02:52,230 --> 00:02:55,260
然后从 netmiko 我会
导入 ConnectHandler。

56
00:02:55,260 --> 00:02:59,640
因此，让我们将其复制到
我的文件中，这样我就没有

57
00:02:59,640 --> 00:03:02,220
重写整个事情。

58
00:03:02,220 --> 00:03:03,870
接下来
我要做的事

59
00:03:03,870 --> 00:03:06,143
我会连接到我的路由器吗？

60
00:03:09,230 --> 00:03:12,010
所以这部分
要进来了。

61
00:03:12,010 --> 00:03:19,840
所以也许我可以说 print
ConnectHandler。

62
00:03:19,840 --> 00:03:22,220
所以让我们去做吧。

63
00:03:22,220 --> 00:03:23,763
所以我会
连接到我的路由器。

64
00:03:23,763 --> 00:03:25,180
所以，再次，这个
可以在

65
00:03:25,180 --> 00:03:28,820
for 循环，它
连接到我所有的路由器。

66
00:03:28,820 --> 00:03:31,510
让我们删除
打印语句。

67
00:03:31,510 --> 00:03:34,220
我们不需要那个。

68
00:03:34,220 --> 00:03:41,570
我们也复制r2，
r2的连接在这里。

69
00:03:44,450 --> 00:03:46,350
所以这部分保持不变。

70
00:03:46,350 --> 00:03:49,670
唯一的区别是我
实际上把所有这些

71
00:03:49,670 --> 00:03:50,490
一起。

72
00:03:50,490 --> 00:03:53,540
然后我会创建一个 for
循环来实际进行打印，

73
00:03:53,540 --> 00:03:56,570
做备份，发送
终端长度0，

74
00:03:56,570 --> 00:03:58,400
发送显示运行命令。

75
00:03:58,400 --> 00:04:00,260
我会在 for 循环中这样做。

76
00:04:00,260 --> 00:04:01,730
接下来
我要做的事

77
00:04:01,730 --> 00:04:04,400
我要
创建一个列表

78
00:04:04,400 --> 00:04:07,260
包含所有这些设备。

79
00:04:07,260 --> 00:04:08,370
所以让我们创建一个。

80
00:04:08,370 --> 00:04:14,690
所以设备等于-- 让我们
制作一个r1 逗号r2 的列表。

81
00:04:14,690 --> 00:04:19,709
所以我有一个列表，基本上
这里包含我的两个变量，

82
00:04:19,709 --> 00:04:21,649
这是r1和r2。

83
00:04:21,649 --> 00:04:25,450
现在我可以
创建我的 for 循环了。

84
00:04:25,450 --> 00:04:28,440
所以我们想要
发送到路由器的所有命令，

85
00:04:28,440 --> 00:04:30,990
已启用。

86
00:04:30,990 --> 00:04:36,720
然后我们保存
配置，写mem。

87
00:04:36,720 --> 00:04:38,880
我们的终端长度为 0。

88
00:04:38,880 --> 00:04:40,320
我们进行了表演。

89
00:04:40,320 --> 00:04:42,330
然后写文件——

90
00:04:42,330 --> 00:04:44,820
编写显示运行，
复制显示运行输出

91
00:04:44,820 --> 00:04:49,470
放入一个临时的
占位符，然后写入

92
00:04:49,470 --> 00:04:50,730
到文件中——

93
00:04:50,730 --> 00:04:53,860
对于所有路由器来说，所有这些都是通用的
。

94
00:04:53,860 --> 00:04:56,010
所以让我们用一个 for 循环来做这个
。

95
00:04:56,010 --> 00:04:59,190
早些时候，我必须单独执行此操作，

96
00:04:59,190 --> 00:05:01,890
一个用于Router1，
一个用于Router2，

97
00:05:01,890 --> 00:05:05,290
但这次我可以在 for 循环中执行此操作。

98
00:05:05,290 --> 00:05:08,242
所以让我们去构建它。

99
00:05:08,242 --> 00:05:09,450
所以我会创建一个for循环。

100
00:05:09,450 --> 00:05:13,940
所以，让我们说，
设备中的开发者——

101
00:05:13,940 --> 00:05:15,610
所以我正在浏览列表。

102
00:05:15,610 --> 00:05:20,410
所以这是我的列表，
是设备，就在这里。

103
00:05:20,410 --> 00:05:23,730
所以对于 dev--dev 只是我的一个
临时占位符

104
00:05:23,730 --> 00:05:24,670
for 循环。

105
00:05:24,670 --> 00:05:26,010
它只是一个 for 循环名称。

106
00:05:26,010 --> 00:05:30,390
因此，对于
设备中的开发人员，我会这样做——

107
00:05:30,390 --> 00:05:32,530
我将首先建立
我的连接。

108
00:05:32,530 --> 00:05:34,590
所以我会建立
到r1的这个连接，

109
00:05:34,590 --> 00:05:38,010
与 r2 的连接，
可以通过

110
00:05:38,010 --> 00:05:49,890
dev.establish_connection，以及
我的左括号并关闭

111
00:05:49,890 --> 00:05:50,550
插入语。

112
00:05:50,550 --> 00:05:54,480
所以这基本上
连接到路由器。

113
00:05:54,480 --> 00:05:57,030
同样，这
仍会连接，但我们

114
00:05:57,030 --> 00:05:59,890
确保我实际上
连接到路由器。

115
00:05:59,890 --> 00:06:02,220
所以我建立了一个连接。

116
00:06:02,220 --> 00:06:04,370
接下来我
要做的是启用。

117
00:06:04,370 --> 00:06:06,730
启用对于所有路由器将是
通用的。

118
00:06:06,730 --> 00:06:11,250
所以这将
成为dev.enable。

119
00:06:11,250 --> 00:06:16,870
然后我会说
连接到设备。

120
00:06:16,870 --> 00:06:18,840
所以也许我可以打印一下。

121
00:06:18,840 --> 00:06:26,560
所以打印连接到设备。

122
00:06:26,560 --> 00:06:28,830
所以我并不是真的
输入路由器名称。

123
00:06:28,830 --> 00:06:32,190
所以这可能只是
连接到设备，

124
00:06:32,190 --> 00:06:36,600
就像一个普通的字符串
说连接到设备。

125
00:06:36,600 --> 00:06:39,090
然后我会做——

126
00:06:39,090 --> 00:06:41,640
也许我可以做到
这实际上在这里。

127
00:06:41,640 --> 00:06:45,820
也许我可以把这个
放在开发者之前，

128
00:06:45,820 --> 00:06:47,920
在建立连接之前。

129
00:06:50,440 --> 00:06:54,310
让我们回去把它放在这里。

130
00:06:54,310 --> 00:06:55,740
所以连接到设备。

131
00:06:55,740 --> 00:06:59,580
然后我有
dev.establish_connection，

132
00:06:59,580 --> 00:07:00,880
使能够。

133
00:07:00,880 --> 00:07:03,510
现在我可以说
保存路由器——

134
00:07:03,510 --> 00:07:08,358
保存配置，也许
保存配置。

135
00:07:08,358 --> 00:07:09,900
所以我有一个打印
声明。

136
00:07:09,900 --> 00:07:12,060
我会寄信给我。

137
00:07:12,060 --> 00:07:14,658
所以这将是
dev.send_command。

138
00:07:17,460 --> 00:07:20,483
我
要发送哪个命令？写内存。

139
00:07:20,483 --> 00:07:22,150
这就是我要发送的命令
。

140
00:07:22,150 --> 00:07:23,530
看，完全一样。

141
00:07:23,530 --> 00:07:28,360
所以在for循环中，我们
这样做的方式是完全一样的。

142
00:07:28,360 --> 00:07:30,810
唯一的区别
是，早些时候，我们

143
00:07:30,810 --> 00:07:33,330
说r1.send。

144
00:07:33,330 --> 00:07:34,530
r1 是什么？

145
00:07:34,530 --> 00:07:36,390
正是这个变量
在这里，我们

146
00:07:36,390 --> 00:07:38,160
已创建连接到 R1。

147
00:07:38,160 --> 00:07:40,470
所以它是 r1.variable--

148
00:07:40,470 --> 00:07:41,940
.send_command。

149
00:07:41,940 --> 00:07:44,870
现在我们说 dev.enable。

150
00:07:44,870 --> 00:07:49,180
dev 是我这里的 for 循环，
是设备中的 for dev。

151
00:07:49,180 --> 00:07:52,140
那么，
dev 中的内容是什么——dev 中的内容是什么？

152
00:07:52,140 --> 00:07:54,150
dev 将是--
首先，它将是 r1。

153
00:07:54,150 --> 00:07:57,180
所以它基本上是 r1.enable。

154
00:07:57,180 --> 00:08:00,120
它是 r1.send_command。

155
00:08:00,120 --> 00:08:02,580
所以 dev 只是一个
临时占位符，

156
00:08:02,580 --> 00:08:05,550
每次都会改变
因为它是

157
00:08:05,550 --> 00:08:07,950
扫描
您的整个列表。

158
00:08:07,950 --> 00:08:10,980
所以我一开始的开发
将是 r1。

159
00:08:10,980 --> 00:08:15,360
完成后，我的开发人员
将自动成为 r2。

160
00:08:15,360 --> 00:08:19,260
所以 dev.send_command 写 mem。

161
00:08:19,260 --> 00:08:22,890
接下来我们
想做的是我们想要

162
00:08:22,890 --> 00:08:24,570
更改终端长度。

163
00:08:24,570 --> 00:08:27,039
所以让我们这样做--
dev.send_command。

164
00:08:29,820 --> 00:08:36,059
我们将发送终端长度 0。

165
00:08:36,059 --> 00:08:44,900
然后我们想要，
比方说，捕捉——

166
00:08:44,900 --> 00:08:47,815
我相信要求
是备份配置。

167
00:08:47,815 --> 00:08:49,190
我相信这是
要求。

168
00:08:49,190 --> 00:08:51,110
所以备份配置。

169
00:08:51,110 --> 00:08:54,350
所以，为此，我们可以
再次打印，比如如何

170
00:08:54,350 --> 00:08:55,560
我们确实保存了配置。

171
00:08:55,560 --> 00:09:01,140
现在我们可以对文件夹说Backing
up configs。

172
00:09:01,140 --> 00:09:02,285
所以让我们打印一下。

173
00:09:05,570 --> 00:09:07,460
让我们回到这里。

174
00:09:07,460 --> 00:09:08,840
也许就在
终端长度之前

175
00:09:08,840 --> 00:09:15,995
我们可以说Backing
Up Configs to Folder。

176
00:09:20,320 --> 00:09:23,080
然后我发送
终端长度0。

177
00:09:23,080 --> 00:09:24,560
我们还想要什么？

178
00:09:24,560 --> 00:09:28,510
我们要存储配置。

179
00:09:28,510 --> 00:09:30,980
所以这部分
是完全一样的。

180
00:09:30,980 --> 00:09:33,280
唯一的区别是
我们正在这样做

181
00:09:33,280 --> 00:09:34,670
在 for 循环中。

182
00:09:34,670 --> 00:09:38,020
所以我会说，在
终端长度为0之后，

183
00:09:38,020 --> 00:09:40,970
让我们做一个 with 声明。

184
00:09:40,970 --> 00:09:42,670
所以在 with
语句之前，我需要

185
00:09:42,670 --> 00:09:45,850
将演出捕捉到
临时占位符，

186
00:09:45,850 --> 00:09:46,760
像一个变量。

187
00:09:46,760 --> 00:09:49,960
所以我想说——

188
00:09:49,960 --> 00:09:53,800
假设 dev_config--
它只是任何名称--

189
00:09:53,800 --> 00:09:56,370
等于 dev.send_command。

190
00:09:59,780 --> 00:10:01,190
我们发送的是哪个命令
？

191
00:10:01,190 --> 00:10:02,750
秀跑。

192
00:10:02,750 --> 00:10:05,000
所以show run，show run的
输出

193
00:10:05,000 --> 00:10:08,780
将被临时
放置在 dev_config 中。

194
00:10:08,780 --> 00:10:12,140
然后我可以将
写入文件，该文件

195
00:10:12,140 --> 00:10:15,800
将与开放--

196
00:10:15,800 --> 00:10:17,330
文件名是什么？

197
00:10:17,330 --> 00:10:22,490
文件名应该是
是R1.cfg，然后是R2.cfg，然后

198
00:10:22,490 --> 00:10:24,960
R2.cfg 等等。

199
00:10:24,960 --> 00:10:30,200
所以我能做的是，
而不是写 R1.cfg--

200
00:10:30,200 --> 00:10:32,750
因为这使得
它非常静态。

201
00:10:32,750 --> 00:10:38,000
我可能有数百个路由器，
分别是R1，R2，R3，R4，R5，

202
00:10:38,000 --> 00:10:39,690
R6 和 R7，以此类推。

203
00:10:39,690 --> 00:10:44,690
所以我要做的是
我要说 R

204
00:10:44,690 --> 00:10:51,470
加上一串，比如说，n。

205
00:10:51,470 --> 00:10:53,120
所以字符串 n。

206
00:10:53,120 --> 00:11:08,350
另外我会说.cfg
逗号，然后写为temp。

207
00:11:08,350 --> 00:11:10,240
所以我实际上
在这里做的是

208
00:11:10,240 --> 00:11:14,120
我是说文件
名称将是--

209
00:11:14,120 --> 00:11:18,490
所以我们需要它是 R1.cfg，
我们需要它是 R2.cfg，

210
00:11:18,490 --> 00:11:22,310
然后是 R3.cfg、
R4、cfg 等等。

211
00:11:22,310 --> 00:11:27,550
所以我说文件名
将是 R 加上一个字符串

212
00:11:27,550 --> 00:11:30,340
n 加上 .cfg。

213
00:11:30,340 --> 00:11:35,180
所以它将是
R1.cfg、R2.cfg 等等。

214
00:11:35,180 --> 00:11:37,510
但是我们还没有真正
定义这个n。

215
00:11:37,510 --> 00:11:39,200
我将对此进行定义。

216
00:11:39,200 --> 00:11:42,700
所以用
写权限创建这个文件，

217
00:11:42,700 --> 00:11:48,410
并将其临时存储在称为 temp 的占位符中。

218
00:11:48,410 --> 00:11:56,840
在此范围内，我们会
说，我相信，temp.write。

219
00:12:00,390 --> 00:12:02,700
我们会说——
我们要写什么？

220
00:12:02,700 --> 00:12:05,670
因此，如果您之前看一下，当
我们单独做这件事时，

221
00:12:05,670 --> 00:12:10,650
我们说的是 r1_config，
这是我的变量

222
00:12:10,650 --> 00:12:13,680
用于显示运行的输出。

223
00:12:13,680 --> 00:12:17,580
所以现在我会说 dev_config。

224
00:12:17,580 --> 00:12:20,280
所以dev_config。

225
00:12:20,280 --> 00:12:23,910
那么 dev_config
将包含什么？

226
00:12:23,910 --> 00:12:28,230
它将包含相应路由器的 show
运行。

227
00:12:28,230 --> 00:12:31,320
下一步将是
断开连接，

228
00:12:31,320 --> 00:12:34,053
这将是
dev.disconnect。

229
00:12:37,440 --> 00:12:43,320
最后，我将定义
n 等于 n 加 1。

230
00:12:43,320 --> 00:12:44,350
就是这样。

231
00:12:44,350 --> 00:12:46,530
这就是我所需要的。

232
00:12:46,530 --> 00:12:51,097
让我们保存它，看看
它是如何工作的。

233
00:12:51,097 --> 00:12:52,180
那么会发生什么？

234
00:12:52,180 --> 00:12:53,847
脚本
要做什么

235
00:12:53,847 --> 00:12:54,980
我执行脚本？

236
00:12:54,980 --> 00:12:56,500
它将导入操作系统。

237
00:12:56,500 --> 00:12:58,240
它会
更改我的目录。

238
00:12:58,240 --> 00:13:00,370
它将导入
ConnectHandler。

239
00:13:00,370 --> 00:13:02,590
它将连接到我的两个路由器。

240
00:13:02,590 --> 00:13:07,330
然后它创建一个列表，
其中包含 r1 和 r2。

241
00:13:07,330 --> 00:13:11,050
然后它运行 for 循环，
上面写着 print Connecting

242
00:13:11,050 --> 00:13:11,690
到设备。

243
00:13:11,690 --> 00:13:15,680
所以一开始，首先要
遍历索引值

244
00:13:15,680 --> 00:13:17,365
0，这将是 r1。

245
00:13:17,365 --> 00:13:20,112
所以 dev 将等于 r1。

246
00:13:20,112 --> 00:13:21,820
所以它将
连接到设备，

247
00:13:21,820 --> 00:13:23,080
这将是 r1。

248
00:13:23,080 --> 00:13:25,210
然后它与它建立一个
连接。

249
00:13:25,210 --> 00:13:26,590
它启用。

250
00:13:26,590 --> 00:13:28,750
它确实打印保存配置。

251
00:13:28,750 --> 00:13:31,330
发送命令 write mem。

252
00:13:31,330 --> 00:13:33,250
将配置
备份到文件夹。

253
00:13:33,250 --> 00:13:35,170
终端长度是否为 0。

254
00:13:35,170 --> 00:13:38,770
将 show
run 的配置存储到 dev_config 中，

255
00:13:38,770 --> 00:13:46,030
然后以 R 加上变量 n 打开一个名为
的文件。

256
00:13:46,030 --> 00:13:48,340
而n等于
什么？ n 等于 n

257
00:13:48,340 --> 00:13:51,400
加 1，即默认情况下，
它将以 1 开头。

258
00:13:51,400 --> 00:13:52,750
所以它将是1。

259
00:13:52,750 --> 00:13:54,790
然后是.cfg。

260
00:13:54,790 --> 00:13:57,970
它打开文件
并存储输出

261
00:13:57,970 --> 00:14:02,380

文件中的dev_config，然后关闭文件，

262
00:14:02,380 --> 00:14:04,510
然后断开
会话。

263
00:14:04,510 --> 00:14:08,440
然后 n 变为 2，
它再次执行 for 循环。

264
00:14:08,440 --> 00:14:11,110
这一次，dev
将是r2，它

265
00:14:11,110 --> 00:14:13,960

再次遍历整个脚本。

266
00:14:13,960 --> 00:14:16,480
所以让我们执行这个。

267
00:14:16,480 --> 00:14:17,830
我会保存这个。

268
00:14:17,830 --> 00:14:22,450
我会把这个复制到——

269
00:14:22,450 --> 00:14:25,420
相信它是
netmiko_challenge2.py。

270
00:14:30,010 --> 00:14:32,125
让我们把它复制到这个文件夹中。

271
00:14:37,090 --> 00:14:41,070
因此，一旦它被复制，让我们
回到我的 Ubuntu 机器。

272
00:14:41,070 --> 00:14:46,120
我会做一个ls。

273
00:14:46,120 --> 00:14:52,390
我将删除 rm R1.cfg，
并删除 R2.cfg。

274
00:14:52,390 --> 00:14:54,480
所以这个文件现在不存在。

275
00:14:54,480 --> 00:14:59,295
我没有 R1 和 R2 的运行
配置。

276
00:14:59,295 --> 00:15:03,060
我应该有
netmiko_challenge2，

277
00:15:03,060 --> 00:15:04,390
这是在这里。

278
00:15:04,390 --> 00:15:05,790
所以我可以执行那个。

279
00:15:05,790 --> 00:15:15,030
让我们这样做——python3，然后
执行 netmiko_challenge2.py。

280
00:15:15,030 --> 00:15:22,940
在我执行该操作的那一刻，
它应该打印 Connecting

281
00:15:22,940 --> 00:15:25,610
到设备，它做到了。

282
00:15:25,610 --> 00:15:29,390
保存配置，备份
配置到文件夹。

283
00:15:29,390 --> 00:15:35,270
我发现我
有一个错误，

284
00:15:35,270 --> 00:15:38,510
表示名称 n 未定义。

285
00:15:38,510 --> 00:15:42,740
事实上，让我们回到我的脚本。

286
00:15:42,740 --> 00:15:47,990
等等，我要
让 n 等于 0。

287
00:15:47,990 --> 00:15:52,980
所以它从 n 等于 0 开始。

288
00:15:52,980 --> 00:15:57,690
或者，事实上，让我们将
this 改为 n 等于 1。

289
00:15:57,690 --> 00:16:02,550
所以我的 for 循环将
从 n 等于 1 开始，

290
00:16:02,550 --> 00:16:06,240
然后它执行脚本。

291
00:16:06,240 --> 00:16:09,300
然后它断开
路由器，然后n

292
00:16:09,300 --> 00:16:12,720
变为 2，即 1 加 1, 2。

293
00:16:12,720 --> 00:16:16,740
它重新执行 for
循环并将其更改为 r2。

294
00:16:16,740 --> 00:16:19,780
让我们实际上尝试一下。

295
00:16:19,780 --> 00:16:22,770
我要回去跑——

296
00:16:22,770 --> 00:16:31,150
再复制一次，复制文件。

297
00:16:31,150 --> 00:16:33,645
让我们重新执行这个。

298
00:16:44,440 --> 00:16:49,020
所以连接到设备，
备份，保存配置，

299
00:16:49,020 --> 00:16:51,240
将
配置备份到文件夹。

300
00:16:51,240 --> 00:16:54,120
再次，连接
设备，保存

301
00:16:54,120 --> 00:16:56,680
配置，以及备份
和配置到文件夹。

302
00:16:56,680 --> 00:17:03,540
因此，如果我现在执行 ls，我应该
拥有 R1.cfg 和 R2.cfg。

303
00:17:03,540 --> 00:17:09,300
因此，如果我执行 cat R1.cfg，我
应该会看到正在运行的配置

304
00:17:09,300 --> 00:17:12,900
R1，即Router1。

305
00:17:12,900 --> 00:17:21,569
如果我执行 cat R2.cfg，我
应该会看到 R2 的运行配置，

306
00:17:21,569 --> 00:17:22,960
我们可以在这里看到。

307
00:17:22,960 --> 00:17:27,030
主机名应该是 Router2。

308
00:17:27,030 --> 00:17:29,500
至此，我们
完成了我们的任务。

309
00:17:29,500 --> 00:17:31,740
因此，如果您查看
整个脚本，

310
00:17:31,740 --> 00:17:33,960
这次我使用了一个 for 循环。

311
00:17:33,960 --> 00:17:37,410
我没有使用
单独的路由器，

312
00:17:37,410 --> 00:17:44,490
我的脚本变得更小，
它变得更具可扩展性。

313
00:17:44,490 --> 00:17:46,690
至此，我们
完成了我们的任务。

314
00:17:46,690 --> 00:17:48,850
我希望此视频
对您有所帮助，