WEBVTT

1
00:00:00.080 --> 00:00:04.360
<v Speaker 1>The world of network engineering is moving incredibly fast, isn't it.

2
00:00:04.360 --> 00:00:06.320
<v Speaker 2>It really is. It feels like the ground is constantly

3
00:00:06.320 --> 00:00:07.400
<v Speaker 2>shifting under our feet.

4
00:00:07.519 --> 00:00:10.000
<v Speaker 1>Yeah. Just yesterday we were all, you know, neck deep

5
00:00:10.000 --> 00:00:10.839
<v Speaker 1>in command line.

6
00:00:10.720 --> 00:00:13.240
<v Speaker 2>Interfaces, clies everywhere exactly.

7
00:00:13.439 --> 00:00:16.519
<v Speaker 1>Yeah, and now it's all about API's automation.

8
00:00:17.160 --> 00:00:20.280
<v Speaker 2>It's a lot keeping up with the complexity that constant

9
00:00:20.320 --> 00:00:23.399
<v Speaker 2>push for automation. Yeah, it can feel like a real

10
00:00:23.480 --> 00:00:24.719
<v Speaker 2>uphill battle sometimes.

11
00:00:24.760 --> 00:00:28.239
<v Speaker 1>But today we're trying cut through some of that noise.

12
00:00:28.640 --> 00:00:31.600
<v Speaker 1>We want to give you, our listener, a focused look

13
00:00:31.719 --> 00:00:35.799
<v Speaker 1>at a tool that's become well, absolutely essential in this landscape.

14
00:00:35.880 --> 00:00:40.159
<v Speaker 2>It's fascinating this shift, you know, moving away from manually

15
00:00:40.200 --> 00:00:43.560
<v Speaker 2>poking each device, yeah, device by device, towards a world

16
00:00:43.600 --> 00:00:47.600
<v Speaker 2>where code, actual software defines and controls the infrastructure.

17
00:00:47.679 --> 00:00:50.840
<v Speaker 1>The potential there for efficiency, for scale, it's just huge,

18
00:00:50.920 --> 00:00:51.280
<v Speaker 1>it is.

19
00:00:51.359 --> 00:00:54.759
<v Speaker 2>But it definitely means network engineers need to add some

20
00:00:54.880 --> 00:00:56.640
<v Speaker 2>new skills, some new tools to their belt.

21
00:00:56.719 --> 00:00:59.799
<v Speaker 1>Absolutely. And the real star the focus of our deep

22
00:00:59.840 --> 00:01:01.520
<v Speaker 1>die today is Python.

23
00:01:01.679 --> 00:01:02.280
<v Speaker 2>Ah.

24
00:01:02.320 --> 00:01:06.079
<v Speaker 1>Python, Yes, we're looking at its crucial role in modern

25
00:01:06.079 --> 00:01:10.760
<v Speaker 1>network engineering. And look, this isn't just our opinion. Now

26
00:01:10.920 --> 00:01:15.920
<v Speaker 1>we've drawn our insights from a really solid resource, Mastering

27
00:01:16.040 --> 00:01:17.719
<v Speaker 1>Python Networking, fourth edition.

28
00:01:17.959 --> 00:01:20.719
<v Speaker 2>That's a comprehensive book, very practical.

29
00:01:20.920 --> 00:01:23.319
<v Speaker 1>It really is. Think of this deep dive as your

30
00:01:23.359 --> 00:01:27.000
<v Speaker 1>shortcut to understanding the key stuff from that book. It

31
00:01:27.040 --> 00:01:29.920
<v Speaker 1>takes a very hands on approach, you know, using Python

32
00:01:29.959 --> 00:01:31.560
<v Speaker 1>for all sorts of network.

33
00:01:31.200 --> 00:01:34.079
<v Speaker 2>Tasks, and it covers a massive amount of ground, doesn't it.

34
00:01:34.200 --> 00:01:38.239
<v Speaker 2>Looking at the big picture. It goes from like basic device.

35
00:01:37.879 --> 00:01:40.120
<v Speaker 1>Interactions, fundamental all the way up.

36
00:01:40.079 --> 00:01:43.879
<v Speaker 2>To advanced automation, even touching on network security with Python.

37
00:01:44.319 --> 00:01:48.000
<v Speaker 1>It really shows how central Python has become. It's everywhere

38
00:01:48.040 --> 00:01:50.319
<v Speaker 1>in networking, right across the board, and that's why we're

39
00:01:50.319 --> 00:01:52.560
<v Speaker 1>here for you, the learner. Our goal today is to

40
00:01:52.599 --> 00:01:56.400
<v Speaker 1>boil down those core concepts, show you the practical waves

41
00:01:56.439 --> 00:01:59.200
<v Speaker 1>Python is actually being used right now. We want to

42
00:01:59.239 --> 00:02:01.000
<v Speaker 1>give you those you know, aha.

43
00:02:00.640 --> 00:02:03.359
<v Speaker 2>Moment, the actionable stuff exactly.

44
00:02:03.000 --> 00:02:06.319
<v Speaker 1>Knowledge you can actually use without getting totally bogged down

45
00:02:06.319 --> 00:02:10.560
<v Speaker 1>in every single tiny detail. So ready to jump in.

46
00:02:10.479 --> 00:02:14.080
<v Speaker 2>Let's do it. But it raises that first question, maybe

47
00:02:14.080 --> 00:02:18.360
<v Speaker 2>the most fundamental one, why Python, you know, with everything changing,

48
00:02:18.599 --> 00:02:22.000
<v Speaker 2>what makes it the go to language for network engineers?

49
00:02:22.120 --> 00:02:25.439
<v Speaker 1>That's the perfect place to start, and our source the

50
00:02:25.479 --> 00:02:29.479
<v Speaker 1>book tackles this head on. It describes Python as a

51
00:02:29.520 --> 00:02:30.719
<v Speaker 1>full spectrum.

52
00:02:30.280 --> 00:02:32.439
<v Speaker 2>Language fall spectrum. I like that.

53
00:02:32.599 --> 00:02:35.120
<v Speaker 1>Think about it. On one end, it's super easy to

54
00:02:35.120 --> 00:02:37.479
<v Speaker 1>get started with, I mean the classic print Hello.

55
00:02:37.280 --> 00:02:39.199
<v Speaker 2>World, everyone's first program.

56
00:02:38.960 --> 00:02:40.919
<v Speaker 1>Right, pretty much, it's like the entry point.

57
00:02:41.039 --> 00:02:41.280
<v Speaker 2>Yeah.

58
00:02:41.280 --> 00:02:43.800
<v Speaker 1>But then on the other end of that spectrum, yeah,

59
00:02:43.879 --> 00:02:48.759
<v Speaker 1>Python power some massive, incredibly complex systems. The book actually

60
00:02:48.840 --> 00:02:50.120
<v Speaker 1>uses YouTube as an example.

61
00:02:50.199 --> 00:02:53.080
<v Speaker 2>Wow, YouTube, Okay, that definitely shows scale and power.

62
00:02:53.240 --> 00:02:55.759
<v Speaker 1>It really does. But here's where it gets particularly interesting

63
00:02:55.759 --> 00:02:58.719
<v Speaker 1>for network folks, I think. Okay, the book emphasizes Python's

64
00:02:58.719 --> 00:03:02.280
<v Speaker 1>strength in scripting and acting as like a glue.

65
00:03:02.360 --> 00:03:03.520
<v Speaker 2>Glue okay, explain that.

66
00:03:03.879 --> 00:03:07.400
<v Speaker 1>Well. It means it's fantastic for quickly automating tasks, sure,

67
00:03:07.759 --> 00:03:11.599
<v Speaker 1>but also for connecting different existing systems or components together.

68
00:03:11.800 --> 00:03:14.439
<v Speaker 2>Ah. I see, so not just building things from scratch,

69
00:03:14.560 --> 00:03:18.479
<v Speaker 2>but making different tools or platforms talk to each other exactly.

70
00:03:18.520 --> 00:03:20.879
<v Speaker 1>And for someone maybe just starting out with network automation,

71
00:03:20.960 --> 00:03:23.039
<v Speaker 1>that flexibility is a huge plus.

72
00:03:23.280 --> 00:03:26.879
<v Speaker 2>Yeah, that makes sense. Let's engineer start small, right, automate

73
00:03:26.919 --> 00:03:28.479
<v Speaker 2>maybe one repetitive.

74
00:03:27.919 --> 00:03:29.479
<v Speaker 1>Task like updating VLANs or.

75
00:03:29.479 --> 00:03:32.120
<v Speaker 2>Something, right, and then gradually build up to more complex

76
00:03:32.159 --> 00:03:34.599
<v Speaker 2>stuff as they get more comfortable as their needs grow.

77
00:03:35.000 --> 00:03:37.879
<v Speaker 2>It's a very uh, practical, on ramp.

78
00:03:37.759 --> 00:03:40.000
<v Speaker 1>Step by step approach. Yeah. Okay, so let's get into

79
00:03:40.000 --> 00:03:44.479
<v Speaker 1>the nitty gritty actually talking to network devices a core interaction. Yeah.

80
00:03:44.719 --> 00:03:48.599
<v Speaker 1>The book points to a pretty big shift around twenty

81
00:03:48.599 --> 00:03:54.120
<v Speaker 1>fourteen moving away from purely manual CLI management the old way,

82
00:03:54.199 --> 00:03:55.919
<v Speaker 1>towards using programmatic APIs.

83
00:03:56.080 --> 00:03:59.159
<v Speaker 2>That was a key turning point. Definitely, before APIs got

84
00:03:59.159 --> 00:04:03.080
<v Speaker 2>really common, it was just typing commands manually into terminal windows.

85
00:04:03.280 --> 00:04:06.039
<v Speaker 2>So much typing, Yeah, very hands on one device at

86
00:04:06.080 --> 00:04:08.360
<v Speaker 2>a time, tedious, And.

87
00:04:08.280 --> 00:04:12.400
<v Speaker 1>As networks just got bigger or complex, that manual way

88
00:04:13.039 --> 00:04:16.040
<v Speaker 1>it just couldn't scale. Could it speed efficiency?

89
00:04:16.240 --> 00:04:19.000
<v Speaker 2>No way. The book even suggests it was becoming a

90
00:04:19.240 --> 00:04:22.800
<v Speaker 2>terrible waste of engineering talent just doing those repetitive CLI

91
00:04:22.959 --> 00:04:23.920
<v Speaker 2>tasks over and over.

92
00:04:24.120 --> 00:04:24.720
<v Speaker 1>I could see that.

93
00:04:25.040 --> 00:04:28.120
<v Speaker 2>And you know, while we still use the CLI sometimes

94
00:04:28.160 --> 00:04:30.800
<v Speaker 2>maybe for initial setup or some tricky troubleshooting.

95
00:04:30.839 --> 00:04:32.000
<v Speaker 1>Sure, it's not gone entirely.

96
00:04:32.199 --> 00:04:35.279
<v Speaker 2>No, but the industry realized we needed ways for machines

97
00:04:35.279 --> 00:04:39.000
<v Speaker 2>to talk to machines effectively for automation, and that's where

98
00:04:39.040 --> 00:04:40.560
<v Speaker 2>APIs really took off.

99
00:04:40.600 --> 00:04:43.800
<v Speaker 1>The book acknowledges. And this is important that we still

100
00:04:43.839 --> 00:04:47.800
<v Speaker 1>need to interact with older, you know, legacy devices sometimes

101
00:04:47.920 --> 00:04:51.040
<v Speaker 1>the ones that don't have those shiny modern APIs.

102
00:04:50.600 --> 00:04:52.959
<v Speaker 2>Right, the reality of most networks, you've got a mix

103
00:04:53.000 --> 00:04:53.720
<v Speaker 2>of old and new.

104
00:04:53.920 --> 00:04:56.759
<v Speaker 1>So for those older boxes, things like telnet and SSH

105
00:04:56.879 --> 00:04:59.680
<v Speaker 1>are still relevant for that basic, low level interaction.

106
00:05:00.319 --> 00:05:02.959
<v Speaker 2>The book even gives a simple example, doesn't it, using

107
00:05:03.000 --> 00:05:06.600
<v Speaker 2>Telnet to connect to a device at one ninety two

108
00:05:06.639 --> 00:05:08.480
<v Speaker 2>point one sixty eight point two point five one.

109
00:05:08.480 --> 00:05:11.439
<v Speaker 1>Yeah, user named Cisco password Cisco. Just a basic illustration

110
00:05:11.519 --> 00:05:12.240
<v Speaker 1>of connectivity.

111
00:05:12.480 --> 00:05:16.920
<v Speaker 2>But crucial point Telnet is not secure. Everything's in plaintext.

112
00:05:17.240 --> 00:05:18.560
<v Speaker 1>Big security risk there.

113
00:05:18.639 --> 00:05:22.399
<v Speaker 2>Absolutely, That's why SSH is the standard now encrypted connection.

114
00:05:22.759 --> 00:05:26.879
<v Speaker 2>And Python has some really good tools for handling SSH programmatically,

115
00:05:26.959 --> 00:05:27.160
<v Speaker 2>and the.

116
00:05:27.120 --> 00:05:31.600
<v Speaker 1>Book introduces peramico as like the foundational Python library.

117
00:05:31.160 --> 00:05:35.079
<v Speaker 2>For this paramco. Yeah, it handles the low level SSH

118
00:05:35.160 --> 00:05:36.040
<v Speaker 2>protocol stuff.

119
00:05:36.120 --> 00:05:39.079
<v Speaker 1>It shows a basic code snippet for making an SSH

120
00:05:39.160 --> 00:05:43.399
<v Speaker 1>connection with Peramico takes care of the encryption, authentication, all

121
00:05:43.439 --> 00:05:44.959
<v Speaker 1>that underlying complexity for you.

122
00:05:45.040 --> 00:05:48.519
<v Speaker 2>Think of peramiico as the engine, right, providing that secure

123
00:05:48.560 --> 00:05:52.120
<v Speaker 2>communication channel, giving you quite fine green control if you need.

124
00:05:52.000 --> 00:05:54.600
<v Speaker 1>It, right, and then what's cool is how other libraries

125
00:05:54.600 --> 00:05:55.439
<v Speaker 1>build on top of that.

126
00:05:55.399 --> 00:05:59.439
<v Speaker 2>Engine exactly, which leads us to netmico. The book talks

127
00:05:59.439 --> 00:06:02.319
<v Speaker 2>about netmeik being built using Peramco.

128
00:06:01.920 --> 00:06:03.639
<v Speaker 1>So netmko uses Peramco.

129
00:06:03.279 --> 00:06:04.160
<v Speaker 2>Underneath pretty much.

130
00:06:04.240 --> 00:06:04.439
<v Speaker 1>Yeah.

131
00:06:04.680 --> 00:06:07.800
<v Speaker 2>Netmiko essentially puts a more user friendly layer on top,

132
00:06:08.120 --> 00:06:11.680
<v Speaker 2>specifically designed for network engineers interacting with network gear. It

133
00:06:11.759 --> 00:06:13.079
<v Speaker 2>simplifies common.

134
00:06:12.800 --> 00:06:15.399
<v Speaker 1>Tasks, ah, okay, so it makes it easier to just

135
00:06:15.560 --> 00:06:18.240
<v Speaker 1>like send a command and get the output back from say, yes,

136
00:06:18.319 --> 00:06:19.600
<v Speaker 1>Cisco router exactly.

137
00:06:19.639 --> 00:06:21.879
<v Speaker 2>Netmko is built for that. It knows how to handle

138
00:06:21.959 --> 00:06:27.720
<v Speaker 2>the prompts and peculiarities of different network operating systems Ciscoios Junior,

139
00:06:27.759 --> 00:06:31.120
<v Speaker 2>per Junos, Arista, EOS, lots of others. It smooths out

140
00:06:31.120 --> 00:06:32.079
<v Speaker 2>those interactions.

141
00:06:32.240 --> 00:06:36.720
<v Speaker 1>That sounds incredibly useful, less time fighting with raw ssh.

142
00:06:36.120 --> 00:06:40.480
<v Speaker 2>Definitely, which brings us to a really really critical concept

143
00:06:40.720 --> 00:06:42.759
<v Speaker 2>in automation, idempotency.

144
00:06:42.920 --> 00:06:45.480
<v Speaker 1>Adempotency Okay, sounds important, let's break that down.

145
00:06:45.600 --> 00:06:49.319
<v Speaker 2>The book emphasizes this heavily, especially when you're scripting interactions

146
00:06:49.319 --> 00:06:50.560
<v Speaker 2>with network devices.

147
00:06:50.639 --> 00:06:54.319
<v Speaker 1>So idempotency it means that if you run the same

148
00:06:54.360 --> 00:06:58.120
<v Speaker 1>automation script multiple times, Yeah, if you have the exact

149
00:06:58.199 --> 00:07:00.639
<v Speaker 1>same end result as running it just once, it shouldn't

150
00:07:00.680 --> 00:07:03.199
<v Speaker 1>like keep adding the same config line over and over

151
00:07:03.519 --> 00:07:05.920
<v Speaker 1>or cause weird side effects on the second or third run.

152
00:07:06.000 --> 00:07:10.519
<v Speaker 2>Precisely, think about a script that configures a specific vlan. Okay,

153
00:07:10.560 --> 00:07:13.360
<v Speaker 2>if it's not ideentpatan, running it twice might try to

154
00:07:13.399 --> 00:07:16.040
<v Speaker 2>create the same vline again, which could cause an error

155
00:07:16.199 --> 00:07:19.680
<v Speaker 2>or worse, lead to some unexpected configuration mess right.

156
00:07:19.800 --> 00:07:22.399
<v Speaker 1>Definitely not what you want in your network errors and

157
00:07:22.480 --> 00:07:23.920
<v Speaker 1>inconsistencies creeping in.

158
00:07:24.079 --> 00:07:27.399
<v Speaker 2>Absolutely not. And the book points out that those older methods,

159
00:07:27.519 --> 00:07:30.639
<v Speaker 2>the ones relying on screen scraping just reading text output

160
00:07:30.639 --> 00:07:33.560
<v Speaker 2>from the CLI, yeah, they were particularly bad for this,

161
00:07:33.800 --> 00:07:37.040
<v Speaker 2>not idempatent at all, usually because if the format of

162
00:07:37.079 --> 00:07:41.240
<v Speaker 2>the CLA output changed just slightly, maybe after a software upgrade.

163
00:07:41.040 --> 00:07:43.920
<v Speaker 1>Your script would break or misunderstand things exactly.

164
00:07:43.959 --> 00:07:49.120
<v Speaker 2>It's inherently fragile trying to parse unstructured human readable.

165
00:07:48.720 --> 00:07:52.639
<v Speaker 1>Text, which is a huge reason why moving towards APIs,

166
00:07:52.839 --> 00:07:55.759
<v Speaker 1>which could use structure data is so much more reliable.

167
00:07:55.839 --> 00:07:59.040
<v Speaker 2>That's the key reliability and efficiency.

168
00:07:59.120 --> 00:08:02.639
<v Speaker 1>Perfect segue into API driven network management. The book really

169
00:08:02.680 --> 00:08:05.439
<v Speaker 1>pushes this as the way forward, moving beyond that fragile

170
00:08:05.439 --> 00:08:07.839
<v Speaker 1>screen scraping. So what are the main wins here?

171
00:08:08.199 --> 00:08:10.720
<v Speaker 2>Well, the fundamental win, as you said, is structured data.

172
00:08:10.800 --> 00:08:14.160
<v Speaker 2>APIs typically give you information back in formats like JSON

173
00:08:14.319 --> 00:08:14.879
<v Speaker 2>or XML.

174
00:08:15.000 --> 00:08:17.959
<v Speaker 1>Okay, json and XML computer friendly formats.

175
00:08:18.040 --> 00:08:20.680
<v Speaker 2>Right, So instead of your Python script trying to guess

176
00:08:20.680 --> 00:08:23.160
<v Speaker 2>where the important info is in a block of CLI text,

177
00:08:23.240 --> 00:08:26.839
<v Speaker 2>which can change, it gets a neat, predictable data structure.

178
00:08:27.000 --> 00:08:30.040
<v Speaker 2>It knows exactly where to find the interface status or

179
00:08:30.199 --> 00:08:33.480
<v Speaker 2>the routing table entries. It's like getting data from a

180
00:08:33.519 --> 00:08:37.320
<v Speaker 2>well organized spreadsheet versus trying to read handwritten notes. Much

181
00:08:37.320 --> 00:08:37.960
<v Speaker 2>more reliable.

182
00:08:38.120 --> 00:08:40.639
<v Speaker 1>Makes sense, and the book gets into some specifics which

183
00:08:40.679 --> 00:08:43.240
<v Speaker 1>is really helpful. It covers a range of vendor APIs.

184
00:08:43.840 --> 00:08:47.600
<v Speaker 1>Let's start with Cisco. They mentioned NXAPI for the Nexus switches.

185
00:08:47.799 --> 00:08:48.440
<v Speaker 1>How's that work?

186
00:08:48.559 --> 00:08:51.960
<v Speaker 2>So Cisco NXAPI especially lets you talk to Nexus switches

187
00:08:52.080 --> 00:08:56.000
<v Speaker 2>using standard web protocols, mostly HTTP or hdtps.

188
00:08:55.559 --> 00:08:57.080
<v Speaker 1>Like talking to a website.

189
00:08:56.720 --> 00:09:01.279
<v Speaker 2>Kind of yeah. The book specifically mentions sending HI posteam

190
00:09:01.320 --> 00:09:05.279
<v Speaker 2>request to a particular URL on the switch ins to

191
00:09:05.440 --> 00:09:07.039
<v Speaker 2>execute CLI commands.

192
00:09:07.279 --> 00:09:09.840
<v Speaker 1>Ah, so you can still run CLI commands, but via

193
00:09:09.879 --> 00:09:11.279
<v Speaker 1>an API call exactly.

194
00:09:11.360 --> 00:09:13.960
<v Speaker 2>You package the command and the PSA requests, send it off,

195
00:09:14.039 --> 00:09:16.720
<v Speaker 2>and you get the output back, often structured as JSON.

196
00:09:16.799 --> 00:09:18.799
<v Speaker 2>It's like a programmatic interface to the CLI.

197
00:09:18.960 --> 00:09:22.080
<v Speaker 1>That sounds way better than SSH screen scraping. And the

198
00:09:22.080 --> 00:09:25.519
<v Speaker 1>book also mentioned Cisco provides a sandbox environment for NXAPI.

199
00:09:25.799 --> 00:09:28.159
<v Speaker 2>Yeah, that's super helpful. It means you can play around,

200
00:09:28.240 --> 00:09:31.200
<v Speaker 2>test your API calls, figure out the request and response.

201
00:09:30.879 --> 00:09:34.440
<v Speaker 1>Formats without touching your live production network exactly.

202
00:09:34.480 --> 00:09:37.279
<v Speaker 2>Reduces risk, speeds up development, great for learning.

203
00:09:37.519 --> 00:09:41.080
<v Speaker 1>What about other Cisco stuff? Netconf and YANG keep popping

204
00:09:41.159 --> 00:09:42.759
<v Speaker 1>up in modern networking.

205
00:09:42.360 --> 00:09:46.320
<v Speaker 2>Discussions, right, So, netconf that's the network configuration protocol. It's

206
00:09:46.320 --> 00:09:50.000
<v Speaker 2>a standardized protocol defined in RFC's for managing network devices.

207
00:09:50.039 --> 00:09:51.279
<v Speaker 1>It's a bandardize okay, yeah.

208
00:09:51.320 --> 00:09:54.480
<v Speaker 2>It usually runs over a secure channel like SSH and

209
00:09:54.600 --> 00:09:58.279
<v Speaker 2>uses XML to encode the configuration data and commands.

210
00:09:58.000 --> 00:10:00.679
<v Speaker 1>XML for the data format. ANG.

211
00:10:00.960 --> 00:10:04.799
<v Speaker 2>YANG is the data modeling language. Think of YANG as

212
00:10:05.039 --> 00:10:09.120
<v Speaker 2>the blueprint or the schema for a network device's configuration

213
00:10:09.279 --> 00:10:10.519
<v Speaker 2>and its operational state.

214
00:10:11.080 --> 00:10:13.320
<v Speaker 1>So YANG defines what you can configure.

215
00:10:12.919 --> 00:10:16.799
<v Speaker 2>And monitor precisely. It describes the data structures, the available options,

216
00:10:16.840 --> 00:10:20.639
<v Speaker 2>the data types. It brings structure and predictability to network

217
00:10:20.679 --> 00:10:24.039
<v Speaker 2>device data. The book even points to the Yang gethub

218
00:10:24.080 --> 00:10:26.200
<v Speaker 2>project where you can find loads of these models.

219
00:10:26.279 --> 00:10:28.320
<v Speaker 1>Okay, so YANG is the model, that kind off is

220
00:10:28.320 --> 00:10:31.480
<v Speaker 1>the protocol to transfer configurations based on that model, often

221
00:10:31.559 --> 00:10:33.399
<v Speaker 1>using XML over ssh.

222
00:10:33.399 --> 00:10:33.720
<v Speaker 2>Got it.

223
00:10:33.799 --> 00:10:34.600
<v Speaker 1>That's a good summary.

224
00:10:34.840 --> 00:10:39.720
<v Speaker 2>And then there's Cisco ACI application centric infrastructure that takes

225
00:10:39.799 --> 00:10:42.320
<v Speaker 2>a different approach again right, more controller based.

226
00:10:42.519 --> 00:10:45.279
<v Speaker 1>Yeah. ACI is all about that central controller managing the

227
00:10:45.399 --> 00:10:48.440
<v Speaker 1>entire network fabric. The book explains that you interact with

228
00:10:48.519 --> 00:10:51.759
<v Speaker 1>ACI primarily through RESTful APIs.

229
00:10:51.519 --> 00:10:54.879
<v Speaker 2>Rest API, so using standard HTTP.

230
00:10:54.519 --> 00:10:58.120
<v Speaker 1>Methods exactly, things like get to fetch information, posts to

231
00:10:58.200 --> 00:11:02.559
<v Speaker 1>create or update configurations, or policies, delete to remove things. It's

232
00:11:02.600 --> 00:11:05.879
<v Speaker 1>all done by talking to the ACI controllers API. Very

233
00:11:05.919 --> 00:11:06.759
<v Speaker 1>API centric.

234
00:11:06.960 --> 00:11:09.679
<v Speaker 2>Like ordering food online. You mentioned get the menu, post

235
00:11:09.720 --> 00:11:10.080
<v Speaker 2>the order.

236
00:11:10.159 --> 00:11:12.919
<v Speaker 1>Yeah, that kind of idea standard web actions applied to

237
00:11:13.120 --> 00:11:14.000
<v Speaker 1>network management.

238
00:11:14.120 --> 00:11:17.559
<v Speaker 2>Okay. Moving across the aisle to Juniper Networks, the book

239
00:11:17.559 --> 00:11:20.080
<v Speaker 2>covers their approach to including netcom right.

240
00:11:20.399 --> 00:11:24.320
<v Speaker 1>Similar to Cisco, Juniper supports netcom over ssh. The book

241
00:11:24.360 --> 00:11:28.000
<v Speaker 1>mentions using a specific Python library called unclient for this

242
00:11:28.200 --> 00:11:31.000
<v Speaker 1>and client okay, yeah, and it shows examples of using

243
00:11:31.000 --> 00:11:34.519
<v Speaker 1>a client to connect your Geniper devices, retrieve configuration sections,

244
00:11:34.559 --> 00:11:35.519
<v Speaker 1>and even make changes.

245
00:11:35.720 --> 00:11:39.159
<v Speaker 2>And Juniper also has its own Python library, doesn't it pie.

246
00:11:38.840 --> 00:11:43.080
<v Speaker 1>Z it does. The book introduces PIEZ, which stands for

247
00:11:43.159 --> 00:11:43.799
<v Speaker 1>Python Easy.

248
00:11:43.840 --> 00:11:44.720
<v Speaker 2>I think makes sense.

249
00:11:44.759 --> 00:11:48.200
<v Speaker 1>It's Juniper's library designed to simplify interacting with Juno's devices.

250
00:11:48.639 --> 00:11:51.960
<v Speaker 1>It provides a higher level abstraction over NETCN, making common

251
00:11:52.000 --> 00:11:53.799
<v Speaker 1>tasks easier.

252
00:11:53.480 --> 00:11:57.919
<v Speaker 2>So potentially less code to write for standard operations compared

253
00:11:57.960 --> 00:11:59.679
<v Speaker 2>to using client directly.

254
00:12:00.000 --> 00:12:02.159
<v Speaker 1>It seems to be the idea. Yeah, more tailored to

255
00:12:02.240 --> 00:12:03.200
<v Speaker 1>Juniper workflows.

256
00:12:03.519 --> 00:12:06.360
<v Speaker 2>Okay, what about Arista? They have EAPI yep.

257
00:12:06.399 --> 00:12:10.639
<v Speaker 1>Arista's EAPI also relies on web protocols, typically Jason RPC

258
00:12:10.799 --> 00:12:14.480
<v Speaker 1>over HTDPS. The book mentions configuring connection details in a

259
00:12:14.480 --> 00:12:17.600
<v Speaker 1>file dot epi dot com. You can pick file and

260
00:12:17.600 --> 00:12:20.840
<v Speaker 1>then using the piple Python library to send commands and

261
00:12:20.960 --> 00:12:23.720
<v Speaker 1>get structured data back. It even shows an example of

262
00:12:23.840 --> 00:12:25.440
<v Speaker 1>creating vlands using pioppy.

263
00:12:25.600 --> 00:12:29.240
<v Speaker 2>So another vendor, another API, another Python library to help.

264
00:12:29.320 --> 00:12:31.559
<v Speaker 1>Pretty much the pattern and we shouldn't forget vos the

265
00:12:31.600 --> 00:12:32.360
<v Speaker 1>open source option.

266
00:12:32.440 --> 00:12:33.559
<v Speaker 2>Oh the book is it a mention too?

267
00:12:33.639 --> 00:12:36.480
<v Speaker 1>Yeah. Briefly mentions a library called vingient for interacting with

268
00:12:36.559 --> 00:12:38.039
<v Speaker 1>vostavisis programmatically.

269
00:12:38.360 --> 00:12:41.120
<v Speaker 2>So the key thing here for you, the learner, is

270
00:12:41.559 --> 00:12:46.440
<v Speaker 2>seeing this pattern right. Vendors provide APIs, maybe net conframe,

271
00:12:46.600 --> 00:12:51.879
<v Speaker 2>maybe rest, maybe something pustom like NXAPI or eapi, and

272
00:12:51.919 --> 00:12:55.000
<v Speaker 2>then there are often Python libraries, either from the vendor

273
00:12:55.120 --> 00:12:59.480
<v Speaker 2>or the community, to make using those APIs easier exactly.

274
00:12:59.519 --> 00:13:02.159
<v Speaker 1>And while we focused on vendor specifics, the book does

275
00:13:02.200 --> 00:13:06.000
<v Speaker 1>also highlight that there are vendor neutral libraries and approaches too.

276
00:13:06.399 --> 00:13:09.039
<v Speaker 2>That's important things not tied to just one company's way

277
00:13:09.080 --> 00:13:09.759
<v Speaker 2>of doing things.

278
00:13:09.879 --> 00:13:12.639
<v Speaker 1>Right. They might sometimes lag a bit behind on the

279
00:13:12.720 --> 00:13:16.279
<v Speaker 1>absolute bleeding edge features compared to a vendor's own library, sure,

280
00:13:16.399 --> 00:13:18.600
<v Speaker 1>but they offer the benefit of consistency if you have

281
00:13:18.639 --> 00:13:21.840
<v Speaker 1>a multi vendor network. Plus, many are open source so

282
00:13:21.879 --> 00:13:23.759
<v Speaker 1>you can see how they work even contribute.

283
00:13:23.879 --> 00:13:26.759
<v Speaker 2>Good point. Okay, so we've covered Python talking to individual

284
00:13:26.799 --> 00:13:30.720
<v Speaker 2>devices via CLIs and APIs. What about orchestrating tasks across

285
00:13:30.799 --> 00:13:33.200
<v Speaker 2>many devices, managing the whole infrastructure?

286
00:13:33.240 --> 00:13:36.720
<v Speaker 1>Ah, now we're getting into network automation frameworks and the

287
00:13:36.720 --> 00:13:38.759
<v Speaker 1>big one the book highlights is ansable.

288
00:13:38.879 --> 00:13:41.440
<v Speaker 2>Ansable. Yeah, you hear that name a lot, definitely.

289
00:13:41.600 --> 00:13:44.279
<v Speaker 1>The book describes it as a Python based framework, But

290
00:13:44.440 --> 00:13:46.480
<v Speaker 1>what makes it really stand out is it's focus on

291
00:13:46.519 --> 00:13:47.320
<v Speaker 1>being declarative.

292
00:13:47.519 --> 00:13:49.559
<v Speaker 2>Declarative okay, what does that mean? In practice?

293
00:13:49.639 --> 00:13:52.600
<v Speaker 1>It means instead of writing a script that lets every

294
00:13:52.600 --> 00:13:55.519
<v Speaker 1>single command to run and sequence step one, step two.

295
00:13:55.320 --> 00:13:57.360
<v Speaker 2>Step three, the imperative way, right.

296
00:13:57.759 --> 00:14:00.600
<v Speaker 1>With antsable, you mostly just declare the desire end state

297
00:14:00.639 --> 00:14:02.919
<v Speaker 1>you want. You say, I want this VLAN to exist,

298
00:14:03.039 --> 00:14:05.720
<v Speaker 1>or I want this NTP server configure, and.

299
00:14:05.759 --> 00:14:08.080
<v Speaker 2>Ansible figures out how to make that happen, checking if

300
00:14:08.080 --> 00:14:10.240
<v Speaker 2>the villain already exists, adding it if it doesn't.

301
00:14:10.360 --> 00:14:13.120
<v Speaker 1>Exactly, it checks the current state. It only makes the

302
00:14:13.159 --> 00:14:16.600
<v Speaker 1>necessary changes to reach the desired state you declared. That's

303
00:14:16.639 --> 00:14:20.559
<v Speaker 1>the power of declarative automation. It's less about how and

304
00:14:20.679 --> 00:14:21.279
<v Speaker 1>more about what.

305
00:14:21.600 --> 00:14:24.799
<v Speaker 2>That sounds much more robust and potentially idempatant by nature.

306
00:14:24.639 --> 00:14:26.919
<v Speaker 1>It often is. Yes, yeah, that's a major goal. So

307
00:14:27.039 --> 00:14:30.399
<v Speaker 1>the book explains Ansible uses inventory files to know which

308
00:14:30.440 --> 00:14:33.720
<v Speaker 1>devices to manage. It shows an example using the IONI

309
00:14:33.879 --> 00:14:38.000
<v Speaker 1>format like iOS devices followed by host names IOSV one,

310
00:14:38.440 --> 00:14:39.399
<v Speaker 1>iosv two.

311
00:14:39.480 --> 00:14:42.519
<v Speaker 2>So just a list of your network here pretty much.

312
00:14:42.600 --> 00:14:45.240
<v Speaker 1>And then you write playbooks in YAMO format YAML.

313
00:14:45.600 --> 00:14:47.399
<v Speaker 2>Okay, that structured text format.

314
00:14:47.600 --> 00:14:51.840
<v Speaker 1>Yeah. Playbooks define the automation tasks, and inside playbooks you

315
00:14:51.960 --> 00:14:53.159
<v Speaker 1>use Ansible.

316
00:14:52.720 --> 00:14:55.600
<v Speaker 2>Modules modules like pre built functions Kina.

317
00:14:55.720 --> 00:14:58.799
<v Speaker 1>Yeah, they're like the tools Ansimble uses to interact with systems.

318
00:14:59.240 --> 00:15:01.799
<v Speaker 1>The book gives to Cycle as an example, a module

319
00:15:01.879 --> 00:15:06.639
<v Speaker 1>specifically for managing access control lists on Cisco and XOS devices.

320
00:15:06.879 --> 00:15:11.879
<v Speaker 2>So there are modules for configuring interfaces, VLANs, routing protocols.

321
00:15:11.320 --> 00:15:14.720
<v Speaker 1>All that stuff, loads of them for network devices, servers,

322
00:15:14.720 --> 00:15:18.559
<v Speaker 1>cloud platforms, and playbooks organize these modules into tasks. You

323
00:15:18.559 --> 00:15:21.879
<v Speaker 1>can also have handlers, which are tasks triggered by changes

324
00:15:22.279 --> 00:15:25.279
<v Speaker 1>variables to customize things may be stored in hostars per device,

325
00:15:25.600 --> 00:15:28.399
<v Speaker 1>and loops to apply tasks to multiple devices easily.

326
00:15:28.480 --> 00:15:31.639
<v Speaker 2>That looping sounds essential for scale configure the same setting

327
00:15:31.679 --> 00:15:33.519
<v Speaker 2>on hundreds of switches exactly.

328
00:15:33.840 --> 00:15:36.679
<v Speaker 1>And one more key ansiable feature of the book mentions

329
00:15:36.759 --> 00:15:38.720
<v Speaker 1>is templating using ginga.

330
00:15:38.559 --> 00:15:40.240
<v Speaker 2>Ginga templating how's that used?

331
00:15:40.519 --> 00:15:44.759
<v Speaker 1>It lets you create configuration templates with placeholders for variables.

332
00:15:45.039 --> 00:15:47.519
<v Speaker 1>So you can have a standard interface config template and

333
00:15:47.559 --> 00:15:50.360
<v Speaker 1>then fill in the specific IP address or description for

334
00:15:50.399 --> 00:15:53.200
<v Speaker 1>each device using variables from your inventory.

335
00:15:53.320 --> 00:15:57.600
<v Speaker 2>Ah, So you generate device specific configs from a common template.

336
00:15:57.759 --> 00:16:02.559
<v Speaker 1>Very efficient, very keeps things consistent but flexible. Okay, switching

337
00:16:02.600 --> 00:16:05.559
<v Speaker 1>gear slightly but still relevant to modern workflows.

338
00:16:06.039 --> 00:16:10.799
<v Speaker 2>Docker containers containers big topic in software development. How does

339
00:16:10.799 --> 00:16:12.000
<v Speaker 2>it fit into networking?

340
00:16:12.320 --> 00:16:14.639
<v Speaker 1>Well? The book points out Docker has become the standard

341
00:16:14.720 --> 00:16:18.559
<v Speaker 1>for packaging and deploying applications, and those benefits apply to

342
00:16:18.679 --> 00:16:20.600
<v Speaker 1>network related tools and services too.

343
00:16:21.200 --> 00:16:24.279
<v Speaker 2>Like packaging a monitoring tool or maybe even a small

344
00:16:24.320 --> 00:16:25.039
<v Speaker 2>network service.

345
00:16:25.039 --> 00:16:29.039
<v Speaker 1>You build exactly. You package the application and all its dependencies, libraries,

346
00:16:29.120 --> 00:16:31.720
<v Speaker 1>run time, everything into a container. Think of it as

347
00:16:31.759 --> 00:16:33.759
<v Speaker 1>a self contained little box for your software.

348
00:16:33.799 --> 00:16:35.960
<v Speaker 2>And the benefits the book highlights are.

349
00:16:35.960 --> 00:16:38.720
<v Speaker 1>Consistency is a big one. It runs the same way

350
00:16:38.759 --> 00:16:41.000
<v Speaker 1>on your laptop as it does on a server or

351
00:16:41.000 --> 00:16:44.759
<v Speaker 1>in the cloud, Isolation, containers don't interfere with each other,

352
00:16:45.200 --> 00:16:47.080
<v Speaker 1>and easier deployment you just ship and run.

353
00:16:47.120 --> 00:16:50.159
<v Speaker 2>The container image makes sense standardized units of software.

354
00:16:50.399 --> 00:16:54.000
<v Speaker 1>The book mentions Docker files that's the recipe for building

355
00:16:54.039 --> 00:16:57.960
<v Speaker 1>a container image, and Docker composed for managing applications made

356
00:16:58.000 --> 00:17:00.480
<v Speaker 1>up of multiple containers that need to work together right.

357
00:17:00.360 --> 00:17:02.480
<v Speaker 2>Like a web app with a database, or.

358
00:17:02.440 --> 00:17:05.880
<v Speaker 1>Maybe a network monitoring stack with different components. It also

359
00:17:05.920 --> 00:17:09.480
<v Speaker 1>touches briefly on container networking, how containers talk to each

360
00:17:09.519 --> 00:17:13.079
<v Speaker 1>other and the outside world using concepts like bridge or

361
00:17:13.160 --> 00:17:13.960
<v Speaker 1>host networking.

362
00:17:14.400 --> 00:17:19.359
<v Speaker 2>Okay, and specifically for network labs. The book mentions container lab.

363
00:17:19.559 --> 00:17:22.240
<v Speaker 1>Yeah, this sounds really cool. Container lab is a tool

364
00:17:22.279 --> 00:17:24.799
<v Speaker 1>specifically designed to make it easier to spin up lab

365
00:17:24.920 --> 00:17:28.400
<v Speaker 1>environments using containerized network operating SYSTEMSS.

366
00:17:28.680 --> 00:17:32.200
<v Speaker 2>So you can run like a virtual Cisco or Arista

367
00:17:32.319 --> 00:17:35.599
<v Speaker 2>or Juniper device inside a container for testing exactly.

368
00:17:35.640 --> 00:17:38.960
<v Speaker 1>It mentions sr linux as an example. It simplifies building

369
00:17:39.000 --> 00:17:43.759
<v Speaker 1>and tearing down virtual network topologies for practice, testing, automation scripts,

370
00:17:44.160 --> 00:17:45.039
<v Speaker 1>learning new features.

371
00:17:45.079 --> 00:17:48.519
<v Speaker 2>That sounds incredibly useful for network engineers. Way lighter than

372
00:17:48.559 --> 00:17:50.039
<v Speaker 2>full VMS maybe potentially.

373
00:17:50.119 --> 00:17:55.160
<v Speaker 1>Yeah. Okay, so we've configured devices, automated tasks, packaged tools.

374
00:17:55.599 --> 00:17:58.279
<v Speaker 1>What about actually monitoring the network? Keeping an eye on

375
00:17:58.319 --> 00:17:59.599
<v Speaker 1>things crucial aspect?

376
00:18:00.079 --> 00:18:03.079
<v Speaker 2>The book dedicates a good chunk to network monitoring with Python.

377
00:18:03.240 --> 00:18:04.039
<v Speaker 2>Where does it start?

378
00:18:04.279 --> 00:18:07.839
<v Speaker 1>SNMP starts with the classic SNMP, the Simple Network Management

379
00:18:07.839 --> 00:18:11.440
<v Speaker 1>Protocol been around forever, still widely used the work, but

380
00:18:11.720 --> 00:18:14.440
<v Speaker 1>as the book notes, it has limitations. It can put

381
00:18:14.440 --> 00:18:16.799
<v Speaker 1>a load on the device CPU, the agent running there,

382
00:18:17.279 --> 00:18:20.720
<v Speaker 1>and you need to know the specific OIDs, those numeric

383
00:18:20.799 --> 00:18:22.319
<v Speaker 1>addresses for pieces of data.

384
00:18:22.400 --> 00:18:25.680
<v Speaker 2>The MIBs and OIDs Yeah, can be complex.

385
00:18:25.319 --> 00:18:27.680
<v Speaker 1>Right, You need the right oid to ask for, say,

386
00:18:28.160 --> 00:18:31.720
<v Speaker 1>interface traffic counters or CPU load. The book does show

387
00:18:31.720 --> 00:18:34.200
<v Speaker 1>how Python can be used to send SMMP queries and

388
00:18:34.240 --> 00:18:38.559
<v Speaker 1>get data back, though even shows restricting SNMP access via

389
00:18:38.640 --> 00:18:39.680
<v Speaker 1>an ACL, So.

390
00:18:40.079 --> 00:18:43.200
<v Speaker 2>Still relevant, but maybe not the only answer. How about

391
00:18:43.279 --> 00:18:44.920
<v Speaker 2>visualizing the data you collect?

392
00:18:45.039 --> 00:18:49.160
<v Speaker 1>Good question? Making sense of numbers? The book introduces Python

393
00:18:49.200 --> 00:18:52.799
<v Speaker 1>libraries like mattplot lib and pigol for creating charts and graphs.

394
00:18:53.039 --> 00:18:55.599
<v Speaker 2>Matt plot lob is very common in the data science world,

395
00:18:55.960 --> 00:18:57.000
<v Speaker 2>Pigole maybe less so.

396
00:18:57.279 --> 00:19:00.920
<v Speaker 1>Mattplotlib for static charts, pigol maybe more, or for interactive

397
00:19:00.960 --> 00:19:04.960
<v Speaker 1>web based charts. The book shows examples of creating line graphs,

398
00:19:05.200 --> 00:19:09.359
<v Speaker 1>maybe tracking bandwidth use over time, visualizing trends.

399
00:19:09.039 --> 00:19:11.920
<v Speaker 2>Seeing spikes or drops is much easier on a graph

400
00:19:11.960 --> 00:19:13.640
<v Speaker 2>than in a table of numbers.

401
00:19:13.319 --> 00:19:16.880
<v Speaker 1>Definitely, and it shows saving these graphs too. But what

402
00:19:17.039 --> 00:19:20.799
<v Speaker 1>about visualizing the network structure itself? The topology?

403
00:19:20.920 --> 00:19:23.039
<v Speaker 2>Ah? Yeah, how things are connected?

404
00:19:23.160 --> 00:19:25.160
<v Speaker 1>The book mentions graph is for that graph is.

405
00:19:25.200 --> 00:19:27.559
<v Speaker 2>That's the tool that generates diagrams from a text description

406
00:19:27.720 --> 00:19:30.240
<v Speaker 2>right using the dot language exactly.

407
00:19:29.920 --> 00:19:34.119
<v Speaker 1>You describe the nodes, devices and edges, links and dot

408
00:19:34.240 --> 00:19:37.319
<v Speaker 1>format and graphiz draws the picture. The book shows a

409
00:19:37.359 --> 00:19:40.519
<v Speaker 1>simple example a core node connected to a distribution node

410
00:19:40.640 --> 00:19:42.000
<v Speaker 1>connected to an access switch.

411
00:19:42.200 --> 00:19:45.480
<v Speaker 2>Really helpful for understanding network layout, especially complex ones.

412
00:19:45.759 --> 00:19:48.920
<v Speaker 1>In Python has libraries that wrap graph is, making it

413
00:19:48.960 --> 00:19:53.039
<v Speaker 1>easy to generate those dot descriptions programmatically from your network data.

414
00:19:53.559 --> 00:19:56.599
<v Speaker 1>The book even has an example using LLLEDP neighbor info

415
00:19:57.000 --> 00:19:58.960
<v Speaker 1>to dynamically build a topology map.

416
00:19:59.039 --> 00:20:02.319
<v Speaker 2>That's pretty neat. Okay, so that's device stats and topology.

417
00:20:02.440 --> 00:20:05.559
<v Speaker 2>What about analyzing the actual traffic flowing through the network?

418
00:20:05.640 --> 00:20:13.039
<v Speaker 1>Deeper insights. The book covers flow based monitoring, NetFlow, s flow, ipfax.

419
00:20:12.279 --> 00:20:16.519
<v Speaker 2>The flow technologies giving you info like source sustination, IPS ports,

420
00:20:16.680 --> 00:20:17.920
<v Speaker 2>traffic volume.

421
00:20:17.680 --> 00:20:21.920
<v Speaker 1>Exactly, understanding who's talking to whom, what applications are using bandwidth.

422
00:20:22.079 --> 00:20:25.200
<v Speaker 1>The book mentions using pythons built in socket instruct modules

423
00:20:25.240 --> 00:20:28.640
<v Speaker 1>for parsing raw NetFlow packets low level stuff yeah, and

424
00:20:28.680 --> 00:20:31.640
<v Speaker 1>for s flow. It mentions external tools like slow tool

425
00:20:31.799 --> 00:20:34.119
<v Speaker 1>and the slow RT collector that you might integrate with.

426
00:20:34.160 --> 00:20:36.680
<v Speaker 2>And it also mentions end top right for even more

427
00:20:36.680 --> 00:20:38.000
<v Speaker 2>detailed traffic analysis.

428
00:20:38.039 --> 00:20:40.759
<v Speaker 1>It does end top or end topping. It's a popular

429
00:20:40.839 --> 00:20:43.440
<v Speaker 1>open source traffic monitoring tool. In the book notes, it

430
00:20:43.480 --> 00:20:47.119
<v Speaker 1>has a Python extension for deeper programmatic interaction and analysis.

431
00:20:47.480 --> 00:20:51.359
<v Speaker 2>So Python can touch pretty much every aspect of monitoring. Okay,

432
00:20:51.359 --> 00:20:56.400
<v Speaker 2>we've configured, automated, monitored. Can Python actually be the network

433
00:20:56.559 --> 00:20:57.519
<v Speaker 2>service itself?

434
00:20:57.680 --> 00:21:02.240
<v Speaker 1>A good question, Yes it can. The book introduces Flask

435
00:21:02.359 --> 00:21:04.920
<v Speaker 1>as a way to build your own network web services

436
00:21:05.240 --> 00:21:06.880
<v Speaker 1>or APIs using Python.

437
00:21:07.160 --> 00:21:10.799
<v Speaker 2>Flask that's a popular micro web framework right known for

438
00:21:10.839 --> 00:21:12.599
<v Speaker 2>being lightweight and flexible exactly.

439
00:21:12.799 --> 00:21:15.640
<v Speaker 1>The book shows a super simple Hello networkers example just

440
00:21:15.640 --> 00:21:16.599
<v Speaker 1>to get the idea.

441
00:21:16.359 --> 00:21:18.960
<v Speaker 2>Across the Hello world of web apps.

442
00:21:18.720 --> 00:21:21.559
<v Speaker 1>Basically, but you can build much more complex things. You

443
00:21:21.559 --> 00:21:23.839
<v Speaker 1>could create your own custom API, maybe one that lists

444
00:21:23.839 --> 00:21:27.640
<v Speaker 1>other systems, query network status, or even trigger specific automation

445
00:21:27.720 --> 00:21:28.640
<v Speaker 1>tasks you've built.

446
00:21:28.799 --> 00:21:31.160
<v Speaker 2>So building your own internal network tools with a web

447
00:21:31.240 --> 00:21:33.160
<v Speaker 2>front end or API precisely.

448
00:21:33.440 --> 00:21:35.839
<v Speaker 1>The book even touches on defining data models for your

449
00:21:35.839 --> 00:21:39.640
<v Speaker 1>network resources using an extension called Flask school Alchemy. If

450
00:21:39.680 --> 00:21:42.440
<v Speaker 1>you need a database, and importantly, how to secure these

451
00:21:42.519 --> 00:21:46.839
<v Speaker 1>APIs you build using Flask httb out for authentication and authorization.

452
00:21:47.160 --> 00:21:50.599
<v Speaker 1>You don't want just anyone triggering network changes via your API.

453
00:21:50.880 --> 00:21:55.039
<v Speaker 2>Definitely need security there, Okay, flask for building services. What

454
00:21:55.160 --> 00:21:58.799
<v Speaker 2>about performance, especially when dealing with lots of network devices

455
00:21:58.799 --> 00:21:59.720
<v Speaker 2>that might response.

456
00:22:00.759 --> 00:22:04.359
<v Speaker 1>Yeah, waiting for network io is a classic bottleneck. The

457
00:22:04.400 --> 00:22:07.680
<v Speaker 1>book addresses this with a section on asynchronous programming using

458
00:22:07.720 --> 00:22:09.519
<v Speaker 1>Python's asnc io features.

459
00:22:09.799 --> 00:22:14.000
<v Speaker 2>Async io that's about doing things concurrently, not blocking while

460
00:22:14.000 --> 00:22:14.880
<v Speaker 2>waiting for stuff.

461
00:22:14.920 --> 00:22:18.039
<v Speaker 1>That's the core idea. When your script sends a command

462
00:22:18.079 --> 00:22:20.440
<v Speaker 1>to a switch and is waiting for the response, a

463
00:22:20.440 --> 00:22:22.319
<v Speaker 1>normal synchronous script just sits.

464
00:22:22.039 --> 00:22:23.960
<v Speaker 2>There idle, wasting time.

465
00:22:24.240 --> 00:22:29.000
<v Speaker 1>Right, asynchronous code using libraries like acincio that the book introduces,

466
00:22:29.440 --> 00:22:32.359
<v Speaker 1>can switch to working on other tasks while waiting, like

467
00:22:32.480 --> 00:22:33.759
<v Speaker 1>talking to another switch.

468
00:22:33.519 --> 00:22:37.039
<v Speaker 2>Concurrently, so you can potentially interact with many devices much faster.

469
00:22:37.519 --> 00:22:41.000
<v Speaker 1>That's the promise. The book mentions libraries like scrappoly, which

470
00:22:41.000 --> 00:22:45.359
<v Speaker 1>are specifically designed for asynchronous interaction with network devices, highlighting

471
00:22:45.359 --> 00:22:49.720
<v Speaker 1>the potential for significant speed ups, especially for large scale automation.

472
00:22:49.440 --> 00:22:52.400
<v Speaker 2>Makes sense. Efficiency is key. Yeah, Now what about the cloud?

473
00:22:52.759 --> 00:22:55.160
<v Speaker 2>Networking doesn't stop at the data center edge anymore?

474
00:22:55.319 --> 00:22:59.039
<v Speaker 1>Absolutely not. The book has a chapter dedicated to cloud networking.

475
00:22:59.079 --> 00:23:02.160
<v Speaker 1>Focusing on the big players AWS and Azure.

476
00:23:02.279 --> 00:23:05.480
<v Speaker 2>Okay, Amazon Web Services and Microsoft Azure.

477
00:23:05.480 --> 00:23:08.440
<v Speaker 1>Give a high level comparison of their core networking concepts

478
00:23:08.920 --> 00:23:13.480
<v Speaker 1>AWS Virtual Private Clouds vpcs and Azra Virtual Networks v

479
00:23:13.559 --> 00:23:16.240
<v Speaker 1>nets basically your private network space in the cloud.

480
00:23:16.519 --> 00:23:20.480
<v Speaker 2>Understanding how cloud networking maps to traditional concepts is important, definitely.

481
00:23:21.000 --> 00:23:25.880
<v Speaker 1>The book briefly touches on KEYAWS components, subnets, internet gateways,

482
00:23:25.960 --> 00:23:30.599
<v Speaker 1>route tables, security groups like firewalls, elastic ips, net gateways,

483
00:23:31.160 --> 00:23:31.799
<v Speaker 1>the building.

484
00:23:31.559 --> 00:23:33.680
<v Speaker 2>Blocks, and similarly for Azure.

485
00:23:33.440 --> 00:23:37.880
<v Speaker 1>YEP mentions azurevnets, subnet network security groups, n sgs, VPN

486
00:23:37.920 --> 00:23:41.039
<v Speaker 1>gateways for site to site connections, expressed route for private connections.

487
00:23:41.319 --> 00:23:43.880
<v Speaker 1>Gives you a feel for the Azure networking landscape.

488
00:23:43.480 --> 00:23:45.880
<v Speaker 2>And crucially, how does Python fit in through their.

489
00:23:45.759 --> 00:23:49.559
<v Speaker 1>SDK software development kits. The book highlights BOTO three for AWS.

490
00:23:49.640 --> 00:23:53.200
<v Speaker 2>Bout three Yeah, that's the standard AWSSDK for Python.

491
00:23:53.119 --> 00:23:57.599
<v Speaker 1>And the Azure mgmt Network Library for Azure. These SDKs

492
00:23:57.680 --> 00:24:00.839
<v Speaker 1>let you use Python to programmatically create, can figure, and

493
00:24:00.960 --> 00:24:04.400
<v Speaker 1>manage all those cloud networking resources we just mentioned.

494
00:24:04.200 --> 00:24:08.480
<v Speaker 2>So infrastructure as code, but for your cloud network using Python.

495
00:24:08.400 --> 00:24:12.960
<v Speaker 1>Exactly powerful stuff. Okay, we're generating lots of data, logs,

496
00:24:13.240 --> 00:24:16.759
<v Speaker 1>monitoring stats, maybe flow data. How do we manage and

497
00:24:16.799 --> 00:24:18.079
<v Speaker 1>analyze all that effectively?

498
00:24:18.160 --> 00:24:21.359
<v Speaker 2>Good point data overload is real. The book introduces the

499
00:24:21.400 --> 00:24:23.880
<v Speaker 2>Elastic stack for this, the elk.

500
00:24:23.680 --> 00:24:26.000
<v Speaker 1>Stack, Elastic Search, log Stash, Kebana.

501
00:24:26.119 --> 00:24:29.119
<v Speaker 2>That's the one, a very popular open source solution for

502
00:24:29.200 --> 00:24:30.960
<v Speaker 2>centralized logging and analysis.

503
00:24:31.000 --> 00:24:31.880
<v Speaker 1>How does it break down?

504
00:24:32.039 --> 00:24:35.240
<v Speaker 2>Log Stash and related tools called Beats is used for

505
00:24:35.359 --> 00:24:39.319
<v Speaker 2>collecting and processing data from various sources cyslogs, from routers,

506
00:24:39.359 --> 00:24:42.920
<v Speaker 2>application logs, et cetera. Elastic Search is the distributed search

507
00:24:42.960 --> 00:24:45.720
<v Speaker 2>and analytics engine where the data gets stored and indexed,

508
00:24:46.200 --> 00:24:50.640
<v Speaker 2>and Kubana is the visualization layer dashboards charts exploring the data.

509
00:24:50.720 --> 00:24:53.400
<v Speaker 1>So collect with log stash, beats, store in search with

510
00:24:53.440 --> 00:24:55.440
<v Speaker 1>elastic Search, visualized with Cubana.

511
00:24:55.480 --> 00:24:58.680
<v Speaker 2>That's the basic workflow, and of course the book mentions

512
00:24:58.720 --> 00:25:01.480
<v Speaker 2>the elastic Search Python co Cliant library, so you can

513
00:25:01.559 --> 00:25:05.079
<v Speaker 2>interact with your elastic Search data programmatically using Python two.

514
00:25:05.400 --> 00:25:09.480
<v Speaker 1>Okay, makes sense for handling large volumes of network data. Now,

515
00:25:09.519 --> 00:25:14.160
<v Speaker 1>all these scripts, configurations, templates, playbook files, how do we

516
00:25:14.240 --> 00:25:15.519
<v Speaker 1>manage the code itself?

517
00:25:15.960 --> 00:25:20.759
<v Speaker 2>Version control absolutely essential? The book provides a solid introduction

518
00:25:20.839 --> 00:25:21.480
<v Speaker 2>to using.

519
00:25:21.279 --> 00:25:24.559
<v Speaker 1>Git get, the standard for version control these days pretty much.

520
00:25:24.640 --> 00:25:28.599
<v Speaker 2>The book explains the benefits tracking changes over time, collaborating

521
00:25:28.599 --> 00:25:31.680
<v Speaker 2>with others on the same codebase, like ansable playbooks or

522
00:25:31.720 --> 00:25:34.720
<v Speaker 2>Python scripts, being able to roll back to a previous

523
00:25:34.759 --> 00:25:36.160
<v Speaker 2>working version of something breaks.

524
00:25:36.200 --> 00:25:38.279
<v Speaker 1>Yeah, that rollback capability.

525
00:25:37.799 --> 00:25:40.000
<v Speaker 2>Is a life saver, it really is. The book also

526
00:25:40.039 --> 00:25:43.480
<v Speaker 2>clarifies the difference between Get the tool itself and GitHub,

527
00:25:43.559 --> 00:25:46.960
<v Speaker 2>a popular web platform for hosting Git repositories and collaborating.

528
00:25:47.039 --> 00:25:49.920
<v Speaker 1>Good distinction, and it covers basic Git commands.

529
00:25:50.200 --> 00:25:53.359
<v Speaker 2>Yeah, the fundamentals dock commit to save changes, push to

530
00:25:53.400 --> 00:25:56.799
<v Speaker 2>send changes to a remote repository like GitHub, pull to

531
00:25:56.799 --> 00:25:59.920
<v Speaker 2>get changes from others, and also mentions dot get ignored

532
00:25:59.920 --> 00:26:02.680
<v Speaker 2>files for telling Get which files not to track, like

533
00:26:02.799 --> 00:26:06.920
<v Speaker 2>passwords or temporary files. Right, don't want secrets in your

534
00:26:06.920 --> 00:26:10.880
<v Speaker 2>Git repo? Definitely not. And for deeper Python integration, the

535
00:26:10.920 --> 00:26:14.359
<v Speaker 2>book introduces libraries like get python for interacting with local

536
00:26:14.359 --> 00:26:19.319
<v Speaker 2>Git repos and pi GitHub for interacting with the GitHub api, so.

537
00:26:19.200 --> 00:26:22.519
<v Speaker 1>You can even automate GET operations from within your Python scripts.

538
00:26:22.519 --> 00:26:25.960
<v Speaker 2>If needed, you can building on version control. The next

539
00:26:26.039 --> 00:26:29.839
<v Speaker 2>logical step is automating the testing and deployment process, Continuous

540
00:26:29.880 --> 00:26:31.000
<v Speaker 2>integration or.

541
00:26:31.039 --> 00:26:35.000
<v Speaker 1>CI, CICD, big topic and DevOps. How does it apply here?

542
00:26:35.240 --> 00:26:39.119
<v Speaker 2>The book introduces the principles of CI automatically building, testing,

543
00:26:39.160 --> 00:26:43.000
<v Speaker 2>and validating changes every time someone commits new code. For networks.

544
00:26:43.039 --> 00:26:46.839
<v Speaker 2>This could mean automatically linting your Python scripts, checking playbook syntax,

545
00:26:46.880 --> 00:26:49.519
<v Speaker 2>maybe even spinning up a lab environment like with container

546
00:26:49.599 --> 00:26:52.039
<v Speaker 2>lab and running tests against virtual devices.

547
00:26:51.680 --> 00:26:53.480
<v Speaker 1>Catching errors early automatically.

548
00:26:53.759 --> 00:26:56.119
<v Speaker 2>That's the goal. The book uses git lab as an

549
00:26:56.119 --> 00:27:00.160
<v Speaker 2>example platform as it has CICD capabilities built in okay up.

550
00:27:00.200 --> 00:27:02.920
<v Speaker 2>It explains get lab runners, the agents that execute the

551
00:27:02.920 --> 00:27:07.000
<v Speaker 2>CI jobs, and the dot get lab Dashchi dot IML

552
00:27:07.079 --> 00:27:11.480
<v Speaker 2>configuration file where you define your CI pipeline, the stages.

553
00:27:11.079 --> 00:27:13.240
<v Speaker 1>And jobs to run, and it shows an example.

554
00:27:13.359 --> 00:27:17.240
<v Speaker 2>Yeah, a simple example using Nornier, another Python automation framework

555
00:27:17.559 --> 00:27:20.319
<v Speaker 2>within a get lab CI pipeline to maybe run some

556
00:27:20.400 --> 00:27:22.319
<v Speaker 2>validation commands on devices.

557
00:27:21.880 --> 00:27:24.599
<v Speaker 1>After change, automating the automation checks. Cool.

558
00:27:24.759 --> 00:27:25.200
<v Speaker 2>Yeah.

559
00:27:25.240 --> 00:27:28.160
<v Speaker 1>Finally, to make all this automation reliable, we need good

560
00:27:28.200 --> 00:27:29.599
<v Speaker 1>testing practices.

561
00:27:29.240 --> 00:27:32.759
<v Speaker 2>Right absolutely. The book wraps up by introducing Test driven

562
00:27:32.799 --> 00:27:35.400
<v Speaker 2>development TDD for network.

563
00:27:35.079 --> 00:27:39.000
<v Speaker 1>TDD, writing tests before or alongside the actual code.

564
00:27:39.039 --> 00:27:41.720
<v Speaker 2>That's the idea. It forces you to think about requirements

565
00:27:41.720 --> 00:27:44.039
<v Speaker 2>and how to verify your code works correctly before you

566
00:27:44.039 --> 00:27:47.200
<v Speaker 2>write it, or at least concurrently. The book mentions Python's

567
00:27:47.240 --> 00:27:50.279
<v Speaker 2>built in unit as framework and the popular third party

568
00:27:50.359 --> 00:27:51.799
<v Speaker 2>PI test framework.

569
00:27:51.440 --> 00:27:53.640
<v Speaker 1>Shows basic examples assertions.

570
00:27:53.720 --> 00:27:57.079
<v Speaker 2>Yeah, simple examples of writing test functions with assertions, checks

571
00:27:57.160 --> 00:28:00.279
<v Speaker 2>like a certain result expected value to verify your codees

572
00:28:00.319 --> 00:28:00.880
<v Speaker 2>as intended.

573
00:28:01.160 --> 00:28:03.599
<v Speaker 1>And it mentions in network specific testing framework too.

574
00:28:03.680 --> 00:28:08.599
<v Speaker 2>Briefly, Yeah, it introduces piats, which is a Cisco developed

575
00:28:08.640 --> 00:28:13.440
<v Speaker 2>but quite powerful and broadly applicable Python based framework specifically

576
00:28:13.480 --> 00:28:15.519
<v Speaker 2>designed for network testing and validation.

577
00:28:15.920 --> 00:28:19.079
<v Speaker 1>Wow. Okay, we have covered a ton of ground there,

578
00:28:19.559 --> 00:28:23.039
<v Speaker 1>from basic Python syntax right up to CICD and TDD

579
00:28:23.279 --> 00:28:24.359
<v Speaker 1>for network automation.

580
00:28:24.680 --> 00:28:28.160
<v Speaker 2>It really shows the breadth of Python's application in networking today.

581
00:28:28.440 --> 00:28:31.119
<v Speaker 1>So let's try and summarize. What are the absolute key

582
00:28:31.160 --> 00:28:33.880
<v Speaker 1>takeaways for you the learner listening to this.

583
00:28:33.960 --> 00:28:36.480
<v Speaker 2>I think the main thing is just how absolutely fundamental

584
00:28:36.480 --> 00:28:38.799
<v Speaker 2>Python has become. It's not just one tool for one

585
00:28:38.839 --> 00:28:42.160
<v Speaker 2>job anymore. No, it's everywhere, right from talking to individual devices,

586
00:28:42.240 --> 00:28:46.880
<v Speaker 2>legacy or modern using libraries like paramico or netmeko.

587
00:28:46.559 --> 00:28:50.119
<v Speaker 1>To orchestrating entire infrastructures with frameworks like ansable.

588
00:28:49.720 --> 00:28:54.039
<v Speaker 2>To monitoring performance, visualizing topology, analyzing traffic.

589
00:28:53.839 --> 00:28:56.599
<v Speaker 1>Managing cloud networks with SDKs like photo.

590
00:28:56.440 --> 00:29:00.200
<v Speaker 2>Three, tut, handling logs with the ELK stack, managing code

591
00:29:00.240 --> 00:29:04.519
<v Speaker 2>with GET, automating tests with CICD. Python is the common thread.

592
00:29:04.559 --> 00:29:08.680
<v Speaker 2>It really bridges that gap between traditional networking skills and

593
00:29:08.720 --> 00:29:11.319
<v Speaker 2>the modern programmable, software driven world.

594
00:29:11.599 --> 00:29:14.279
<v Speaker 1>It's the glue. Like the book said earlier. Okay, so

595
00:29:14.319 --> 00:29:17.279
<v Speaker 1>here's something to chew on. Looking forward, how do you

596
00:29:17.359 --> 00:29:23.319
<v Speaker 1>think the continued evolution of device APIs maybe more standardization

597
00:29:23.480 --> 00:29:26.880
<v Speaker 1>like with YANG and the ongoing development of Python libraries.

598
00:29:27.200 --> 00:29:29.680
<v Speaker 1>How is that going to further reshape network engineering?

599
00:29:30.039 --> 00:29:34.079
<v Speaker 2>That's a great question. More abstraction, easier intent based networking,

600
00:29:34.519 --> 00:29:38.640
<v Speaker 2>proactive management driven by AI, analyzing network data via Python.

601
00:29:39.079 --> 00:29:43.200
<v Speaker 1>What new possibilities does this unlock, maybe moving beyond reactive

602
00:29:43.240 --> 00:29:47.960
<v Speaker 1>fixes to truly innovative self managing networks. It's definitely something

603
00:29:48.000 --> 00:29:48.880
<v Speaker 1>to think about, isn't it?

604
00:29:48.880 --> 00:29:50.680
<v Speaker 2>It really is, And that leads to a question for you,

605
00:29:50.720 --> 00:29:53.440
<v Speaker 2>the listener, which specific part of all this sparked your

606
00:29:53.480 --> 00:29:56.079
<v Speaker 2>interest the most? Was it the device interaction, the large

607
00:29:56.079 --> 00:29:59.720
<v Speaker 2>scale automation with antsible cloud networking, maybe the testing side.

608
00:30:00.119 --> 00:30:02.680
<v Speaker 1>What area feels most relevant or exciting for you to

609
00:30:02.759 --> 00:30:03.839
<v Speaker 1>explore further.

610
00:30:03.880 --> 00:30:06.000
<v Speaker 2>Because the next step is really getting hands on.

611
00:30:06.319 --> 00:30:10.519
<v Speaker 1>Absolutely, we strongly encourage you, the learner, to actually explore

612
00:30:10.559 --> 00:30:11.640
<v Speaker 1>some of these libraries we.

613
00:30:11.640 --> 00:30:15.640
<v Speaker 2>Mentioned paramico Netmko, maybe your vendor specific SDK.

614
00:30:15.839 --> 00:30:19.319
<v Speaker 1>Antsable, flask Asensio if you're feeling brave.

615
00:30:19.559 --> 00:30:22.960
<v Speaker 2>The cloud SDKs like Boto three, the Elastic search client,

616
00:30:23.200 --> 00:30:24.839
<v Speaker 2>get Python tie test.

617
00:30:25.279 --> 00:30:28.519
<v Speaker 1>Pick one or two that seem interesting, and definitely consider

618
00:30:28.599 --> 00:30:30.160
<v Speaker 1>setting up a lab environment.

619
00:30:29.960 --> 00:30:34.480
<v Speaker 2>Crucial for practice. Use tools like ciscocml, eve ng, or

620
00:30:34.519 --> 00:30:36.839
<v Speaker 2>maybe try that container lab approach we discussed.

621
00:30:36.920 --> 00:30:39.480
<v Speaker 1>Get some hands on keyboard time. Try connecting to a

622
00:30:39.559 --> 00:30:43.279
<v Speaker 1>virtual device, running a simple playbook, writing a small script.

623
00:30:43.480 --> 00:30:44.920
<v Speaker 1>That's where the real learning happens.

624
00:30:45.000 --> 00:30:48.519
<v Speaker 2>Don't hesitate to dive into the official documentation for these tools,

625
00:30:48.559 --> 00:30:51.119
<v Speaker 2>look at examples on GitHub. There are tons of resources

626
00:30:51.119 --> 00:30:51.519
<v Speaker 2>out there.

627
00:30:51.640 --> 00:30:55.039
<v Speaker 1>The journey into Python networking is well, it's ongoing, but

628
00:30:55.079 --> 00:30:57.240
<v Speaker 1>it's definitely an exciting one to be on right now.
