WEBVTT

1
00:00:00.160 --> 00:00:03.399
<v Speaker 1>Welcome to the deep dive. Our mission cut through that

2
00:00:03.480 --> 00:00:07.559
<v Speaker 1>information overload, help you get well informed fast ever, face

3
00:00:07.599 --> 00:00:10.960
<v Speaker 1>those really repetitive IT tasks you know, onboarding users, maybe

4
00:00:11.080 --> 00:00:14.160
<v Speaker 1>updating configs, running the same reports, and just think, ugh,

5
00:00:14.320 --> 00:00:16.600
<v Speaker 1>there has to be a better way, like without needing

6
00:00:16.640 --> 00:00:19.000
<v Speaker 1>to be some hardcore coder. Well, this deep dive is

7
00:00:19.039 --> 00:00:21.320
<v Speaker 1>definitely for you today. We're really getting into the core

8
00:00:21.359 --> 00:00:24.960
<v Speaker 1>insights from PowerShell Fast Track Hacks for Non Coders, second

9
00:00:25.039 --> 00:00:28.480
<v Speaker 1>edition by Vikasukija. Our mission is basically to give you

10
00:00:28.480 --> 00:00:31.320
<v Speaker 1>a shortcut a way to grasp how PowerShell can genuinely

11
00:00:31.359 --> 00:00:34.920
<v Speaker 1>simplify complex IT admin stuff even if you've never really

12
00:00:34.960 --> 00:00:36.799
<v Speaker 1>thought of yourself as a programmer. You're going to discover

13
00:00:36.840 --> 00:00:40.560
<v Speaker 1>some fundamental concepts yeah, but also practical real role automation

14
00:00:41.039 --> 00:00:43.679
<v Speaker 1>and some pretty powerful cheat codes that'll save you time

15
00:00:43.719 --> 00:00:46.920
<v Speaker 1>reduce errors big time. So okay, let's umpack this. What

16
00:00:47.000 --> 00:00:49.719
<v Speaker 1>is PowerShell at its core? And why is this deep

17
00:00:49.799 --> 00:00:52.640
<v Speaker 1>dive such a potential game changer for IT pro who

18
00:00:52.719 --> 00:00:54.679
<v Speaker 1>isn't like from a programming background.

19
00:00:54.719 --> 00:00:58.079
<v Speaker 2>Well, what's really interesting here is how the author Vikasukija,

20
00:00:58.119 --> 00:01:01.600
<v Speaker 2>people know him as tech wizard right over two decades

21
00:01:01.600 --> 00:01:05.959
<v Speaker 2>in IT infrastructure. He frames PowerShell not as some super

22
00:01:05.959 --> 00:01:08.920
<v Speaker 2>complex coding language, not at all. He calls it a

23
00:01:09.040 --> 00:01:12.239
<v Speaker 2>task automation solution, comprising a command line shell and a

24
00:01:12.280 --> 00:01:16.519
<v Speaker 2>scripting language, much more approachable, and the book's goal, he says,

25
00:01:17.040 --> 00:01:19.640
<v Speaker 2>is to equip you with the skills to develop scripts

26
00:01:19.719 --> 00:01:23.159
<v Speaker 2>through a hands on approach, so really practical for you,

27
00:01:23.200 --> 00:01:26.120
<v Speaker 2>the IT admin. This means you can quickly learn to

28
00:01:26.120 --> 00:01:29.760
<v Speaker 2>write your own scripts, automate all sorts of IT systems

29
00:01:29.799 --> 00:01:33.159
<v Speaker 2>and processes without needing that computer science degree. It's really

30
00:01:33.200 --> 00:01:34.640
<v Speaker 2>about solving everyday problems.

31
00:01:34.719 --> 00:01:36.480
<v Speaker 1>That's a great way to put it, not about suddenly

32
00:01:36.519 --> 00:01:39.760
<v Speaker 1>becoming developer, but getting practical skills for IT work. Speaking

33
00:01:39.760 --> 00:01:42.599
<v Speaker 1>to practicalities, PowerShell's evolved a lot, hasn't it. I hear

34
00:01:42.640 --> 00:01:44.760
<v Speaker 1>it's not just Windows anymore. How big a deal is

35
00:01:44.799 --> 00:01:48.400
<v Speaker 1>that really for IT administration today? And what's it mean

36
00:01:48.439 --> 00:01:51.239
<v Speaker 1>if you're managing different kinds of systems?

37
00:01:51.359 --> 00:01:54.359
<v Speaker 2>Oh, it's a huge deal. Yeah. PowerShell seven especially it

38
00:01:54.400 --> 00:01:58.079
<v Speaker 2>brought in serious cross platform capability, so it runs smoothly

39
00:01:58.120 --> 00:02:01.560
<v Speaker 2>on Windows, Mac Os, Linux. That's a major shift from

40
00:02:01.640 --> 00:02:05.200
<v Speaker 2>older versions like five point one, which were well Windows only, right,

41
00:02:05.400 --> 00:02:08.319
<v Speaker 2>and for admins. Powertell seven also means better performance, less

42
00:02:08.360 --> 00:02:13.120
<v Speaker 2>memory usage, faster scripts. That's pretty crucial when you're automating

43
00:02:13.240 --> 00:02:16.240
<v Speaker 2>hundreds of things or running checks all the time. Let's

44
00:02:16.240 --> 00:02:18.960
<v Speaker 2>you scale up without killing your systems. Now that said,

45
00:02:19.280 --> 00:02:22.520
<v Speaker 2>PowerShell five point one is far from obsolete. Lots of

46
00:02:22.560 --> 00:02:24.919
<v Speaker 2>scripts still use it, and most of those are compatible

47
00:02:24.919 --> 00:02:27.919
<v Speaker 2>with powertell seven. Maybe meeting just minor tweaks okay, and

48
00:02:28.000 --> 00:02:30.800
<v Speaker 2>running them is simple. PowerShell for five point one PFTRA

49
00:02:30.879 --> 00:02:32.719
<v Speaker 2>version seven easy, so.

50
00:02:32.639 --> 00:02:35.479
<v Speaker 1>You're covered whether you're on legacy stuff or the latest

51
00:02:35.479 --> 00:02:40.439
<v Speaker 1>cloud environments. That's really key for anyone still managing older systems. Yeah, okay,

52
00:02:40.439 --> 00:02:42.280
<v Speaker 1>so we get the big picture revolution. Let's zoom in

53
00:02:42.319 --> 00:02:45.479
<v Speaker 1>a bit the actual building blocks for someone just starting.

54
00:02:45.479 --> 00:02:47.840
<v Speaker 1>Where do we begin, Like just storing information?

55
00:02:48.080 --> 00:02:50.479
<v Speaker 2>Yeah, good place to start. As variables, think of them

56
00:02:50.479 --> 00:02:54.439
<v Speaker 2>as labeled boxes for your data. In PowerShell, they always

57
00:02:54.439 --> 00:02:57.479
<v Speaker 2>start with a dollar sign f like that helps tell

58
00:02:57.520 --> 00:03:00.240
<v Speaker 2>them apart from commands, and they just store stuff. Could

59
00:03:00.240 --> 00:03:03.439
<v Speaker 2>be a number always one or textbad dollars pick gas simple,

60
00:03:04.199 --> 00:03:06.680
<v Speaker 2>and when you want to see what's inside right host

61
00:03:06.800 --> 00:03:08.840
<v Speaker 2>or right output, they just print it to the screen.

62
00:03:09.000 --> 00:03:10.800
<v Speaker 2>Right host is kind of neat you can add color

63
00:03:11.400 --> 00:03:14.120
<v Speaker 2>like a n heavy four ground color green for you know,

64
00:03:14.280 --> 00:03:15.639
<v Speaker 2>success messages or whatever.

65
00:03:15.759 --> 00:03:18.800
<v Speaker 1>God, And what about storing collections like lists of things,

66
00:03:18.840 --> 00:03:21.159
<v Speaker 1>because in it it's rarely just one server or one

67
00:03:21.240 --> 00:03:22.120
<v Speaker 1>user exactly.

68
00:03:22.199 --> 00:03:25.439
<v Speaker 2>That's where arrays and arraylists are indispensable. Arrays hold multiple

69
00:03:25.439 --> 00:03:28.759
<v Speaker 2>items like servers are server one, server two, server three.

70
00:03:28.919 --> 00:03:31.800
<v Speaker 2>But here's a really interesting point for performance, especially with

71
00:03:31.919 --> 00:03:35.479
<v Speaker 2>like huge data sets. Traditional arrays, they're fixed size. If

72
00:03:35.560 --> 00:03:38.039
<v Speaker 2>you add something, PowerShell actually has to create a whole

73
00:03:38.080 --> 00:03:40.199
<v Speaker 2>new array in memory, copies everything over.

74
00:03:40.319 --> 00:03:40.719
<v Speaker 1>Oh wow.

75
00:03:40.840 --> 00:03:43.159
<v Speaker 2>Yeah, it can be really slow, uses a lot of resources.

76
00:03:43.199 --> 00:03:46.199
<v Speaker 2>That's why the book suggests using arraylists as a thumb rule.

77
00:03:46.280 --> 00:03:49.960
<v Speaker 2>Their performance rich when data set is huge because they're dynamic,

78
00:03:50.000 --> 00:03:52.680
<v Speaker 2>they just grow as needed, much more efficient. You'd start

79
00:03:52.680 --> 00:03:55.919
<v Speaker 2>one like this servers smong dot, collections dot a raylist

80
00:03:56.080 --> 00:03:57.520
<v Speaker 2>at Okay, that's.

81
00:03:57.319 --> 00:04:01.719
<v Speaker 1>A critical tip. Sounds subtle, but a massive performance difference.

82
00:04:01.719 --> 00:04:04.639
<v Speaker 1>Definitely something to keep in mind for bigger scripts. So

83
00:04:05.039 --> 00:04:08.400
<v Speaker 1>storing data is covered, but scripts need to make decisions

84
00:04:08.479 --> 00:04:12.080
<v Speaker 1>right like if this condition is true, do this otherwise

85
00:04:12.120 --> 00:04:13.280
<v Speaker 1>do that absolutely.

86
00:04:13.319 --> 00:04:16.120
<v Speaker 2>That's exactly what conditional statements like I less are four.

87
00:04:16.480 --> 00:04:19.040
<v Speaker 2>They let your script make choices. For instance, if a

88
00:04:19.160 --> 00:04:22.160
<v Speaker 2>G nine checks a whyless is greater than nine? Pretty

89
00:04:22.160 --> 00:04:25.160
<v Speaker 2>straightforward and PowerShell has a bunch of these comparison operators

90
00:04:25.279 --> 00:04:28.759
<v Speaker 2>eq for equal mean not equal, olt less than even

91
00:04:28.800 --> 00:04:31.160
<v Speaker 2>fancier ones like light contains to see if something's in

92
00:04:31.160 --> 00:04:34.040
<v Speaker 2>a list, or g match for checking text patterns. Super

93
00:04:34.160 --> 00:04:36.959
<v Speaker 2>useful for logs, okay, and you can combine conditions too,

94
00:04:37.439 --> 00:04:41.279
<v Speaker 2>using a or or like if or AK ten lets

95
00:04:41.279 --> 00:04:42.680
<v Speaker 2>you build complex logic.

96
00:04:42.959 --> 00:04:45.920
<v Speaker 1>Right. So, ifils handles those branching decisions. But what if

97
00:04:45.959 --> 00:04:48.800
<v Speaker 1>you have one variable and it could be I don't

98
00:04:48.800 --> 00:04:51.680
<v Speaker 1>know five or six different specific things, and you need

99
00:04:51.680 --> 00:04:54.279
<v Speaker 1>a different action for each. Is there something cleaner than

100
00:04:54.360 --> 00:04:57.120
<v Speaker 1>just chaining a bunch of IFEL statements together. Yeah, gets

101
00:04:57.199 --> 00:04:58.240
<v Speaker 1>messy fast.

102
00:04:58.120 --> 00:05:01.319
<v Speaker 2>Yeah exactly. That's the perfect use case for switch. It's

103
00:05:01.439 --> 00:05:04.959
<v Speaker 2>much cleaner, way more readable than a long IFL sift

104
00:05:05.079 --> 00:05:08.560
<v Speaker 2>chain when you've got one variable with multiple distinct values.

105
00:05:09.199 --> 00:05:11.279
<v Speaker 2>Just makes your code easier to follow, easier to maintain.

106
00:05:11.439 --> 00:05:13.879
<v Speaker 2>The basic idea is switch five's value five tag do

107
00:05:13.920 --> 00:05:16.279
<v Speaker 2>something else default in check handle others. It just checks

108
00:05:16.399 --> 00:05:17.360
<v Speaker 2>value against.

109
00:05:17.040 --> 00:05:20.399
<v Speaker 1>Each case that clarifies things. Makes sense. So we can

110
00:05:20.439 --> 00:05:24.399
<v Speaker 1>store data, check conditions. What about doing things over and over,

111
00:05:24.720 --> 00:05:27.319
<v Speaker 1>like processing that list of one hundred users or checking

112
00:05:27.360 --> 00:05:29.839
<v Speaker 1>one hundred servers. Copy pasting isn't going to cut it,

113
00:05:30.240 --> 00:05:30.759
<v Speaker 1>no way.

114
00:05:30.879 --> 00:05:33.399
<v Speaker 2>That's the whole point of loops. They're designed for executing

115
00:05:33.399 --> 00:05:37.279
<v Speaker 2>a block of code repeatedly. PowerShell gives you a few types.

116
00:05:37.720 --> 00:05:40.600
<v Speaker 2>Four each is really common, great for going through items

117
00:05:40.600 --> 00:05:43.720
<v Speaker 2>in a collection, like four each user and user list.

118
00:05:44.160 --> 00:05:46.680
<v Speaker 2>There's also four each object, which you often use with

119
00:05:46.720 --> 00:05:49.800
<v Speaker 2>the pipe symbol, like user list, ford object two step

120
00:05:49.839 --> 00:05:53.199
<v Speaker 2>do something with each user processes things as they come through,

121
00:05:53.680 --> 00:05:57.000
<v Speaker 2>and the traditional for loop exists too, though maybe less

122
00:05:57.000 --> 00:05:58.879
<v Speaker 2>common in day to day PowerShell scripting.

123
00:05:59.160 --> 00:06:01.519
<v Speaker 1>Okay, and while what's the difference there? Right?

124
00:06:01.600 --> 00:06:04.560
<v Speaker 2>Wild loops two main flavors, do wile and just While

125
00:06:04.639 --> 00:06:07.319
<v Speaker 2>do wile runs the code first, then checks the condition

126
00:06:07.800 --> 00:06:09.759
<v Speaker 2>good if you need the action to happen at least once,

127
00:06:10.199 --> 00:06:13.519
<v Speaker 2>like prompting for input until it's valid oh okay, whereas

128
00:06:13.600 --> 00:06:16.800
<v Speaker 2>while checks the condition before running the code perfect if

129
00:06:16.839 --> 00:06:18.639
<v Speaker 2>you only want to proceed if the condition is met

130
00:06:18.720 --> 00:06:19.480
<v Speaker 2>right at the start.

131
00:06:20.160 --> 00:06:23.759
<v Speaker 1>Makes sense, especially that do wild distinction guarantees it runs once.

132
00:06:24.040 --> 00:06:26.519
<v Speaker 1>So loops handle repetition. But what if you have a

133
00:06:26.560 --> 00:06:29.040
<v Speaker 1>chunk of code you use all the time in different places,

134
00:06:29.079 --> 00:06:33.079
<v Speaker 1>maybe even different scripts. Copy pasting seems risky, errors creep in.

135
00:06:33.399 --> 00:06:37.000
<v Speaker 2>Yeah, you've hit on something crucial for writing maintainable code. Functions.

136
00:06:37.399 --> 00:06:40.639
<v Speaker 2>Functions are basically reusable blocks of code that you define

137
00:06:40.680 --> 00:06:43.160
<v Speaker 2>once and can call from anywhere in your script. They

138
00:06:43.160 --> 00:06:46.959
<v Speaker 2>cut down redundancy massively, make your code way more organized,

139
00:06:47.040 --> 00:06:50.439
<v Speaker 2>easier to debug. Two like a simple AD function function

140
00:06:50.519 --> 00:06:52.959
<v Speaker 2>AD eight dollars D dollars plus B dollars. Then you

141
00:06:53.040 --> 00:06:54.879
<v Speaker 2>just call AD five to six whenever you need it.

142
00:06:55.240 --> 00:06:57.800
<v Speaker 1>So, putting it all together, what does this mean for

143
00:06:57.839 --> 00:07:00.639
<v Speaker 1>someone just wanting to automate stuff? It really sounds like

144
00:07:00.680 --> 00:07:04.199
<v Speaker 1>PowerShell gives you the essential tools, you know, without needing

145
00:07:04.199 --> 00:07:05.720
<v Speaker 1>a whole computer science background.

146
00:07:05.839 --> 00:07:11.439
<v Speaker 2>That's precisely it. These foundational bits, variables, arrays, conditions, loops, functions,

147
00:07:11.480 --> 00:07:15.279
<v Speaker 2>they're absolutely crucial. They let you build robust, effective scripts

148
00:07:15.639 --> 00:07:18.800
<v Speaker 2>for real production environments. They're the building blocks. Once you

149
00:07:18.800 --> 00:07:21.120
<v Speaker 2>get these, you can really start automating your work.

150
00:07:21.439 --> 00:07:25.040
<v Speaker 1>Okay, building on those basics, let's get practical. Because scripts

151
00:07:25.079 --> 00:07:27.519
<v Speaker 1>aren't just about doing a task right. They need to

152
00:07:27.560 --> 00:07:31.360
<v Speaker 1>be smart track things take input in different ways. For admins,

153
00:07:31.439 --> 00:07:35.120
<v Speaker 1>logging and auditing often just as important as the automation itself.

154
00:07:35.279 --> 00:07:38.160
<v Speaker 2>Couldn't agree more. One of the first practical things for

155
00:07:38.199 --> 00:07:41.439
<v Speaker 2>any script is handling dates and logs. Timestamps are vital

156
00:07:41.920 --> 00:07:46.000
<v Speaker 2>tracking operations, creating unique filenames, building those audit trails. Get

157
00:07:46.040 --> 00:07:48.399
<v Speaker 2>date gives you the current data and time easily, and

158
00:07:48.480 --> 00:07:54.439
<v Speaker 2>you can format it however you need IILCHA, mmddxcmd, SDS whatever.

159
00:07:54.759 --> 00:07:56.720
<v Speaker 2>Then you can, like the book says, glue them all

160
00:07:56.720 --> 00:08:00.519
<v Speaker 2>together for unique log names like skipsees be eighteen, ASU

161
00:08:00.560 --> 00:08:04.399
<v Speaker 2>eight twenty twenty five, thirty three five five dot log.

162
00:08:04.879 --> 00:08:07.319
<v Speaker 2>It's also great for more complex stuff like getting the

163
00:08:07.399 --> 00:08:09.160
<v Speaker 2>first or last day of the month for reports, or

164
00:08:09.199 --> 00:08:11.639
<v Speaker 2>maybe a midnight timestamp for daily summaries.

165
00:08:11.680 --> 00:08:14.399
<v Speaker 1>Super practical. I can totally see using that to create

166
00:08:14.480 --> 00:08:17.120
<v Speaker 1>dated folders like can fig back up twenty two five

167
00:08:17.240 --> 00:08:19.079
<v Speaker 1>zero eight when you know exactly when that.

168
00:08:19.040 --> 00:08:21.439
<v Speaker 2>Backup runs exactly, And the book even provides some ready

169
00:08:21.439 --> 00:08:24.639
<v Speaker 2>made functions cheat codes basically to make this easier. There's

170
00:08:24.759 --> 00:08:28.160
<v Speaker 2>right log automatically creates timestamp logs even lets you specify

171
00:08:28.160 --> 00:08:33.480
<v Speaker 2>severity information warning error makes logs structured and critically set

172
00:08:33.519 --> 00:08:37.799
<v Speaker 2>recycle logs. This automatically deletes old log files based on age,

173
00:08:37.799 --> 00:08:41.240
<v Speaker 2>say older than thirty days, Super important to avoid filling

174
00:08:41.320 --> 00:08:45.879
<v Speaker 2>up server drives. Right works locally remotely specific paths, very flexible.

175
00:08:45.960 --> 00:08:48.360
<v Speaker 2>Oh and there's even start progress bar for giving some

176
00:08:48.440 --> 00:08:51.320
<v Speaker 2>visual feedback while long scripts run, so you're.

177
00:08:51.200 --> 00:08:53.519
<v Speaker 1>Not just automating the job, but the cleanup too. That's

178
00:08:53.519 --> 00:08:57.279
<v Speaker 1>a huge time saver. What about getting data into the scripts?

179
00:08:57.720 --> 00:09:01.399
<v Speaker 1>Admins are always dealing with lists, users from HR server lists,

180
00:09:01.480 --> 00:09:03.000
<v Speaker 1>guys can figs from spreadsheets.

181
00:09:03.120 --> 00:09:06.159
<v Speaker 2>Yeah, handling input to your scripts is absolutely essential for

182
00:09:06.200 --> 00:09:09.480
<v Speaker 2>real world stuff. Probably the most common method for providing

183
00:09:09.519 --> 00:09:13.919
<v Speaker 2>a script with structured input data is import CSV. Perfect

184
00:09:13.960 --> 00:09:18.399
<v Speaker 2>for bulk operations. Think updating hundreds of user accounts, migrating mailboxes.

185
00:09:18.679 --> 00:09:21.559
<v Speaker 2>You import a CSV file, maybe with columns like user

186
00:09:21.679 --> 00:09:24.679
<v Speaker 2>email title. Then you loop through accessing data like I

187
00:09:24.759 --> 00:09:27.519
<v Speaker 2>dot user or I email connects directly to things like

188
00:09:27.759 --> 00:09:31.240
<v Speaker 2>updating active directory, user attributes, city, state, job title. All

189
00:09:31.240 --> 00:09:34.159
<v Speaker 2>that and you can weave right log right into that process.

190
00:09:34.159 --> 00:09:37.600
<v Speaker 2>Log Each updates successful or not, leaves a clear audit trail.

191
00:09:37.559 --> 00:09:39.600
<v Speaker 1>So it's not just fire and forget you know exactly

192
00:09:39.600 --> 00:09:40.679
<v Speaker 1>what happened precisely.

193
00:09:41.039 --> 00:09:43.639
<v Speaker 2>Now. For simpler lists, maybe just a text file with

194
00:09:43.679 --> 00:09:47.519
<v Speaker 2>server names one per line, use get content and you

195
00:09:47.720 --> 00:09:50.600
<v Speaker 2>typically loop through that using for each object. Or hey,

196
00:09:50.679 --> 00:09:52.679
<v Speaker 2>sometimes the data might just be an array you define

197
00:09:52.759 --> 00:09:54.759
<v Speaker 2>right in the script, like servers at server zero one,

198
00:09:54.799 --> 00:09:57.279
<v Speaker 2>server zero two. If it's a short list, and what

199
00:09:57.320 --> 00:09:58.000
<v Speaker 2>if you need.

200
00:09:57.799 --> 00:10:00.480
<v Speaker 1>The script to ask the user something all t running

201
00:10:00.960 --> 00:10:04.120
<v Speaker 1>which server? Or are you sure bad? That kind of thing?

202
00:10:04.679 --> 00:10:07.519
<v Speaker 2>Interactive input read host is your friend.

203
00:10:07.519 --> 00:10:07.759
<v Speaker 1>There.

204
00:10:07.919 --> 00:10:10.840
<v Speaker 2>It prompts the user and waits for their input. It

205
00:10:10.879 --> 00:10:14.480
<v Speaker 2>gets really powerful with a secure string. Use that to

206
00:10:14.639 --> 00:10:18.519
<v Speaker 2>securely tap your passwords or other sensitive info. It encrypts

207
00:10:18.519 --> 00:10:21.960
<v Speaker 2>the input immediately, so it's never stored or logged as plaintext.

208
00:10:22.279 --> 00:10:25.279
<v Speaker 2>Absolutely vital for things like Office three sixty five logins

209
00:10:25.360 --> 00:10:28.200
<v Speaker 2>or apikes. What you get back is a PS credential

210
00:10:28.200 --> 00:10:31.559
<v Speaker 2>object that's PowerShell's secure way to handle those credentials within

211
00:10:31.559 --> 00:10:32.159
<v Speaker 2>the script.

212
00:10:32.360 --> 00:10:35.399
<v Speaker 1>This really makes scripts feel more intelligent. We're moving beyond

213
00:10:35.440 --> 00:10:38.679
<v Speaker 1>just simple commands to something that gathers info, logs progress,

214
00:10:38.840 --> 00:10:39.679
<v Speaker 1>even cleans up.

215
00:10:39.960 --> 00:10:42.759
<v Speaker 2>Indeed, these methods let you build scripts that are not

216
00:10:42.799 --> 00:10:47.240
<v Speaker 2>just powerful, but also robust auditible, user friendly. They handle

217
00:10:47.360 --> 00:10:49.519
<v Speaker 2>data the way you actually encounter it in day to

218
00:10:49.600 --> 00:10:52.240
<v Speaker 2>day It work. It's about building real solutions.

219
00:10:53.000 --> 00:10:57.000
<v Speaker 1>Okay, moving beyond just text input, what about more interactive ways,

220
00:10:57.279 --> 00:11:01.720
<v Speaker 1>maybe even graphical? And then let's tackle something huge modules.

221
00:11:01.840 --> 00:11:04.919
<v Speaker 1>How can we make scripts even more user friendly, say

222
00:11:04.960 --> 00:11:06.519
<v Speaker 1>for someone who isn't super technical?

223
00:11:06.720 --> 00:11:09.440
<v Speaker 2>Well, for more interactive input, the book actually shares a

224
00:11:09.480 --> 00:11:13.240
<v Speaker 2>neat cheat code function. Let's you create a simple GUI button.

225
00:11:13.399 --> 00:11:16.240
<v Speaker 2>Now it's probably less common for pure server automation, but

226
00:11:16.320 --> 00:11:19.480
<v Speaker 2>it creates a basic Windows form, you know, textboxes and ok.

227
00:11:19.679 --> 00:11:22.919
<v Speaker 2>Button makes scripts feel more engaging, maybe more intuitive for

228
00:11:23.039 --> 00:11:26.080
<v Speaker 2>users who prefer clicking over typing. The values they enter

229
00:11:26.159 --> 00:11:28.320
<v Speaker 2>get passed back to your script in an array like

230
00:11:28.360 --> 00:11:31.960
<v Speaker 2>return dollars. Interesting, and another really useful interactive bit is

231
00:11:32.000 --> 00:11:34.440
<v Speaker 2>a simple yes no prompt. You can use a wscript

232
00:11:34.440 --> 00:11:38.000
<v Speaker 2>dot shell pop up crucial for getting confirmation before doing

233
00:11:38.039 --> 00:11:41.200
<v Speaker 2>something critical like do you want to overwrite ad attributes?

234
00:11:41.240 --> 00:11:43.559
<v Speaker 2>Stops accidents, essential safety check.

235
00:11:43.759 --> 00:11:46.480
<v Speaker 1>That's a handy trick, especially for scripts running locally. Okay,

236
00:11:46.480 --> 00:11:49.440
<v Speaker 1>now let's talk modules. The book calls them the batteries

237
00:11:49.440 --> 00:11:51.799
<v Speaker 1>of power show. What are they exactly and why are

238
00:11:51.840 --> 00:11:54.799
<v Speaker 1>they so important for modern automation? Right?

239
00:11:54.960 --> 00:12:00.519
<v Speaker 2>Modules? Think of them as a package that contains PowerShell members, fnmellets, functions,

240
00:12:00.679 --> 00:12:04.120
<v Speaker 2>variables all bundle together. They're not just code packages, though,

241
00:12:04.440 --> 00:12:07.240
<v Speaker 2>they're really essential for interacting with a wide range of

242
00:12:07.279 --> 00:12:11.799
<v Speaker 2>products and services. We're talking Azure Office three sixty five,

243
00:12:11.960 --> 00:12:16.720
<v Speaker 2>Exchange Online, Teams, Serpoint Online, even aws everything. So you're

244
00:12:16.720 --> 00:12:21.000
<v Speaker 2>not just automating local stuff, You're orchestrating big, enterprise wide

245
00:12:21.000 --> 00:12:25.000
<v Speaker 2>workflows using tools built specifically for those platforms.

246
00:12:25.000 --> 00:12:27.480
<v Speaker 1>That really frames their importance. So where do you find

247
00:12:27.519 --> 00:12:29.679
<v Speaker 1>these batteries and how do you plug them in?

248
00:12:29.919 --> 00:12:33.320
<v Speaker 2>The main hub is the PowerShell Gallery at www dot

249
00:12:33.360 --> 00:12:37.360
<v Speaker 2>PowerShell gallery dot com. It's the central repository for almost

250
00:12:37.399 --> 00:12:41.480
<v Speaker 2>all public modules. Installing is usually simple, install module, dash name,

251
00:12:41.519 --> 00:12:43.960
<v Speaker 2>Azure aid for example. You can update them too, update

252
00:12:44.000 --> 00:12:46.480
<v Speaker 2>module or install module names. Some module forced to overwrite

253
00:12:46.480 --> 00:12:49.000
<v Speaker 2>an existing version and remove module gets rid of them.

254
00:12:49.120 --> 00:12:52.159
<v Speaker 2>Since PowerShell v three modules often load automatically when you

255
00:12:52.200 --> 00:12:54.320
<v Speaker 2>try to use one of their commands, pretty slick, but

256
00:12:54.480 --> 00:12:57.279
<v Speaker 2>import module still works if you need to load one explicitly.

257
00:12:58.000 --> 00:13:01.039
<v Speaker 2>Oh in just a quick note, snappins. That's the legacy

258
00:13:01.039 --> 00:13:03.639
<v Speaker 2>approach Older stuff like Exchange two thousand and seven, two

259
00:13:03.679 --> 00:13:07.200
<v Speaker 2>thousand sen maybe quest eight tools modules are the way forward.

260
00:13:07.279 --> 00:13:10.360
<v Speaker 1>Got it? And speaking of specific modules, the AUSO has

261
00:13:10.360 --> 00:13:13.480
<v Speaker 1>his own right the v sadmin cheap module. What's special

262
00:13:13.480 --> 00:13:14.200
<v Speaker 1>about that one? Ah?

263
00:13:14.279 --> 00:13:17.159
<v Speaker 2>Yes, the v sadmin module. It's a really powerful resource

264
00:13:17.399 --> 00:13:21.559
<v Speaker 2>Visus built himself, packed with functions to streamline common, often

265
00:13:21.639 --> 00:13:25.600
<v Speaker 2>tricky admin tasks. Like it has converts CSV to Excel

266
00:13:25.679 --> 00:13:28.759
<v Speaker 2>huge benefit. Converts CSV to a proper Excel file without

267
00:13:28.759 --> 00:13:31.600
<v Speaker 2>needing Excel installed on the server. That's amazing for automation wow,

268
00:13:32.159 --> 00:13:35.720
<v Speaker 2>Or get AD group members Recursive gets all members of

269
00:13:35.720 --> 00:13:38.279
<v Speaker 2>an AD group, even if they're nested deep inside other groups.

270
00:13:38.600 --> 00:13:41.039
<v Speaker 2>Saves a ton of manual effort. Then there's get off

271
00:13:41.039 --> 00:13:44.639
<v Speaker 2>and save encrypted password crucial for handling credentials securely saving

272
00:13:44.679 --> 00:13:47.320
<v Speaker 2>them to ENCRYPTI files or getting ps credential objects for

273
00:13:47.360 --> 00:13:48.320
<v Speaker 2>PowerShell commands.

274
00:13:48.519 --> 00:13:52.639
<v Speaker 1>That secure credential handling sounds vital. Where are cloud stuff

275
00:13:52.720 --> 00:13:55.480
<v Speaker 1>like connecting to Microsoft three sixty five That could be

276
00:13:55.519 --> 00:13:56.840
<v Speaker 1>fiddley sometimes.

277
00:13:56.440 --> 00:13:59.200
<v Speaker 2>Absolutely The launch and remove functions are great for that,

278
00:13:59.279 --> 00:14:03.240
<v Speaker 2>like launchioll for Exchange Online, launch SPO for SharePoint Online.

279
00:14:03.360 --> 00:14:07.600
<v Speaker 2>They simplify the whole connection and disconnection process. And importantly

280
00:14:07.639 --> 00:14:11.320
<v Speaker 2>they support using a client ID and certificate for app authentication.

281
00:14:11.919 --> 00:14:14.919
<v Speaker 2>That's the modern secure way for scripts to connect without

282
00:14:14.919 --> 00:14:17.159
<v Speaker 2>needing usernames and passwords stored anywhere.

283
00:14:17.320 --> 00:14:18.480
<v Speaker 1>Much better, definitely.

284
00:14:18.559 --> 00:14:22.159
<v Speaker 2>The module also helps with hybrid environments by encouraging command

285
00:14:22.200 --> 00:14:26.039
<v Speaker 2>prefixes like get EO mailbox versus get mailbox so you

286
00:14:26.080 --> 00:14:30.879
<v Speaker 2>know which environment you're targeting, avoids confusion. Plus little helpers

287
00:14:30.919 --> 00:14:34.120
<v Speaker 2>like new random password for generating complex passwords right there

288
00:14:34.120 --> 00:14:34.639
<v Speaker 2>in your script.

289
00:14:34.799 --> 00:14:37.720
<v Speaker 1>This is fantastic stuff. So you can make scripts interactive,

290
00:14:37.799 --> 00:14:40.559
<v Speaker 1>tap into this huge library of modules for different systems

291
00:14:40.639 --> 00:14:44.360
<v Speaker 1>and even use custom ones like vsadmin for specific shortcuts.

292
00:14:44.480 --> 00:14:46.399
<v Speaker 1>Really expands what's possible, right.

293
00:14:46.600 --> 00:14:48.960
<v Speaker 2>And it brings up a good point in this world

294
00:14:49.000 --> 00:14:52.879
<v Speaker 2>of just information everywhere, how do you manage your own

295
00:14:53.000 --> 00:14:56.879
<v Speaker 2>automation effectively? Modules are key. They give you the tools

296
00:14:56.879 --> 00:15:00.159
<v Speaker 2>for specific platforms, and things like visadmin are designed to

297
00:15:00.200 --> 00:15:03.120
<v Speaker 2>really simplify those common everyday admin headaches.

298
00:15:03.200 --> 00:15:05.600
<v Speaker 1>Okay, we've got our toolkit built. Let's talk about making

299
00:15:05.600 --> 00:15:10.080
<v Speaker 1>scripts truly production ready error reporting and well just reporting

300
00:15:10.080 --> 00:15:14.919
<v Speaker 1>in general, because a silent failure that can be worse

301
00:15:14.960 --> 00:15:16.200
<v Speaker 1>than no script at all.

302
00:15:16.120 --> 00:15:19.320
<v Speaker 2>You absolutely nailed it. Error reporting is a non negotiable

303
00:15:19.399 --> 00:15:22.240
<v Speaker 2>they must have you need to know if something breaks.

304
00:15:22.600 --> 00:15:25.879
<v Speaker 2>PowerShell has a built in variable error It holds all

305
00:15:25.919 --> 00:15:28.000
<v Speaker 2>the errors from your current session. You can grab the

306
00:15:28.039 --> 00:15:31.639
<v Speaker 2>most recent error eer dollars and email at using tenmail message,

307
00:15:31.879 --> 00:15:34.360
<v Speaker 2>or the sabin module has a send email function that's

308
00:15:34.399 --> 00:15:36.600
<v Speaker 2>better at handling the whole error array. If you want

309
00:15:36.600 --> 00:15:40.240
<v Speaker 2>more context and super important, remember error dot clear at

310
00:15:40.279 --> 00:15:42.759
<v Speaker 2>the start of your script, Otherwise you might send old,

311
00:15:42.799 --> 00:15:46.679
<v Speaker 2>irrelevant errors for a complete play by play. Start transcript

312
00:15:46.720 --> 00:15:50.879
<v Speaker 2>and stop transcript are fantastic. They log everything output commands,

313
00:15:51.039 --> 00:15:55.120
<v Speaker 2>entered errors to a text file, great for debugging or auditing,

314
00:15:55.480 --> 00:15:58.879
<v Speaker 2>and you can also explicitly log errors using that write

315
00:15:58.879 --> 00:16:01.720
<v Speaker 2>log function we mentioned setting the severity to error.

316
00:16:01.799 --> 00:16:05.639
<v Speaker 1>Okay, so we can log comprehensively and get notified. But

317
00:16:05.679 --> 00:16:08.559
<v Speaker 1>what about making the script itself tougher so it doesn't

318
00:16:08.600 --> 00:16:10.320
<v Speaker 1>just fall over when it hits a snag.

319
00:16:10.440 --> 00:16:13.799
<v Speaker 2>That's where tricatch blocks are essential. They provide a more

320
00:16:13.840 --> 00:16:17.799
<v Speaker 2>structured way to handle exception errors. Basically, you put the

321
00:16:17.799 --> 00:16:21.279
<v Speaker 2>code that might fail inside the triblock. If an error occurs,

322
00:16:21.399 --> 00:16:24.759
<v Speaker 2>the catch block runs instead of the script crashing. Inside

323
00:16:24.759 --> 00:16:26.799
<v Speaker 2>the catch, you can log the specific error, send an

324
00:16:26.799 --> 00:16:30.840
<v Speaker 2>email notification, maybe try an alternative action, or just exit gracefully.

325
00:16:31.080 --> 00:16:34.039
<v Speaker 2>It makes your scripts much more robust, much more reliable

326
00:16:34.080 --> 00:16:34.919
<v Speaker 2>for production use.

327
00:16:34.960 --> 00:16:38.080
<v Speaker 1>Okay, that makes scripts resilient. Now, once it has run

328
00:16:38.240 --> 00:16:41.000
<v Speaker 1>successful or not, you often need to present the results,

329
00:16:41.320 --> 00:16:43.399
<v Speaker 1>maybe to management, maybe just for your own records. That's

330
00:16:43.399 --> 00:16:44.559
<v Speaker 1>where good reporting comes in.

331
00:16:44.759 --> 00:16:49.799
<v Speaker 2>Absolutely reports are essential tools. Presenting data clearly helps stakeholders

332
00:16:49.879 --> 00:16:54.600
<v Speaker 2>understand what's happening, helps improve processes. Export CSV is probably

333
00:16:54.639 --> 00:16:57.960
<v Speaker 2>the workhorse here, a powerful and flexible tool for getting

334
00:16:58.080 --> 00:17:03.679
<v Speaker 2>data into spreadsheets. Exporting mailbox details, name, email address, quota

335
00:17:03.720 --> 00:17:08.720
<v Speaker 2>from Exchange simple effective right. For more complex CSV reports,

336
00:17:08.720 --> 00:17:11.359
<v Speaker 2>you might need to pull data from multiple places, maybe

337
00:17:11.400 --> 00:17:14.799
<v Speaker 2>get user info from ad than mailbox stats from Exchange.

338
00:17:14.920 --> 00:17:17.240
<v Speaker 2>Based on a list of users, you'd fetch the data

339
00:17:17.240 --> 00:17:20.279
<v Speaker 2>from each source, combine it into a custom object in PowerShell,

340
00:17:20.319 --> 00:17:22.680
<v Speaker 2>and then export that combined object to CSV.

341
00:17:22.880 --> 00:17:25.400
<v Speaker 1>And what about those tricky fields that have multiple values,

342
00:17:25.440 --> 00:17:28.640
<v Speaker 1>like recipients on an email log? How does CSV handle that?

343
00:17:28.680 --> 00:17:32.000
<v Speaker 2>Good question? For multi valued attributes, export CSV lets you

344
00:17:32.079 --> 00:17:34.599
<v Speaker 2>use custom expressions. You can join all the values into

345
00:17:34.599 --> 00:17:38.000
<v Speaker 2>a single string, maybe separated by commas or semicolons like

346
00:17:38.160 --> 00:17:41.000
<v Speaker 2>aud at name recipients, expression at of recipients next join

347
00:17:41.279 --> 00:17:42.920
<v Speaker 2>makes the CSV readable clever.

348
00:17:43.000 --> 00:17:46.000
<v Speaker 1>Okay, CSV is great, but sometimes you need something nicer

349
00:17:46.000 --> 00:17:49.160
<v Speaker 1>looking like Excel or even HTL for a dashboard.

350
00:17:49.480 --> 00:17:52.359
<v Speaker 2>Yeah, for Excel reporting it often looks more polished and

351
00:17:52.519 --> 00:17:57.400
<v Speaker 2>user friendly, especially for management charts formatting. All that. Method

352
00:17:57.440 --> 00:18:00.119
<v Speaker 2>one is using a cheap function like save cs V

353
00:18:00.240 --> 00:18:03.440
<v Speaker 2>to Excel from vsadman. But remember that usually needs Excel

354
00:18:03.519 --> 00:18:05.319
<v Speaker 2>actually installed where the script runs.

355
00:18:05.359 --> 00:18:05.759
<v Speaker 1>Ah.

356
00:18:05.799 --> 00:18:09.519
<v Speaker 2>Okay, limitation there, which brings us to method two, the

357
00:18:09.640 --> 00:18:13.880
<v Speaker 2>import Excel module. This thing is seriously powerful, probably the

358
00:18:13.880 --> 00:18:18.440
<v Speaker 2>most popular and powerful PowerShell module for Excel work. Key

359
00:18:18.480 --> 00:18:21.640
<v Speaker 2>advantage it lets you create and manipulate real Excel files

360
00:18:21.839 --> 00:18:25.359
<v Speaker 2>without needing Excel installed. Huge for server automation. Cannot stress

361
00:18:25.400 --> 00:18:25.759
<v Speaker 2>that enough.

362
00:18:25.759 --> 00:18:28.640
<v Speaker 1>That is a game changer. Wow, and HTML.

363
00:18:28.359 --> 00:18:31.599
<v Speaker 2>Hmail reporting is great for visual dashboards. Think traffic light

364
00:18:31.640 --> 00:18:34.319
<v Speaker 2>indicators showing service status read for down, green for up.

365
00:18:34.440 --> 00:18:36.680
<v Speaker 2>Easily viewable in a browser. You can even use online

366
00:18:36.759 --> 00:18:39.920
<v Speaker 2>HTML editors like HTML dash online dot com editor to

367
00:18:39.960 --> 00:18:42.680
<v Speaker 2>design your table or layout. Then grab the HTML code

368
00:18:42.720 --> 00:18:45.200
<v Speaker 2>and embed it right into your PowerShell script to populate

369
00:18:45.240 --> 00:18:48.960
<v Speaker 2>with live data. The Exchange health check example uses this.

370
00:18:48.960 --> 00:18:52.160
<v Speaker 1>This is truly getting to power user level building in

371
00:18:52.200 --> 00:18:56.559
<v Speaker 1>safety nets, robust error handling, and then presenting results professionally.

372
00:18:57.119 --> 00:18:59.359
<v Speaker 1>That knowledge is invaluable.

373
00:18:58.759 --> 00:19:01.480
<v Speaker 2>It really is. Knowledge is great, but it's most valuable

374
00:19:01.480 --> 00:19:06.400
<v Speaker 2>when understood and applied right. These techniques ensure errors get logged, reported,

375
00:19:06.640 --> 00:19:10.640
<v Speaker 2>handled properly, and that your data gets presented clearly. Leads

376
00:19:10.680 --> 00:19:14.680
<v Speaker 2>to more reliable systems, better decisions. Transforms a simple script

377
00:19:14.880 --> 00:19:16.039
<v Speaker 2>into a proper solution.

378
00:19:16.400 --> 00:19:20.839
<v Speaker 1>We've covered so much basics, data handling, security, error handley, reporting, shoe.

379
00:19:21.119 --> 00:19:24.119
<v Speaker 1>Now let's get into some advanced hacks, cool ways to

380
00:19:24.200 --> 00:19:27.359
<v Speaker 1>manipulate data, and then, crucially, how do we glue all

381
00:19:27.400 --> 00:19:30.200
<v Speaker 1>these pieces together solve those real world problems right?

382
00:19:30.240 --> 00:19:34.359
<v Speaker 2>Some miscellaneous keywords that are data manipulation masters, split super

383
00:19:34.440 --> 00:19:36.880
<v Speaker 2>useful breaks a string into pieces based on a character,

384
00:19:37.119 --> 00:19:39.480
<v Speaker 2>like splitting an email first dot last at domain dot

385
00:19:39.519 --> 00:19:41.799
<v Speaker 2>com on the dat and at to get first name,

386
00:19:41.880 --> 00:19:46.079
<v Speaker 2>last name domain. Replace does what it says, substitutes text.

387
00:19:46.599 --> 00:19:49.039
<v Speaker 2>Maybe replace dot wit in that email address if you

388
00:19:49.079 --> 00:19:51.759
<v Speaker 2>need it. For a file name selects string. This is

389
00:19:51.759 --> 00:19:56.559
<v Speaker 2>like rep for powersheld people searches for text patterns inside files. Example,

390
00:19:57.160 --> 00:19:59.880
<v Speaker 2>get child items, CE data logs, select string to pattern

391
00:20:00.200 --> 00:20:03.799
<v Speaker 2>r instantly finds all lines containing error in your logs.

392
00:20:04.279 --> 00:20:06.039
<v Speaker 2>Massive time saver for troubleshooting.

393
00:20:06.319 --> 00:20:09.640
<v Speaker 1>Definitely faster than opening each file. What about compare object

394
00:20:09.880 --> 00:20:10.640
<v Speaker 1>sounds powerful?

395
00:20:10.720 --> 00:20:13.720
<v Speaker 2>Oh it is? Compare object is highly efficient for comparing

396
00:20:13.759 --> 00:20:17.039
<v Speaker 2>two sets of data files or raise whatever. Perfect for

397
00:20:17.079 --> 00:20:20.119
<v Speaker 2>comparing AD group memberships. Find who's in group A but

398
00:20:20.200 --> 00:20:23.119
<v Speaker 2>not group B or vice versa. Let's you synchronize groups,

399
00:20:23.119 --> 00:20:26.200
<v Speaker 2>add the missing or remove the extras ensure they match perfectly.

400
00:20:26.400 --> 00:20:29.519
<v Speaker 2>Also great for emerging CSV files based on a common field,

401
00:20:29.519 --> 00:20:32.519
<v Speaker 2>like matching up user details with their OneDrive usage sets.

402
00:20:32.640 --> 00:20:36.880
<v Speaker 1>This is absolutely the aha moment. We've seen all these tools, variables, loops, modules,

403
00:20:37.000 --> 00:20:39.839
<v Speaker 1>error handling, reporting, and now you're showing how they connect,

404
00:20:40.359 --> 00:20:43.599
<v Speaker 1>how they solve actual common IT problems. Takes it from

405
00:20:43.640 --> 00:20:44.519
<v Speaker 1>theory to real.

406
00:20:44.319 --> 00:20:46.880
<v Speaker 2>Results exactly, and there's always more to learn. But seeing

407
00:20:46.880 --> 00:20:50.039
<v Speaker 2>how the pieces fit that lets you build really sophisticated,

408
00:20:50.119 --> 00:20:53.920
<v Speaker 2>efficient solutions for your daily work. Let's walk through that

409
00:20:53.920 --> 00:20:57.599
<v Speaker 2>scenario again, adding users from an HR file to an

410
00:20:57.640 --> 00:21:01.240
<v Speaker 2>AD group for say fileshare access your scripts. Would you know,

411
00:21:01.279 --> 00:21:04.240
<v Speaker 2>maybe add some headers for clarity, import the modules needed,

412
00:21:04.359 --> 00:21:08.119
<v Speaker 2>visadmin active directory, define your variables, dot log file path,

413
00:21:08.200 --> 00:21:10.680
<v Speaker 2>the user list file, the AD group name. Maybe how

414
00:21:10.680 --> 00:21:13.599
<v Speaker 2>many old logs to keep. Then the main loop go

415
00:21:13.680 --> 00:21:16.240
<v Speaker 2>through each user in the list, check if they're already

416
00:21:16.240 --> 00:21:18.920
<v Speaker 2>in the group using get ady user member of If not,

417
00:21:19.119 --> 00:21:22.440
<v Speaker 2>add them with AD eighty group member, and critically sprinkle

418
00:21:22.599 --> 00:21:26.480
<v Speaker 2>writ log calls throughout log who's being processed, who's added,

419
00:21:26.559 --> 00:21:30.000
<v Speaker 2>any errors encountered, and at the end set recyclogues to

420
00:21:30.039 --> 00:21:33.279
<v Speaker 2>clean up those old log files automatically. See that one

421
00:21:33.319 --> 00:21:37.319
<v Speaker 2>example pulls together variables, file input loops, eighty commands, logging,

422
00:21:37.359 --> 00:21:38.960
<v Speaker 2>clean up almost everything we've discussed.

423
00:21:39.000 --> 00:21:42.640
<v Speaker 1>It really crystallizes it, and it shows powershells adaptability. Right,

424
00:21:42.640 --> 00:21:45.279
<v Speaker 1>It's not just for one thing. The joy is seeing

425
00:21:45.359 --> 00:21:46.680
<v Speaker 1>these tools apply everywhere.

426
00:21:46.839 --> 00:21:49.920
<v Speaker 2>That adaptability is its core strength. It's used everywhere with

427
00:21:50.039 --> 00:21:55.720
<v Speaker 2>Microsoft Exchange, cleaning databases, finding orphan mailboxes, tracking messages, reporting quotas,

428
00:21:55.759 --> 00:22:00.759
<v Speaker 2>setting quotas you name it, active directory, exporting group members, recursively,

429
00:22:00.799 --> 00:22:05.440
<v Speaker 2>setting attributes from CSPs, exporting attributes to Excel, adding removing

430
00:22:05.519 --> 00:22:09.759
<v Speaker 2>users from files, native ad modules, quest modules, Office three

431
00:22:09.880 --> 00:22:14.599
<v Speaker 2>sixty five detailed exchange online reports, message tracking in the cloud, searching,

432
00:22:14.680 --> 00:22:18.000
<v Speaker 2>the unified audit log for teams, activity exchange changes, and.

433
00:22:18.000 --> 00:22:19.279
<v Speaker 1>Beyond the Microsoft stack too.

434
00:22:19.319 --> 00:22:22.960
<v Speaker 2>Oh yeah, AZUREAD or Entra as it's called now, adding

435
00:22:22.960 --> 00:22:26.519
<v Speaker 2>removing users from cloud groups, checking memberships, assigning admin roles,

436
00:22:26.559 --> 00:22:29.839
<v Speaker 2>checking provisioning, sink errors, and a really key thing here

437
00:22:30.240 --> 00:22:33.839
<v Speaker 2>the Microsoft Graph module. The old AZURID and MSOL modules,

438
00:22:33.839 --> 00:22:36.640
<v Speaker 2>they're on their way out. Microsoft Graph is the unified API,

439
00:22:37.039 --> 00:22:39.920
<v Speaker 2>the future one way to manage Azure Office three sixty

440
00:22:39.960 --> 00:22:42.920
<v Speaker 2>five teams, SharePoint, tons more, definitely the way to go

441
00:22:43.000 --> 00:22:46.279
<v Speaker 2>for future proofing scripts. Good to know even AWS. The

442
00:22:46.400 --> 00:22:50.559
<v Speaker 2>AWS PowerShell module lets you manage AWS resources like get

443
00:22:50.599 --> 00:22:53.440
<v Speaker 2>a two instants to list your virtual servers, plus all

444
00:22:53.480 --> 00:22:56.599
<v Speaker 2>the general tech CSV file operations, quick tricks for headers,

445
00:22:56.680 --> 00:23:01.160
<v Speaker 2>data cleaning, and don't forget rejx regular express, super powerful

446
00:23:01.160 --> 00:23:04.960
<v Speaker 2>for matching complex text patterns, validating emails, pulling specific data

447
00:23:04.960 --> 00:23:07.319
<v Speaker 2>from messilog files. Huge potential. There.

448
00:23:07.359 --> 00:23:10.559
<v Speaker 1>What a comprehensive tour from PowerShell basics right through to

449
00:23:10.640 --> 00:23:15.319
<v Speaker 1>advanced data slicing, secure connections, error handling, reporting across just

450
00:23:15.359 --> 00:23:19.319
<v Speaker 1>about every major IT platform. This deep dive has seriously

451
00:23:19.440 --> 00:23:22.720
<v Speaker 1>armed you, the listener, with insights and tools to really

452
00:23:22.759 --> 00:23:24.000
<v Speaker 1>streamline your IT work.

453
00:23:24.079 --> 00:23:27.279
<v Speaker 2>Yes, absolutely, and this knowledge means you can take those repetitive,

454
00:23:27.400 --> 00:23:31.160
<v Speaker 2>time consuming tasks and automate them, improve efficiency and sure

455
00:23:31.200 --> 00:23:33.960
<v Speaker 2>things are done consistently. Makes you a more effective, more

456
00:23:34.039 --> 00:23:36.799
<v Speaker 2>valuable IT pro even if you know you didn't start

457
00:23:36.799 --> 00:23:38.799
<v Speaker 2>out as a coder. It's about using the right tool

458
00:23:38.839 --> 00:23:39.279
<v Speaker 2>for the job.

459
00:23:39.480 --> 00:23:41.359
<v Speaker 1>We really encourage you to try some of these cheat

460
00:23:41.359 --> 00:23:44.440
<v Speaker 1>codes out, explore those ready made scripts maybe at tech wizard,

461
00:23:44.480 --> 00:23:46.920
<v Speaker 1>dot cloud, downloads like the book mentions, and just to

462
00:23:47.000 --> 00:23:49.279
<v Speaker 1>leave you with a final thought to chew on, given

463
00:23:49.279 --> 00:23:53.079
<v Speaker 1>how much time automation can save, what's one small, maybe

464
00:23:53.119 --> 00:23:56.480
<v Speaker 1>seemingly insignificant, repetitive task in your own digital life or

465
00:23:56.519 --> 00:23:59.839
<v Speaker 1>workflow that you could maybe start automating today, And how

466
00:24:00.000 --> 00:24:02.559
<v Speaker 1>I might tackling just that one small thing ripple out

467
00:24:02.640 --> 00:24:05.200
<v Speaker 1>and save you hours, maybe even days over the next year.

468
00:24:05.440 --> 00:24:06.279
<v Speaker 1>Something to think about.
