Microsoft PowerShell 4 Foundations

0:00Hello, my friends, and welcome to PowerShell 4 Foundations.

0:03My name's Garth Schulte.

0:04I'll be your host throughout this course

0:06where we're going to learn all about the future

0:08of administration configuration and automation

0:11here in Microsoft environments.

0:14Now is as good a time as any to get some PowerShell skills

0:16in your toolbox.

0:17Maybe you've been avoiding PowerShell.

0:19Maybe you just haven't gotten to yet.

0:20Or maybe you clicked on that little blue button

0:23in the taskbar out of curiosity and said,

0:25you know what, this is just a glorified command dot

0:27exe with a blue background.

0:29No, thanks and you go back to your GUI ways.

0:31Well, I'm here to tell you and show you

0:33that PowerShell is a big deal.

0:35Microsoft is serious about it, an employers

0:37are starting to get serious about it.

0:39And once employers really understand what PowerShell is

0:41and what it can do, they see two things, right, they see time

0:44and they see money.

0:45In these are two areas that PowerShell

0:46can give back immensely.

0:48In fact, if I'm an employer right now looking

0:50to fill administrative position, and I've got some candidates,

0:53you know what I'm going to do?

0:54In fact, let's do this.

0:55Let's say we've got Bob over here,

0:56and we've got Joe over here.

0:58So Bob and Joe are vying for the same job.

1:00What I'm going to do is I'm going to give them

1:02a common everyday task.

1:04Maybe I've got 50 users in a department

1:06that all need their password reset or some attribute

1:08changed in Active Directory.

1:10Well, I'm going to give Bob and Joe that task

1:11and say, go do that.

1:12Come back when you're done.

1:13And let's say that Joe, Joe's like Bradley Cooper

1:16from Limitless.

1:17Anybody see Limitless where he takes the smart pill

1:19and he's like a ridiculous genius?

1:20Well, let's say Joe took the PowerShell pill.

1:23Joe writes a couple commands or turns it into a script,

1:27and does it, comes back in maybe a minute,

1:29and says, oh, by the way, it's done.

1:31And I made it repeatable.

1:32Here you go.

1:33Here's the script if you ever need to do that again, Boss.

1:36Where Bob is still over there waiting for Active

1:39Directory to launch.

1:39He's farting around in the GUIs.

1:41Come on, Bob, get with the show.

1:44PowerShell's the future.

1:45And you know, obviously, who'd get hired there is Mr. Joe.

1:49So together, you and I are going to learn to be like Joe.

1:52So if you're like Bob now, no worries,

1:54because it doesn't take much to learn

1:56and become effective and dangerous in PowerShell.

1:59Now let's get to this Nugget.

2:00This Nugget, I'm going to give you more reasons

2:02to learn PowerShell.

2:03If that wasn't reason enough, we'll take a look at many more.

2:05We'll also define what PowerShell is,

2:07and then we'll get a bird's eye view of the entire course

2:09to see all the things that we're going to cover.

2:11And we'll also get you familiar with our lab and demonstration

2:14environment, the Virtual Nugget Lab.

2:15We've got a five-machine network at our fingertips

2:19ready to go that span many versions of PowerShell

2:21and many versions of Windows.

2:24I'm excited to be your host.

2:26Thanks again for joining me.

2:27Let's jump in.

2:28Let's make the case for PowerShell

2:29and start with a simple question.

2:31How do you currently perform and automate tasks

2:34across some of these common areas such as Active Directory?

2:36We just saw an example of Bob and Joe.

2:38But let's say that you were tasked

2:39with creating a bunch of users or maybe

2:41had to move users around, or migrate users,

2:43or maybe you had to change some attributes of users,

2:45or join a computer to a domain.

2:47If you don't PowerShell, the answer to all those

2:49is probably the GUI.

2:50Here's another one, the file system.

2:52How do you currently create and manage

2:54those directory structures for things

2:55like reports and backups?

2:57How do you archive that stuff?

2:58If the answer is by hand, I'm sorry.

3:01But it's not going to be after you learn PowerShell.

3:03Also another one here is for personal use.

3:05I'll give you a good example.

3:06I've got a network-attached storage device here

3:09that has 15 years worth of photos and videos

3:12from the family, right?

3:13They all have iPods and iPads and phones

3:15and any time they upload anything,

3:17my only requirement was put it in the year directory

3:19for the year that it is.

3:20So I've got 15 directories that span

3:2215 years over two and a half terabytes of data

3:24and everything has the default name, dsc9384.jpg or dot mpg

3:29or whatever.

3:30And I just let it go.

3:30I'm like, whatever, some day I'll get to that.

3:32Well, once I got some PowerShell skills, I'm like,

3:35you know what, this is going to be easy.

3:36It took me an hour to write a script

3:37to organize all that, appropriately name it,

3:39now anybody can find exactly what they're looking for.

3:42And that was a super fun one to build.

3:43What about server an operating system stuff?

3:45You know, those common everyday things

3:47that we do as administrators, like manage processes,

3:49services, event logs.

3:50Do you do that through the GUI?

3:52Probably.

3:52And you probably even do it on a machine by machine basis.

3:55PowerShell can help us out immensely in all those areas.

3:57What about-- and here's a really good one adding and removing

4:00features, roles and features.

4:02Let's say you've got three servers,

4:03and they're all going to be Hyper-V servers.

4:05How do you get Hyper-V on those?

4:06Would you log into each one individually,

4:08walk through the Add and Remove roles and Features Wizard?

4:11Probably.

4:12That sounds like half a day of work

4:13getting three Hyper-V servers up and running, right?

4:15With PowerShell you could do it in minutes.

4:17One command is literally a one-liner to do that.

4:19And you could send that command to all those machines

4:22and have them fully configured in no time.

4:23Pretty cool.

4:24Speaking of Hyper-V, virtualization

4:26is a big deal these days, right?

4:27But it's also a big time sink.

4:29If you don't know PowerShell, you're

4:30probably spinning up your environments by hand,

4:32and I can tell you from experience here

4:34being a trainer, I'm constantly spinning up

4:35virtual environments.

4:36And doing it by hand used to take forever.

4:38Doing it with PowerShell?

4:39Not only does it not take is long, but it's repeatable.

4:43So if I ever need to respin up that environment,

4:45I just run a script, boom, there it is.

4:46There's my network at the point exactly where I wanted it.

4:48And in fact, I did that for our Virtual Nugget Lab,

4:51spun up a network.

4:52Changed the computer names, brought up a domain controller,

4:54added all the machines to the domain,

4:56did a few configuration points, and now

4:57if I ever need to get us back to that starting point,

5:00I just run the script.

5:01What about server applications?

5:02How you manage and make configuration changes in things

5:04like Exchange, SQL, Systems, and our SharePoint?

5:06The list goes on and on there.

5:07The answer is probably the GUI.

5:09You're go into to the GUI, find what you're looking for,

5:10you make the change.

5:11But the problem with the GUI?

5:12It's not repeatable.

5:13What if you need to do it again, and again, and again?

5:15You're back inside of the GUIs.

5:17So PowerShell is great, because it lives

5:19outside of all these things.

5:21It's one tool to rule them all, and this is just

5:24a small example.

5:25Small small, small example of some of the things

5:27that we can do with PowerShell.

5:28How about a top 10 list?

5:30The top 10 reasons to learn PowerShell.

5:32Ready?

5:33Go.

5:33Number 10, it's easy to learn, really.

5:35It is incredibly easy to learn.

5:37Jeffrey Snover, the man and the myth,

5:38the legend behind PowerShell, somehow

5:41took the essence of the GUI and brought into PowerShell.

5:44And this is why GUIs are good, right?

5:46GUIs are good because it's what we're used to, number one,

5:49but they're also easy to learn.

5:50Once you learn something in one GUI,

5:52you can carry it over to the next.

5:53So the first time you learned how the X button to close

5:56the window, or the Minimize button or OK, Apply, Cancel,

5:58once you learn all those, you can carry it over

6:00to the next GUI.

6:01So it's efficient for learning how to learn.

6:03PowerShell is the same way.

6:05Not only will you be learning quickly,

6:07you'll be ripping off commands across your whole network

6:10in no time, but you learn how command-lines work,

6:12the structure, the syntax, the convention,

6:14you carry that information over to the next command-line.

6:17So whether you're working Windows, or SQL

6:18Server or SharePoint, it'll just be learning specifics

6:21about those command-lines.

6:22And we'll talk a little bit more about this,

6:24how it's discoverable and predictable,

6:26but just know that PowerShell is easy to learn.

6:28And CLIs get a bad rap, and that's

6:30kind of why PowerShell's a bad rap because who wants to work

6:33in a text-based environment?

6:35Nobody.

6:35But PowerShell's different as you'll see.

6:37Number nine, it can be the only way.

6:40Yeah, not every single feature is inside of the GUI.

6:43In fact, a lot of things in Active Directory

6:45and other products, you're only going

6:47to be able to access using PowerShell.

6:49Number eight, GUIs are slow and, of course, this incomplete kind

6:53of ties into number nine there.

6:54But the slow part is what I want to highlight here.

6:56No matter how good you are at doing something in the GUI,

7:00you'll never be able to do it as fast as you

7:01can do it in PowerShell.

7:03As an example, say you were tasked with creating 100 Active

7:05Directory Users.

7:06They give you a spreadsheet, here you go.

7:08What are you going to do?

7:09If you're going to do that in the GUI, at most, at the best,

7:11let's say it takes you a minute to create

7:13a user in Active Directory based on that spreadsheet.

7:15Enter all that data, you hit Create,

7:17and then you go to the next one, the next one, the next one.

7:18So if it takes you a minute, to do 100 users,

7:20that's a little over an hour and a half.

7:22In PowerShell, one line of code to import those users

7:25into Active Directory.

7:26I'm not kidding.

7:26One line, so it would take you seconds.

7:30Number seven, it's actually really fun to use.

7:34I'm not kidding.

7:35It's like you got to be careful with this stuff,

7:37because you could end up in PowerShell anonymous, right?

7:39PA.

7:40But really, once you get dangerous with this stuff,

7:43you're going to want to keep going more, and more, and more.

7:45And once you get familiar with a few commands,

7:47you get them under your belt, then

7:48you're going to want to start writing scripts and doing

7:50some incredibly neat stuff with very little effort.

7:54So it's fun to use as you'll see.

7:55It's like it's like Pringles, you know,

7:57once you start you can't stop.

7:58Once you pop, you can't stop.

7:59PowerShell and Pringles, one in the same.

8:01Number six, you can do so much with so little.

8:04These commandlets, which are native PowerShell commands

8:07that we'll get plenty into, have a lot of power in them.

8:10Combine that with something called the Pipeline, which

8:12we're going to look a lot at, which essentially allows

8:14us to connect commands together and pass data between commands,

8:18you'll be astounded.

8:19Half the time, again, you won't need a script

8:21to do something that you would normally need a script for.

8:24Number five Microsoft is baking it in to everything.

8:26Almost every GUI we use today on the server side

8:29is just executing PowerShell commands under the hood.

8:31And that trend is going to continue

8:32until eventually PowerShell is underneath everything.

8:36Number four, the time and cost savings are astronomical.

8:39We looked at this and an example of this earlier,

8:41but I mean this is the truth.

8:43Employers are going to be hiring people

8:44that have PowerShell skills over people that do not,

8:46because they're the ones that are going to help move

8:49the business forward by automating and making

8:51things repeatable.

8:52They'll never do things more than once,

8:53because they'll never half to.

8:55They do it once, they turn it in to a script or store

8:57that command somewhere.

8:58If they ever have to do it again, they just run it,

9:00so time wasted doing the same things over and over.

9:03Number three, it's enabling interactivity like never

9:05before.

9:06This is a big one.

9:08Here's why.

9:09Remember over here server apps?

9:10What if I had to create a process

9:12that did some kind of synchronization or coordination

9:17across some of these products, how would you do it now?

9:19Not easily.

9:20PowerShell makes it easy because, again, it

9:22sits outside in all of these products exposed commandlets

9:25that we can tap into from PowerShell.

9:26So now all of a sudden it becomes

9:28very easy to do cross product integration.

9:32Number two, it's the Microsoft standard for automation.

9:35Now, going forward, Microsoft's in it for the long haul

9:37here with PowerShell.

9:38So once you learn how to use PowerShell

9:41and how to automate something, you'll

9:42never need to, or even want to, do it any other way again.

9:45It's just that easy.

9:46And number one, your future is an IT professional

9:49depends on learning PowerShell.

9:51This is the skill that employers are

9:53going to be looking for in the future.

9:54So it's as good a time as any to learn PowerShell.

9:57In fact, now is the perfect time to get into PowerShell,

9:59because it's just starting to get interesting, really

10:02interesting.

10:02We're going to be focusing heavily

10:04on PowerShell Version 4.

10:06Version 4 brings a lot of stuff to the table.

10:08They've worked out a lot of kinks.

10:10They've added a lot more commandlets, which

10:11are going to give us a wider and deeper reach into Windows

10:13and beyond, and they've introduced a new feature called

10:15DSC, Desired State Configuration, which

10:18is going to, again, change the face of configuration

10:20management as we know it.

10:22So now that we know why we should be learning PowerShell,

10:24hopefully, let's talk about what PowerShell is.

10:26If I had to define PowerShell in one sentence,

10:28I would call it an object-oriented command line

10:30shell and scripting language based on the dot NET

10:32framework that gives us all those benefits, everything

10:35we need to do here from an administrative perspective.

10:37But here's the thing, this is an important keyword right here,

10:40object-oriented.

10:41Windows is an object-oriented operating system,

10:44but this term can scare a lot of people away, right?

10:46Because this is a developer term,

10:48object-oriented programming, things like classes,

10:50polymorphism, inheritance, instantiating objects.

10:53But here's the thing.

10:54We only need to know objects.

10:56Properties, methods, events, things

10:57we'll cover when we get into objects,

10:58but this is really the magic, the secret sauce

11:00behind PowerShell is it's an object-based shell.

11:03So we can create these really elegant pipelines,

11:05pass objects, and this is why we can do so much with so little.

11:08So again, the man and the mind behind PowerShell's name

11:11is Jeffrey Snover, brilliant guy.

11:12And his vision for PowerShell was

11:14outlined in something known as the Monad Manifesto, Monad,

11:17the name of PowerShell before it was actually

11:19renamed to PowerShell.

11:20But his vision was essentially to give anybody, power users,

11:23administrators, whoever could tap into PowerShell here,

11:25the power of dot NET framework and the power of a developer

11:28without actually having to do any coding or development work.

11:31The rest is history.

11:32So what is PowerShell?

11:34First up, it's a command-line shell.

11:36So it's just like command dot exe.

11:37In fact, we can run all those utilities

11:39that you're used to running, Ping, IP, config, [INAUDIBLE],

11:41all those things we can still do in PowerShell.

11:43So theoretically, you never have to open up command dot exe

11:46again.

11:46Just use PowerShell for that kind of stuff.

11:48We've got PowerShell specific things

11:49that we can do that replaces those to work

11:52with objects rather than text.

11:54And actually, that's going to be a big part of this course.

11:57We're going to learn a lot of commandlets.

11:59So think of commandlets like regular commands

12:01on steroids, because they're little dot NET utilities that

12:04send us back dot NET objects that we can work with passed

12:07down the pipeline to other commands

12:09or do all kinds of stuff with.

12:10Cool stuff that you will see.

12:11Secondly here, it is a scripting language.

12:14It's very simple scripting language

12:16once you get the hang of it.

12:16We have variables.

12:17We have control flows, so once we

12:18want to start doing more complex things,

12:21we're going to break out the scripts to do so.

12:23It's object-based rather than text-based,

12:25and this is really what sets PowerShell

12:27apart from a traditional Linux shell like Bash

12:30or even the Legacy command prompt that we

12:31were talking about here.

12:32So traditional shells output text this is the big difference

12:36right here.

12:37And that's going to make it difficult to do things

12:39like formatting and filtering.

12:40And there are tools to help us get the job done

12:42in those old school shells, like setting preferences,

12:45but it takes years to master things like regular expressions

12:47to do the heavy text parsing.

12:49So because PowerShell takes advantage of the underlying dot

12:51NET framework and uses objects to represent data,

12:54it's going to make life a lot more fun and efficient inside

12:57of the shell.

12:58PowerShell's also consistent with its syntax

12:59and conventions, and this is a big one

13:01because, again, with those Legacy shells,

13:03people build command line utilities all the time,

13:05and there's no standard.

13:06Again, some people may use dashes or slashes or whacks

13:09or whatever for their switches and there's no consistency

13:12across perimeters.

13:13Well, with PowerShell, you learn a commandlet,

13:15you learn a parameter, especially

13:17if it's a common parameter, that parameter's

13:18going to work the same across all the other commandlets.

13:20And that syntax is going to be the same across all

13:22of the commandlets, so it's is very learner friendly and user

13:25friendly.

13:26Now, this next bit is probably one of the coolest parts

13:29about PowerShell.

13:30This is a Microsoft term, are you ready?

13:31It's discoverable and predictable.

13:34Discoverable means we can easily find what we're looking for.

13:38So this happens a lot.

13:39The first time you fire up PowerShell, as most people do,

13:42they look at the screen and they go now what or what's next?

13:47Well, this is what's next.

13:48What's next is you need to find what you're looking for.

13:50So we've got a search engine on top of everything

13:53in PowerShell called Get Dash Comman.

13:55It's a commandlet.

13:56It's a very easy to use search engine

13:57to help us find what we're looking for.

13:59And PowerShell commandlets have a really consistent naming

14:03convention that goes in the form of verb, you know,

14:06get, add, remove, clear, that kind of thing, the action

14:08that you're taking.

14:09And then the noun, what research are

14:11you working with, service, event log, process, computer,

14:13so and so forth.

14:14So this is why it's predictable, because if a new set

14:16of commandlets come up for a product, you already know.

14:18You can essentially predict exactly what you're looking for

14:22based on that product.

14:22It's also flexible and extensible.

14:25So comes packaged with lots of core commandlets.

14:28But let's say we're in a Windows 8.1 machine,

14:30we have it installed, and we want to remotely manage

14:32Active Directory.

14:33Well, guess what?

14:34We can download the remote server administration

14:35tools which give us access to all

14:36those Active Directory commandlets.

14:38We import that, we work with them,

14:39and boom, now we can work with Active Directory from anywhere.

14:42And that goes for all the other server side products

14:44as well in many other areas.

14:46In fact, we can build our own modules.

14:47We can even build our own commandlets

14:49in the dot NET framework.

14:50It's literally five lines of code

14:51set up to skeleton to create your own commandlets.

14:53It's really, really neat stuff.

14:55It's dynamic and powerful as we'll

14:56see throughout the course.

14:57It's automatable and, as you'll see,

15:00it's now everywhere in Windows.

15:02So what are we going to be doing with PowerShell in this course?

15:04Well, I tell you, if you know nothing about PowerShell

15:06or if you know something about PowerShell,

15:08you've come to the right place.

15:09So we're going to start from the ground up,

15:12and then we're going to turn it up.

15:13So we'll start here immediately following

15:15this Nugget with installation.

15:16I'll show you how to install it on Legacy systems,

15:18how to install it across the Enterprise.

15:20And we'll talk about what versions of PowerShell

15:23installed by default, what's supported, and specifically,

15:26where PowerShell 4 is supported and what the requirements are.

15:28Then we'll get started.

15:29Here we're going to get familiar with our tools.

15:31We'll get familiar with the ISE, the Integrated Scripting

15:33Environment, as well as the shell itself,

15:34the old command-line shell.

15:35Those are the two screenshots we saw in the previous screen.

15:37And we'll get familiar with get command.

15:39So we're very familiar with how to use that search

15:41and define exactly what we're looking for.

15:44Then we'll get into the Help System, a very, very incredible

15:47and dynamic help system that will make it very easy to learn

15:51what all these commandlets do, everything from the syntax,

15:54to description, to examples.

15:55And we'll take a look at all different ways we can

15:57use that wonderful Help System.

15:59From there, we're going to get into commands.

16:00So here's where we're going to learn all the terminology

16:02in PowerShell.

16:03What's a command?

16:04What's a command level?

16:05What's a function?

16:05What's a script?

16:06What's an alias?

16:06So all those components that make

16:07a PowerShell, all those things we'll be working with we'll

16:09define there.

16:10We'll also get familiar with syntax,

16:11and we'll talk about some of the common commands

16:13that you'll be working with every day inside of PowerShell.

16:16From there, we'll get into objects.

16:17We'll define what an object is.

16:18We'll see why they're so critical to understanding

16:20how PowerShell functions.

16:22And we'll even look at something called

16:23get [INAUDIBLE], which allows us to interrogate an object

16:26to see everything there is to know about it.

16:28We'll get into pipelines.

16:29You've got to know objects before pipelines,

16:30because pipelines are how we're going

16:32to take data that's returned from a commandlet

16:34and pass it down the pipeline.

16:35And do some more with it, filter it, format it, sort it,

16:38transform it, or maybe just do something with it, right?

16:42So big look at the pipeline, and we've actually

16:44got a couple of Nuggets on the pipeline.

16:45One to get introduced to it, one to go deep down

16:48to understand how objects are passed around the pipeline.

16:51From there, we're going to get into providers.

16:53And providers essentially allow us

16:55to take an underlying data source

16:57and make it look like a file system.

16:58So everybody's familiar with the file system, right?

17:00You've got directories, subdirectories, subdirectories,

17:02and files.

17:03While providers abstract that underlying data source to make

17:06it look like this, so we can map a drive

17:08to things like the registry and make the registry look

17:10like a file system, which will make it

17:11very easy for us to work with.

17:13We'll also get into Windows Management Instrumentation

17:15and the Common Information Model, which

17:18will allow us to tap into the functionality of the operating

17:20system.

17:21We'll be using that quite heavily, too.

17:23It's a great way to get and extract information out

17:26from the operating system level.

17:27And, again, even tap into and utilize

17:29some of that functionality at the OS level.

17:32We'll get into remoting, which is

17:34how we're going to execute commands across the network.

17:37We've got other ways to do it, but this

17:39would be the best and most secure way of doing it.

17:41So if we want to execute, send commands,

17:43PowerShell commands, over to 100 machines, we can do that.

17:46And all those commands will get executed on those machines.

17:48And we'll get the results sent back

17:50to where we're running power, so on the client machine, really,

17:53really awesome stuff.

17:53We'll get into automation.

17:55We've got background jobs, which are

17:56way to run long running tasks in the background,

17:58as well as scheduled jobs for automation.

18:00We'll get into scripting.

18:01We've got a bunch of Nuggets on scripting

18:03to get familiar with how to write scripts.

18:04And at the end here, we're going to look at Desired State

18:06Configuration, which is that new feature in PowerShell 4

18:08that is just absolutely incredible.

18:11Jeffrey Snover called this the "make it so feature."

18:13Essentially, this stops configuration drift.

18:16Configuration drift is one of those things

18:18that happens over time.

18:19People fight fires, they change settings,

18:21and they don't put them back.

18:22And eventually you have a system that

18:24is completely different from the state

18:26that you wish it to be in.

18:28So Desired State Configuation allows

18:30us to declaratively define what a machine should

18:33look like as far as configuration, settings,

18:35features, all that stuff.

18:36And then if those ever change, Desired State Configuration,

18:39after a set amount of time, will put it back to normal.

18:42Really powerful stuff, and it goes way beyond that,

18:44and that's what we'll dig into in those Nuggets.

18:47And we'll also, at the end here, throw some challenges your way,

18:49and along the way, we'll do some really neat real-world stuff.

18:52So here's the Virtual Nugget Lab.

18:53This is the network that we're going to be working with.

18:55And you can have access to this network as well.

18:57If you're a premium subscriber, you

18:58can fire it right up from the course page

19:00right through your browser and have access

19:02to this five machine network.

19:03And we're going to be doing a lot in here.

19:05So we're going to start small just

19:06working with one or two machines,

19:07and then by the end of this course,

19:09we'll be sending commands in automating things

19:12across the entire network.

19:13We're going to do some pretty cool things.

19:15So we've got DCNUGGET.

19:16This is our domain controller.

19:17FSNUGGETs are file server.

19:19APPNUGGET is going to be kind of our everything else.

19:21We'll eventually get IS on here.

19:23We'll write and automate some tasks

19:25to run across the whole network, gather some information,

19:28create a web page, put it on IS, and we'll

19:29use Desired State Configuration to make sure

19:31that all those features stay in place.

19:33Really cool stuff.

19:33We're going to, like I said, go from zero to hero

19:36here by the time we're done with this course.

19:38And then we've got some client machines here, a Windows 7

19:40client and a Windows 8 client.

19:42Now let me introduce you to the network

19:43we're going to be working in.

19:44There it is.

19:45This is actually our domain controller here.

19:46In fact, let me bring this over.

19:48There we go, all right, cool.

19:49So here we go.

19:50Here's DCNUGGET, here's our File Server

19:51Nugget, Windows Server 2012 R2 on those.

19:53Here's our other server.

19:54So we have three servers here all with Windows Server 2012

19:56R2.

19:57And we've got two client machines.

19:58Here's our Windows 7 client and here's our Windows 8 client.

20:01So right now, we've got all the default installations

20:04of PowerShell, which means we're fine on the server

20:06side and even the 8.1 side.

20:07In fact, we can see this.

20:08Let's just fire up PowerShell here and let's

20:11just run a quick PS version table.

20:13Don't worry about this if none of this make sense,

20:15we're going to get into it.

20:16So there we go.

20:17In fact, in our installation Nugget,

20:18it will get you very familiar with PS version table.

20:20We'll do some pretty cool things with it.

20:22So PowerShell version 4 right here, so we're good there.

20:25But if we head over to our Windows 7 client,

20:28and we try that out, you can see that we're

20:30running PowerShell Version 2.

20:31So this is something, an older Legacy

20:33machine, something you'll probably

20:35come across in the real world.

20:36If you have a lot of older clients out there,

20:37you'll need to get them up to PowerShell 4

20:39if you want to take advantage of some of these cool features.

20:40So we'll look at how to do that in our Installation Nugget.

20:43In this CBT Nugget, I welcomed you to Power Shell 4

20:46Foundtions, and hopefully made the case

20:48for why we all need PowerShell skills here going forward.

20:51It's going to make us more efficient.

20:53We're going to be able to do things that we ever

20:54thought possible before we're going

20:56to be able to easily manage, configure, and automate

20:59our environments.

21:00We also defined what PowerShell is.

21:02It's an object-oriented command-line shell

21:04and scripting language based on the dot NET framework.

21:07And then we went over what we're going

21:08to cover in this course, which is all the foundations

21:11and beyond of PowerShell 4.

21:12And at the end here, we got familiar

21:14with the virtual environment that we're

21:15going to be working with for all of our labs and demonstrations.

21:18I'm extremely excited that you're

21:19joining me for this course.

21:20So again, thank you.

21:21We're going to have a lot of fun.

21:22We're going to learn a lot, and you're

21:23going to be extremely effective with PowerShell

21:25by the time we're done with this course.

21:27I hope that this has been informative for you,

21:29and I'd like to thank you for viewing.

0:00Installing PowerShell 4.

0:02So before we can start utilizing all these awesome features

0:05in PowerShell 4, we need to get it installed

0:07across the enterprise.

0:08And that can be a challenge, unless you're

0:10one of those lucky folks whose infrastructure's always

0:13on the latest version of Windows.

0:14So your servers are all up to date with Windows Server 2012

0:17R2, your clients are all up to date with Windows 8.1.

0:19Well, number one, you're golden, because you already

0:22have PowerShell 4 installed.

0:23Number two, we envy you, because, generally, that's

0:26not going to be the case.

0:27Generally, we're going to have clients all over the place, XP,

0:30Vista, 7.

0:30We're going to have servers all over the place, 2003, 2008,

0:332008 R2, and that's going to equate to PowerShell versions

0:37all over the place.

0:38So in this Nugget we're going to talk about all things

0:40PowerShell 4 installation.

0:41We're going to cover its requirements,

0:43where you can find it, its availability.

0:44Can we even install PowerShell 4 in older versions of Windows?

0:47And we'll even talk about a couple

0:48of features that, in newer versions of Windows,

0:51are turned on rather than off.

0:52Which just goes to show that Microsoft

0:54is very serious about making PowerShell more accessible

0:57right out of the box.

0:58And finally, towards the end of this Nugget,

1:00we'll get into the Virtual Nugget Lab,

1:01and I'll give you a demonstration.

1:02We'll look at some neat commands that we

1:03can use to, again, interrogate our network

1:05to see what versions of PowerShell are out there.

1:07And then we've got a legacy Windows 7.1 client

1:10inside of our domain, that's running PowerShell 2,

1:12so we'll look at the process for getting them up

1:14to PowerShell 4.

1:15So without further ado, let's begin.

1:17All right, everything you need to know about installing

1:19PowerShell 4, here it is.

1:21So for down level installs, and I'm talking anything prior

1:24to 8.1 on the client side, and anything prior to Windows

1:26Server 2012 R2 on the server side,

1:28you'll need to first install the .NET Framework 4.5.

1:32Then we can install WMF, the Windows Management Framework

1:364.0, which is where we find PowerShell

1:38and all kinds of supporting technologies around it.

1:41Now here's the thing, WMF, when you try to install it,

1:44doesn't actually check for .NET 4.5.

1:46This is a known issue.

1:47So if you install WMF before .NET 4.5, it'll succeed,

1:51but it won't actually do anything.

1:53So if you run into troubles, you can then install .NET Framework

1:564.5, and then just run through the installation of WMF 4.0

1:59again, and it'll succeed.

2:00Now here are the components of WMF.

2:02PowerShell 4, both the shell and the ISE,

2:04a couple of tools we'll be getting very familiar with.

2:06PowerShell Web Services, this is what

2:08allows administrators to expose commandlets

2:10via a restful endpoint.

2:11So developers can tap into these APIs

2:13and execute PowerShell commandlets remotely.

2:15It also comes packaged with WRM, Windows Remote Management.

2:18Now this is Microsoft's implementation

2:20of the WS-MAN protocol, which uses SOAP over HTTP and HTTPS

2:25for communication.

2:26And it's much more firewall friendly than, say,

2:30the computer name switch, which we're also

2:31going to talk about, how we can pass in a list of computers

2:34for a commandlet.

2:35That uses DCOM and RPC, which is not firewall friendly.

2:39So again, we're going to get heavily into this

2:41when we talk about remoting.

2:42We'll uncover the details here of the WinRM

2:45service and WS-MAN, and talk about how

2:47remoting works under the hood.

2:48And it's also going to be one your post-installation tasks

2:50if you want remoting to work across your enterprise,

2:53you're going to need to configure and enable

2:54Windows Remote Management, which is pretty easy to do here,

2:57through PowerShell.

2:58So again, more on that down the road,

2:59when we get into remoting.

3:00WMF is also going to upgrade WMI so it's

3:03compatible with PowerShell version 4.

3:05And then we get that sweet new feature here,

3:08called Desired State Configuration,

3:09it's going to install the components,

3:11so we can utilize that.

3:12And, again, we're going to take a big look at DSC

3:15down the road, as well.

3:16Now let's look at PowerShell 4's availability.

3:18Is it supported, and by what operating systems?

3:20Now, again, Windows Server 2012 R2 and Windows 8.1, it's

3:23installed by default, there's nothing you need to do.

3:24It's already got .NET 4.5, it's already got PowerShell 4,

3:27so you're ready to go.

3:28Windows Server 2012, you will need to install .NET 4.5,

3:32and then, again, you can install WMF 4.0.

3:35Windows 8, it is unsupported.

3:37So the only way, if you're on Windows 8, to get PowerShell 4,

3:39is to upgrade to Windows 8.1, and then you'll be ready to go.

3:43And again, that is a free upgrade.

3:44Windows Server 2008 R2, you will need to install SP1 and .NET

3:504.5, and then you can install WMF 4.0.

3:52And the same goes for Windows 7, install SP1, then .NET 4.5,

3:57then get WMF 4.0.

3:59For everything else, you guessed it,

4:01PowerShell 4 is unsupported.

4:03Now here's another view, this just kind of

4:05gives us the bigger picture here.

4:06And this is a great chart for reference,

4:08if you ever have any questions around PowerShell 4's

4:10availability.

4:11This will give us our default PowerShell version

4:13across all the relevant versions of Windows,

4:15and the supported versions of PowerShell

4:18across all these versions of Windows.

4:20It's also going to show us our default settings, for execution

4:23policy, and remoting.

4:25These are two very important areas,

4:26because they're going to determine whether or not

4:28you can execute scripts on the machine,

4:30and if you can execute PowerShell commands remotely

4:34across one or more machines.

4:35Again, these are your two big post-installation tasks

4:38right here, setting up an execution policy for scripts,

4:41and configuring enabling remoting.

4:43Both of these we'll look at down the road.

4:44We've got a couple Nuggets for scripting.

4:46The first thing we'll do is work with execution policy

4:49and get an understanding of what all these options are.

4:51And then first thing we'll do we get into remoting

4:53is learn how to configure and enable them.

4:55But notice one thing here, Windows Server 2012 R2, yeah,

4:58remote sign-in enabled.

4:59These are on by default, which is, again, just awesome,

5:02because it makes it more accessible and easier

5:04to work with.

5:05And also notice with Windows Server

5:062012, remoting was enabled.

5:09So that's a big deal.

5:10But also notice, Windows 8.1, remoting is disabled,

5:13Windows 7, remoting is disabled.

5:14So we've got two client machines in our network

5:17right now with remoting disabled.

5:18And that's going to come in the play

5:20here shortly when we get in and do a demonstration.

5:22So how do we figure out what version of PowerShell

5:24we currently have running on our system?

5:26Well, there's a bunch of ways to do it, as is the norm here,

5:29with PowerShell.

5:30But one common way to do it is to run

5:32what's known as an automatic variable here.

5:33Think of this like an environment

5:35variable for PowerShell.

5:36PS version table.

5:37We execute that, it's going to give us

5:39back a bunch of information, but the first item

5:41that it's going to return here is our PowerShell version.

5:44You can also run dollar sign host,

5:46which will give you a bunch of host information,

5:47including the version of PowerShell.

5:49But what we want to do now is head into the Virtual Nugget

5:51Lab, and let's take PS version table

5:54and turn it into a command that we can execute

5:56across the entire network, all the machines in our domain,

5:59using remoting.

6:00This is going to be really neat.

6:01And then we'll take a look at the installation process.

6:03And we'll even talk a little bit here

6:04about how to install it across the enterprise.

6:06All right, so we're in the Virtual Nugget Lab,

6:08we are on CL8 Nugget.

6:10This is our client machine for Windows 8.1.

6:12And what I want to do first is just show you

6:15where you can find all the files here, for this course.

6:18So on FS Nugget, our file server,

6:20I have a share there called PSV4.

6:22What we're going to do is build this out as we go.

6:24So right now we're in 0.2 installation.

6:26Every command inside of here, we will put inside

6:29of commands.ps1.

6:30Unless it's a script that does a specific thing,

6:32I'll store them all inside of this.

6:33So every command we do inside of this course

6:36will be accessible here inside of these files.

6:39So there will be a folder per Nugget,

6:41and then we'll even have kind of support folder

6:43here with all the installation files that you'll need.

6:45And if you don't have access to the Virtual Nugget Lab,

6:47don't worry, upon course completion I'll wrap this up

6:49and we'll make it available via our Nugget Lab files

6:52on the course page.

6:53All right, so let's fire up PowerShell here.

6:55You always want to run PowerShell as an administrator,

6:57otherwise it won't function as you expect it to.

6:59And let's go ahead and check out the version here

7:01on this machine.

7:01So again, we're on Windows 8.1 client right now.

7:04And you can see our PowerShell version, 4.0,

7:06so we're good to go on this machine.

7:07Now what if we wanted to check out all the other machines

7:09in our network?

7:10Does that mean we have to RDP into those machines

7:12and do the same thing?

7:13No, and that's what I want to show you here.

7:15But first, before I show you that,

7:16let's do a PS version table on our Windows 7 client here.

7:19We can see that we are on PowerShell version 2.0.

7:21So this is a machine that we're going to need

7:23to upgrade to get it to 4.0.

7:24But let's head back to our 8 machine here, and watch this.

7:32Now you're probably thinking to yourself,

7:34what the heck is that?

7:35We haven't even talked about commandlets or commands yet.

7:37And don't worry.

7:38We're going to get to that in Getting Started,

7:39we'll talk all about commandlets, their structure,

7:41get familiar with their syntax and such.

7:42I just wanted to show you something cool,

7:44to give you the idea of how powerful it is,

7:46and how we can do so much with so little.

7:48So here, we're using remoting via the invoke command

7:51commandlet.

7:52We're passing it a list of computer names

7:53that we want to send this command to,

7:55and then we're using the script block parameter

7:57and passing in the actual command

7:59that we want to execute.

8:00So it's going to send this command to all these machines,

8:03get all that data, bring it back, and give it

8:05to us right here on our local machine, which is really cool.

8:08Now the one thing I want to point out,

8:09though, is remember, Windows 7 and Windows 8,

8:12remoting is disabled by default. So this could bring back

8:15some errors, and it will bring back

8:16some errors, because we didn't configure remoting yet.

8:19But DCNUGGET, APPNUGGET, FSNUGGET,

8:21those are all 2012 R2, so we should get all their versions

8:24sent back to us.

8:25So I'm going to go ahead and hit Enter,

8:26and it's going to think about it for a second,

8:28send those commands over the wire,

8:29and they're going to come back.

8:30And look at that, CL8 Nugget failed with the following error

8:33message.

8:34And then it succeeded on these three,

8:36and it's still trying to hit CL7.

8:37We'll get that error message shortly.

8:38But how cool is that?

8:41That we could sit on one machine,

8:44send a command to all those machines,

8:46and get a response back from them.

8:47And there's our CL7.

8:48So CL7 Nugget and CL8 Nugget, because remoting

8:50is disabled by default, it didn't work on those.

8:53But it did work across all of our servers.

8:55Here's another really cool one.

9:01Can anybody guess what this is going to do?

9:03Notice we took that static list of computer names

9:05that we had up here out, and then we

9:06replaced it with another commandlet

9:08called Get ADComputer.

9:09Yeah, you guessed it.

9:10This is going to read all the computers in Active Directory.

9:13Pretty cool, right?

9:14And extremely powerful for something

9:16that we're doing in one line.

9:17And if I hit Enter, there you go.

9:19It's going to go ahead and read from Active Directory,

9:21and then we're going to get the same response here.

9:23So the three servers that are in Active Directory, great,

9:25but the two clients that are in Active

9:26Directory, because remoting isn't enabled,

9:28are going to come back with an error.

9:30All right, so we know that our three servers are good,

9:32they all PowerShell version 4.

9:34We know that our CL8 Nugget is good,

9:36because we ran a PS version table right

9:37on this machine here, we know that that's OK with 4.

9:40And we know that our CL7 Nugget, which is right here,

9:44is on PowerShell 2.

9:45So the first thing you want to do on your legacy operating

9:47systems is, make sure that you have the requirements.

9:49Since we're on Windows 7, those requirements are going to be

9:52.NET Framework 4.5, as well as Service Pack 1.

9:56Now, check this one out.

10:02Can you guess what this one's going to do?

10:04Yeah, it's going to query the operating system through WMI,

10:07to see the operating system version and the service pack

10:10version.

10:11Let's hit Enter.

10:11Look at that.

10:12So we're on Windows 7 Professional, Service Pack

10:15major version 1, so we're good to go there,

10:18we meet that requirement.

10:19Now we could also query the registry to find out if we have

10:21the .NET Framework 4.5 installed.

10:23In fact, let me show you this, only through the ISE.

10:25And we could fire up the ISE down here,

10:28we could run Windows PowerShell ISE, or we just type

10:30in ISE here in the command shell.

10:32And there it is.

10:33And what I'm going to do is just open up that command script

10:34I was telling you about here.

10:36So, all right, and we'll just hit up our file server here.

10:40There we go.

10:41There is the directory for this Nugget,

10:42and there is, commands.ps1.

10:43So let's open this up.

10:44Now, again, this is PowerShell 2's ISE.

10:46And don't worry, we're going to get a nice tour of all

10:48the tools, and we'll get very familiar with PowerShell 4's

10:51ISE, which is much nicer.

10:52But here are the commands that we were just running,

10:55there's your version check, here's your operating system

10:57and Service Pack check.

10:58And here, if you want to query the registry to see what

11:01version of .NET, you could do that.

11:03But we're just going to do a like on the end of this to see

11:05if we're running .NET 4.5.

11:07So if we execute our highlighted selection there,

11:10it's going to return false, meaning we do not have .NET 4.5

11:14installed.

11:14All right, now our next step is to get the .NET Framework 4.5

11:18installed.

11:18Here is the URL, I'll give you the short URLs for these

11:20as well, for the .NET Framework 4.5.

11:22This is for the offline installer.

11:24I also have the web installer inside of our installation

11:26directory here, but we'll talk about why you'd use one

11:29over the other here, shortly.

11:30And then here is WMF 4.0.

11:32I'm going to go ahead and run through installation here,

11:34so let me go ahead and just close out of this.

11:37Head into our directory, head into installs, and here's

11:39what we get.

11:40So here's the web installer.

11:42Here's the offline installer.

11:43These are both for .NET 4.5.

11:45And when you go to the WMF page, you'll

11:46have the option to download one of these.

11:48These are the 64 and 32-bit versions for client operating

11:51systems, and then there is the 64-bit version

11:53for server operating systems.

11:55So first things first, let's get .NET 4.5 up and running.

11:58I'm just going to use the web installer.

12:00And I'm not going to make you watch me run through all this,

12:02I'll run through it really quick here.

12:06And there we go, .NET 4.5 successfully installed.

12:09Now let's do the same thing for PowerShell here,

12:11and we are on Windows 7, 64 bits,

12:13so we're going to run this one right here.

12:15So let's go ahead and run this.

12:16WMF 4.0, we'll do the same thing here.

12:18I'm going to go ahead and choose Yes for the updates.

12:20And here it is.

12:21So, again, I'm not going to make you sit here

12:23and walk through this.

12:24So I'll fast forward through all this stuff,

12:26and when we're done, we should have WMF 4.0 installed,

12:28which will have PowerShell 4.

12:29We'll do a restart, and we'll be ready to rock.

12:34And there it is, WMF 4.0 installed.

12:36So all we need to do is restart, and we

12:38should be ready to go with PowerShell 4

12:39here, on our Windows 7 machine.

12:41And we're back from our restart.

12:42Let's see if everything worked out.

12:44Let's run PowerShell as an administrator here.

12:46And we'll run our handy dandy automatic variable

12:49called PS version table.

12:50And it should say version 4.

12:52And look at that, we're on version 4.

12:54If we fire up the ISE, this should also be on version 4.

12:57You can already tell the splash screen

12:58looks a little more modern.

13:01And you can see when it opens up,

13:02it should look a lot different as well.

13:04And there it is.

13:05So here we go, we've got the latest version of the ISE

13:07on here, as well.

13:08Excellent.

13:09So everything worked out, and I should also

13:10mention that PowerShell can run side by side

13:12with other versions.

13:13But now, by default, everything is

13:14going to run through version 4.

13:16Now the last thing I want to mention here

13:18is installing PowerShell 4 across the enterprise.

13:21Let's head back to our share here, on FS Nugget,

13:23and let me show you a few things.

13:25There we go.

13:26Now here's the scenario.

13:27Let's say you've got 100 Windows 7 machines out there.

13:30You want to bring them all up to PowerShell 4

13:32so you can manage them remotely.

13:33Are you going to go and log into every one and do it?

13:35Hopefully not.

13:36Here's what you'll do.

13:38First, you'll download your installers.

13:40Put them on a network share somewhere.

13:41And this is where you'll want the off-line installer for .NET

13:444.5, just in case you have machines out there that do not

13:46have internet access.

13:47So get the .NET Framework 4.5 offline installer on a network

13:52share.

13:52Then get your WMF 4.0 installers on a share

13:55as well, for whatever architectures and versions

13:57of Windows you want to support.

13:59Then, once you have that in place,

14:01it's just a matter of choosing your deployment method.

14:03There's a lot of ways to do it.

14:03You could use System Center Configuration Manager,

14:06or a nice cheap easy free way, assuming

14:09you've already paid for Windows to do this,

14:10is using group policy.

14:13In fact, I've got a batch script in here that will do just that.

14:16So the first thing you'll do is create

14:18a group, put all those machines inside of a group.

14:20Then create a GPO, and as a shutdown script,

14:22you'll specify a batch script like this.

14:24A very simple batch script.

14:26The first thing it's going to do is query the registry to see

14:28if we have .NET 4.5 installed.

14:30So you may have some machines that do,

14:31some machines that don't.

14:33If they don't, this will install it for them.

14:35Because it'll come back with an error level of one,

14:37and then it'll run down here and install .NET 4.5 from

14:41the offline installer that share in quiet mode with no restart.

14:44Because we're doing this in a shutdown script,

14:45no need to do any sort of restarting.

14:47Then we'll check for WMF 4.

14:50If that comes back false, then it will install WMF,

14:53and it'll check the processor architecture

14:55and install the right one for Windows 7.

14:56See, we're not incorporating any servers in here,

14:59because we're saying this for a Windows 7 scenario.

15:01But this will install the 32-bit one, if we're on x86.

15:04It'll install 64-bit if we're not.

15:06And that's it.

15:07That's a great way to do it.

15:08So PowerShell does not like to update itself yet.

15:11Hopefully we'll get better support that down the road,

15:13but for now we need to resort to archaic methods

15:16to pushing it across the enterprise in one fell swoop.

15:19But if you only need to install it across a couple of machines,

15:21very simple to do.

15:22Just remember, .NET Framework 4.5 first, WMF 4.0 second,

15:27and you're golden.

15:27So there you go, everything you need

15:29to know to get PowerShell 4 up and running

15:31in your environment.

15:32I hope that this has been informative for you,

15:34and I'd like to thank you for viewing.

0:00Getting started.

0:01In this Nugget we're going to begin getting familiar

0:03with the tools of the trade.

0:04So we'll look at the PowerShell console, as well as

0:06the PowerShell ISE, the Integrated Scripting

0:08Environment.

0:09We'll begin by clearly defining the purpose

0:11of each one of them, and then we'll

0:12jump in and get some hands-on experience.

0:14I'll show you how to configure them.

0:15Always the first thing we should do in these tools

0:17is configure and customize them to make them comfortable.

0:19Make them feel like home.

0:21And then from there we'll look at how to navigate around

0:23in these tools, and we'll even get familiar

0:25with executing commands.

0:27Let's begin.

0:27The first tool we'll be getting our hands on in here

0:29is the PowerShell console, pictured here.

0:32What I like to call the Blue Screen of Love.

0:34Because we already have a Blue Screen of Death,

0:36now we get a Blue Screen of Love.

0:38Which is kind of funny because the first thing I do whatever

0:39I get into PowerShell the first time

0:41is change the color scheme.

0:42I'll show you how you had to do that when

0:44we get into our demos.

0:45But this console is great because it's small.

0:48It loads quick, and it's really meant for quick work.

0:52Troubleshooting, diagnosing issues.

0:54You're going to eventually have a pocket

0:56full of go-to commandlets.

0:58And whenever something goes wrong,

0:59you're going to break out PowerShell, no matter

1:01where you are, and you're going to run those commandlets,

1:03get some information, diagnose the problem,

1:04and be on your way.

1:05Or maybe expand that to multiple commandlets all piped together.

1:10Stuff we'll get into.

1:11But this PowerShell console is great for just that.

1:14Quick work, troubleshooting, not for building

1:16big, complex scripts.

1:17And the reason is because it doesn't really

1:19give us a lot of assistance.

1:20This is not a good learning tool simply

1:24because it's a chore do anything.

1:26Copy and pasting, a chore.

1:27Navigating around, a chore.

1:29But we can make it a little better

1:31here with some key strokes.

1:32By learning how to become efficient here

1:35with the keyboard and the console,

1:36you'll become a wiz in no time.

1:38The other thing I want to mention

1:39is this may be your only option.

1:41Server Core, anyone?

1:42Yeah, there's no GUI in Server Core.

1:44So it's still going to be beneficial to learn

1:45how to get around the console, and really by having both

1:49of these tools in your pocket is the ideal way

1:51to go about PowerShell.

1:52The second tool you'll be getting familiar with here

1:54is the old ISE, the Integrated Scripting Environment.

1:56Now this is a great tool.

1:57You can use a lot more than what it's intended for.

2:00Its intended to be a tool for developing and debugging

2:03scripts, but you can also use it as a learning tool

2:05because it has so many cool features built in.

2:07Productivity features, things like IntelliSense,

2:09Tab Completion, Auto Complete.

2:11It's got everything in it.

2:12And by the way, Intellisense-- one

2:14the greatest features ever-- the fact that we get it in here

2:16is great because you can easily take out all the guesswork when

2:20you're doing things like finding commandlets, or finding

2:22parameters, or finding values for parameters,

2:25it helps out immensely.

2:26And of course, it's a modern tool.

2:28It's not the command line.

2:29So it feels like a real modern experience when

2:32you're working inside of it.

2:33So this will definitely be your preferred tool

2:35for doing anything that isn't quick.

2:38Essentially anything that you don't just

2:39need to get in and get done, you'll be using the ISE for.

2:42Now if you want to get very efficient in both

2:43of these tools, I'd advise getting familiar

2:45with the shortcuts.

2:46So here are the shortcuts for the console,

2:48here are the shortcuts for the ISE,

2:50and I'll be pointing these out as we go.

2:52With that, let's jump into the Virtual Nugget Lab

2:54and give familiar with these tools.

2:55We'll get them configured, show you how to navigate around,

2:58and we'll execute some commands.

2:59Here we are in the Virtual Nugget Lab.

3:01We are on our Windows 8 client machine.

3:03Now the first thing you need to do is launch PowerShell.

3:06How can you do that?

3:06Well, if you're lucky enough to have a shortcut in the Task

3:08Bar, that's all you need.

3:09You can right click on it even, and launch the PowerShell ISE

3:12from the regular console shortcut.

3:15Just keep in mind anytime you launch PowerShell, ISE,

3:17or console, run them as an Administrator or things won't

3:21work as you expect them to.

3:23Now if you don't have this down here-- in fact,

3:25let's just go ahead and unpin this-- what do you do?

3:28Well, just do a search for it.

3:30Here we go.

3:30And if you're on Client Operating System,

3:32chances are you'll have both 32 and 64-bit version.

3:34So choose the version appropriate for you.

3:36And then right click and pin it to the Task Bar.

3:39You can even pin both of them if you'd like to.

3:41So there we go.

3:41We've go them both pinned to the Task Bar

3:42and we're ready to rock.

3:43Let's launch PowerShell.

3:44Remember, give it a right click to run it as an administrator.

3:47And we're logged in as Domain Admin

3:49here, so we didn't actually have to do that,

3:50but you can verify other way by just checking if administrator

3:53is up there in the Title Bar.

3:55Now notice the font size, extremely small,

3:57we're going to want to fix that.

3:58Color scheme, that's all a matter of preference.

4:00But I'll show you how to change that.

4:02And then I never like where it puts the window.

4:05It always puts it at 0, 0, 0, left, 0, top.

4:08I like it kind of in the middle here.

4:09So it's nice and centered, and we can see the Desktop.

4:12But notice-- this is kind of neat.

4:14Once you do this kind of thing right here,

4:15change it around, move it around,

4:17now when we go into Options, it's

4:18actually going to pick up those settings and we can apply them.

4:20So to get into the settings for the shell,

4:23just click on the Control Menu, and go to Properties.

4:25Let's just highlight some of the important ones

4:26here on the Options Tab.

4:27Quick Edit Mode is important because that's

4:29going to make copying and pasting

4:30feel a lot less archaic.

4:32You know what I mean.

4:33Without this on, you're going to be stuck going through the Edit

4:35menus to mark and copy and paste,

4:37and it's a huge time sink.

4:38So make sure that's turned on, then you can highlight,

4:40right click to copy, right click to paste.

4:42Makes it very easy.

4:42Insert Mode, we want this turned on as well, because whenever

4:45we type, wherever our cursor is, it's

4:47going to insert those character rather than overwrite anything

4:49to the right of the cursor.

4:51So those are good.

4:51Let's add to font.

4:52Let's absolutely increase the font size.

4:5416, 18, 20, whatever is comfortable for you.

4:57We'll put ours at 16 here.

4:59On the Layout Tab, the buffer size,

5:01this is how many characters are stored in memory.

5:04For the width, it's on a line.

5:06So it'll go this way until it runs out of memory,

5:09and then it'll push on to the next line.

5:11Height is going up and down.

5:13How many lines it stores in memory.

5:14Now the really important thing here comes with window size.

5:17Width and height, that's obviously just the window

5:19size that we have here.

5:20But if your widths are off, especially if your screen

5:23buffer size is larger than your window size,

5:25then you're going to get a horizontal scroll bar.

5:27And that's going to make working in here very difficult.

5:29So just make sure that your widths line up.

5:30And then all the rest of the stuff

5:32is pretty straightforward.

5:33And notice this was 0, 0, but I moved it

5:35before I came in to here.

5:36So it put our left at 211, and our top at 113.

5:39So that's good.

5:39So our window will show up right here.

5:41And finally, the Colors Tab.

5:43Here's where you can again, set up your color preferences

5:46for our background texture.

5:47If we want to make another, let's just change

5:49this to how about a 60, 60, 60.

5:50This will give us a nice, gray background here.

5:53And then for the text, let's make some orange text here.

5:55Let's go 255, 200, and let's go 110?

6:00110.

6:01Looks good.

6:01There we go.

6:02So we're good.

6:03Let's hit OK.

6:04There it is.

6:05Now if you don't like how that turned out-- like,

6:07ours a little off the screen here--

6:08you can just go back in and change them.

6:10But watch this.

6:11I like how this is, it was just positioned

6:12a little funny there.

6:13So let's move it back.

6:14Now if we were to close out of this and watch it again,

6:17it remembers the settings.

6:18It doesn't remember that we moved it here,

6:19because we didn't go back in.

6:20So if we do this, go back into Properties,

6:23head over here to Layout.

6:24And just verify it looks good.

6:26Hit OK.

6:26Now if we close out of it and relaunch it, boom.

6:28We're good to go.

6:29Now all of those settings are stored in the shortcut.

6:31So if you want to give yourself a consistent experience

6:34across all of your PowerShell installs, what you can do

6:36is set up what's known as a Profile Script.

6:38And we're going to get into Profile Scripts down the road.

6:40We got a Tips and Tricks Nugget, which

6:41will go over all those random things that'll make

6:43your life easier in PowerShell.

6:44But what's really cool here is everything we just accessed

6:47in there is actually accessible through the automatic variable

6:49known as Host, which actually maps to the commandline Get

6:53Host.

6:53So this is great because this will

6:55allow us to programmatically do anything that you just

6:58saw on there, and then some.

6:59So we could do Host.UI.rawUI.

7:02Let's go to Window Title, for instance.

7:04Window Title-- I'm just going to use Tab Completion there

7:06to find Window Title equals super PowerShell ninja.

7:11Look at that.

7:12And we just changed the title.

7:14So what's great about this is now we can create a script.

7:16And we're going to get into scripting all that stuff,

7:18so we'll see how to do all this stuff.

7:19But we can create a script that contains all of our settings.

7:22Maybe when we create our own aliases, something else

7:24we'll get into, all kinds of things that we can do

7:26to pre-configure our environment.

7:28And then any time we launch it, it'll run that script.

7:30So again, profile scripts, down the road scripts,

7:34down the road, in general, we'll show you

7:36how you can do some neat things to make your life easier.

7:37And get a nice, consistent experience then

7:39across all of your PowerShell installs.

7:41Something you want to do, because if we

7:43were to close out of this-- ooh-- and then open it back up.

7:45Look at that.

7:45Our window title is gone.

7:46But all of our settings here in the local machine

7:48are fine because anything we did through here

7:51was stored inside of the shortcut.

7:52Let's do some PowerShelly stuff.

7:54We'll get some basics out of the way,

7:55and then we'll move into the ISE and we'll actually start

7:58doing stuff with Get Command.

8:00One of my favorite commandlets here in all of PowerShell.

8:02Now the first thing you're going to do, especially

8:04if you're a GUI person, when you get to this point right here,

8:07you're going to be like, uh now what?

8:09What's next?

8:10And that's where Get Command is going to come in handy.

8:12But for now, let's just go over some basics.

8:13Let's just type in a command here.

8:15Do something awesome.

8:17Hey, that's not a command.

8:18So this is what an error looks like.

8:20Get used to seeing the blood on the screen

8:22here, and trying to understand what it's telling you.

8:24But this is pretty much saying, do

8:26something awesome isn't anything that PowerShell can find.

8:28It's not a commandlet function script.

8:30It's nothing that I can do anything with.

8:31What about this one?

8:32Dir.

8:32Hey, we know that works.

8:34Dir.

8:35Everybody know what Dir is.

8:36Directory listing.

8:37So that got us a directory listing

8:39based on our current location here, which is our profile.

8:41Administrator dot in the Nugget Lab

8:43inside of the user's directory.

8:44Watch this.

8:44How about Dir with the recurse flag?

8:46What's that going to do?

8:47Or parameter?

8:48That's going to run through all the directories.

8:50Now here's the cool thing about PowerShell,

8:52Dir is actually what's known as an alias for something

8:55called Get Child Item, which is the same thing.

8:58If we run that, same thing as Dir.

9:00Here's the thing, a lot of these commands

9:01that we're used to are just aliases.

9:03They're just shortcuts on top of PowerShell.

9:06So a lot of things are just sitting on top

9:07of PowerShell commandlets.

9:08Here's the really neat thing-- and this

9:10is why the PowerShell team is so brilliant-- they made

9:13it comfortable for Windows users to pick up and do what they're

9:16used to doing, and they made it comfortable for Linux users.

9:18LS, right?

9:19That's a Linux command.

9:20Does the same thing.

9:21Those are both aliases on top of Get Child Item.

9:23And that's a command we'll look at down the road, because it

9:25is a very good one.

9:26Let's go over some of our characters here.

9:28Now the back to character is how we do multi-line entry.

9:32So if we hit Enter here, we're going

9:33to get the double command prompt there.

9:36This means it's waiting for more info.

9:37So we could do a recursor, we could Enter.

9:39We do add more parameters there.

9:40Keep hitting Enter.

9:41When you hit Enter twice or on a blank line,

9:45it's going to finish it and actually execute the command.

9:47We're going to get into all the other ones as well.

9:50Single quote, double quote, brackets

9:53are going to be important, parentheses

9:54are going to be important.

9:55All this stuff will be more important

9:57when we get into scripting.

9:58But for now, just know the back take there allows

10:00us to do multi-line entry.

10:02Let's clear our screen here.

10:03Let's do a little CLS.

10:05Or we could do a Clear, or we could

10:07do a Clear Host, which is the actual commandlet

10:09underneath both of those aliases.

10:11Now let's look at one of the greatest features

10:13here in the console, and that is Tab Completion.

10:15If I start typing something out--

10:16let's say I'm looking for a commandlet that will help me

10:18out with services here.

10:19In fact, let's just do a get SC.

10:20I can hit Tab and one, it'll fly through all

10:22the available options.

10:23But two, if I get one that's right up

10:25to where I'm looking for, for instance, Get Serve,

10:27I'll hit Tab, and it'll complete it for me.

10:29That's the one I wanted.

10:30So that will save you a ton of typing.

10:31And this works at all levels.

10:32This actually works at the parameter level.

10:34So I can type in D and hit Tab to iterate through

10:36all the potential parameters here

10:37that start with D. Let's see, I was looking for Display Name,

10:40which I just passed.

10:41Now I can hit Shift Tab to go backwards.

10:42There it is.

10:43Display Name.

10:44And first, before we do that, let's

10:45just execute Get Service here.

10:47Boom.

10:47There's Get Service.

10:48So it shows all the services on the system sent back to us here

10:51in the console.

10:52Now I can hit Up to recall my Command History.

10:55This is going to become a vital when

10:57you are building pipelines.

10:58Because you execute your commands, see what you got.

11:01And then you can start adding onto it.

11:02So let's do Display Name here, and I hit Tab.

11:04It'll complete it for me.

11:05Let's say we wanted to see all the services in here that

11:08start with WIN.

11:09We do WIN, you use the wild card character, hit Enter,

11:12and there they are.

11:13Now let's recall that commandlet.

11:14Say that we want it to sort this,

11:15because it's kind of all over the place.

11:17It's sorted right now by system name, or the name-- not

11:19the display name, but the actual name of the system

11:22name of the service.

11:23And then we've got status over the place.

11:25So if we wanted to do that, we could do a pipe.

11:27And we're going to get all into piping.

11:29Pipelines are a critical part of PowerShell.

11:32But we're going to pipe these results over

11:34to the Sort Object.

11:35And we're going to say, yep.

11:36We want to sort by status.

11:39Boom, there it is.

11:39Now we're sorted by status.

11:41Pretty cool.

11:42Another critical one here for getting started

11:44is Control-C, which cancels the execution of a command.

11:47That's important, because how many times

11:48have you executed a command and you're just sitting there

11:51staring at blank screen?

11:52This will help you out at ton here.

11:54And especially if we did something like this.

11:56Let's say that we did this.

11:58And we forgot to put our filter in there for Display Name,

12:01so we just do a Get Service.

12:03But we're going to do it across the network.

12:06We're going to run Get Service across all

12:08the computers in our network.

12:09Let's just do two here.

12:10Get Nugget FS Nugget.

12:11This will probably still come back pretty quickly,

12:13but if it didn't, we get a Control-C. Boom.

12:15It bombs out right there.

12:16See that?

12:16Before it even got to the end.

12:17And let's let it get to the end.

12:18There you go.

12:19There's the end.

12:19So Control-C is a life saver because it can get you

12:21control of the Console Back.

12:24So there's a quick tour of the console.

12:26I think those are the really important points

12:28for getting started.

12:29Customize it, make it feel comfortable,

12:31get familiar with Tab Completion,

12:33and also some of the critical ones there as far as history

12:36goes.

12:36And by the way you can always hit F7

12:37as well to view your history.

12:39All those keywords shortcuts I showed you in a previous slide,

12:41get familiar with all of those because they're

12:43a big, big, big help, and they'll save you a ton of time.

12:46Especially all the history ones, and then

12:48Control-C, obviously being a big one.

12:50And some of the navigation ones too.

12:51Like navigating around in here, you

12:53can go-- if you'll control down, it'll

12:54bounce back and forth between the words.

12:56See that?

12:56Those are super useful too when you have a big command you're

12:59trying to navigate around.

13:00A lot better than hitting left arrow a thousand times.

13:02So get some practice in.

13:03Just fire up PowerShell, type in a few commands.

13:06If you're don't not sure what commands to type in,

13:08we'll get a ton here at the end of this Nugget.

13:09Type those in, and just go through all of those keyboard

13:12shortcuts, just to start committing them

13:14to muscle memory.

13:14You'll thank yourself down the road

13:16because you'll be so much more efficient here in the console.

13:20Let's move on to the ISE.

13:21So again, the console is great here,

13:22especially for quick things for troubleshooting,

13:25when you just need to get something done.

13:27You're going to have a handful go to commandlets.

13:29And you're going to be able to write

13:30these long complex pipelines.

13:32The console is great for that.

13:33But the real power is in scripting.

13:35Especially when we're going to start

13:36automating lots of processes and integrating products

13:39together, and doing all that kind of stuff.

13:41You're going to want to work in the ISE.

13:43In fact, we're going to be spending

13:43most of our time in the ISE just because it's more modern,

13:46and there's a lot of great productivity features in it.

13:48So let's first launch it, right down here on the Task Bar.

13:51We'll launch this.

13:52Make sure you again, you run it as an administrator.

13:54And the first thing you want to do

13:55is customize the environment.

13:56You can do that in the Tools Menu here.

13:58Going into Options.

13:59So again, here's all your fonts here for the Script Pane

14:01and the Console Pane.

14:02We'll go over all these panes in here.

14:04But what you want to do first is just increase the font size.

14:06Let's again, put ours up to 12 so we

14:08don't have to strain when we're looking at this stuff.

14:11With that out of the way, let's go over all this.

14:13So this is your scripting pane.

14:15This is where we're going to be doing a lot of our work here.

14:16Like, Get Service.

14:17Here it is.

14:18Notice right off the bat, something amazing happened.

14:20It popped up with a list of all the valid values,

14:23based on what we typed in.

14:24This is IntelliSense.

14:26This is one of the greatest features that

14:28ever hit a development environment back

14:29in Visual Studio, and now we get it

14:31in PowerShells Integrated Scripting

14:32Environment, which is great.

14:34It's just going to save us a lot of time and guess work.

14:36And it'll save us on a lot of typing too.

14:38Because we can click these things,

14:39and it will type it up for us.

14:40You can still do Tab.

14:41It still supports Tab Completion and all that.

14:43But watch this.

14:44I hit a parameter-- a dash there for perimeter--

14:46it's going to pop up all the parameters in here,

14:48and even give us the data type that perimeter expects.

14:50We're going over parameter sets, parameters, data types,

14:53all different kinds of parameters

14:54here when we get into the Nugget following this one,

14:57Getting Help.

14:57We'll go over all that stuff and syntax.

15:00But this is awesome that it pops up

15:01with all the potential parameters.

15:03So here it is.

15:04Here's Display Name.

15:05And then we can start typing, and it's

15:06going to give us a valid values, in this case,

15:08of all the display names of the services.

15:10How cool is that?

15:11If we didn't want Display Name, we wanted the System Name,

15:14we can do Name, and look at that.

15:15Here's all the System Names.

15:16How cool.

15:17So let's do Display Name again.

15:18Just type display.

15:19I'll hit Tab there.

15:20And let's do WIN with our wild card,

15:23and now I'm going to run this.

15:24And what I'm going to do is highlight this.

15:26And I'm going to hit this button right here, Runs Selection.

15:29We'll talk about the differences of those in a minute.

15:31But this is your Development Pane.

15:32This is where you'll be writing code, and this is your console.

15:34Just like the same exact console that we were just working.

15:37In fact, you can even come down here

15:39and type in whatever you want.

15:40And you still get IntelliSense and Tab Completion.

15:42We can hit Enter, and there's all the services again,

15:44on the local machine.

15:45Now the other pane we have open by default

15:46here is the Command-AddOn Pane.

15:48And this is really nice.

15:49It's just a browser for all the commandlets on the system.

15:51And it even breaks it up by module.

15:53Now watch this.

15:53Let's say we wanted to find all the commandlets

15:54on the system that have to do with the computer.

15:56They have computer in the name.

15:57We just type in computer, and they're there.

15:59Let's say we only care about Active Directory commandlets.

16:02We could drop down and choose the Active Directory module.

16:04Again, we'll talk about modules as well in a future Nugget.

16:06Once you find what you're looking for, click on it,

16:08here's all the parameters.

16:10You Can hold your mouse over these fields,

16:11get a tool tip of the type, and whether it's

16:13a mandatory or optional parameter.

16:14And then you can fill this out, you'll get an insert

16:17and it will actually write the code for you.

16:19Pretty cool.

16:20But what I like to do is close out of this

16:21because it takes up valuable screen real estate.

16:23And you can always get it back here with the last button

16:26on the Toolbar if you need it.

16:27Now the other button here next to it

16:29is called Show Command Window, and this is great

16:32if you like to use the GUI for executing commands.

16:35So you can highlight a command here, Get Service,

16:37and we can hit Show Command Window.

16:38And here it is.

16:39So here's all the parameter sets.

16:40We'll cover those in a future Nugget.

16:43And here's all the parameters then for each parameter sets.

16:45Here's Computer Name, we use that with Get Service.

16:48And here's the Name.

16:49Here's Display Name.

16:50So this is again, the system name down here.

16:51Here's the parameter set for Display Name.

16:53You can put in Computer Name to all these.

16:55But this is great for learning.

16:56Obviously, we're trying to get away from GUIs with all this.

16:58But this is absolutely great for learning

17:01parameter sets and what parameters are expected

17:04for each parameter set.

17:05And again, the types.

17:06And you can just enter the values in here.

17:08And you can get a copy, it'll write the whole thing out

17:11for you, or you can hit Run as well.

17:12So fantastic.

17:14We'll definitely get back into Show Command in the future,

17:16just because it's such a helpful learning tool.

17:18Now let's go over some these other buttons.

17:20See this here?

17:21These are how we can control our real estate here.

17:25The one that it's on by default here is stacked.

17:27So again, Development Pane up here.

17:29Console Pane down here.

17:30We can put them side by side, if you prefer that.

17:32But what I really like to do is this right here.

17:34That way we get the full real estate.

17:36We can focus on just our script and writing our commands

17:40in here.

17:40And then your best friend when you're in this view

17:42is going to be Control-R.

17:43See that?

17:43You can just flip back and forth between Control-R all day long.

17:46And any time you execute anything anyway,

17:48it's going to flip over to that.

17:48Then you can hit Control-R to get back.

17:50Retype.

17:50So this is good because it gives you a lot more real estate

17:54to work with.

17:55A couple other buttons up here.

17:56This will launch PowerShell dot exe.

17:58Now notice it didn't pick up our preferences,

18:00because this launched literally PowerShell dot exe, not

18:03the shortcut where our settings are stored down here.

18:06So that's that.

18:07This is for remoting.

18:08This is going to be super useful because you pop this open,

18:11specify a computer name, and it's

18:12just like you're sitting on that computer.

18:14So you can have lots of tabs with all your computers open,

18:16and you can fire off commands individually, or just

18:18use the power of remoting send one command to all of them.

18:21So I can't wait to get into remoting.

18:22As you can tell, I love it because it's

18:23one of most powerful features here in PowerShell.

18:25These next three are all for executing scripts.

18:28So the Run Button, which is F5, will execute the entire script.

18:32F8 is the Run Selection, which is what I was doing here.

18:35So if you have a lot of commands in here,

18:36you can just highlight a command, hit F8,

18:38and it will only run that command, not the entire script.

18:40Then you have all of your standard productivity things.

18:42Redo, undo, your squeegee here, which

18:44will clear the command line, same

18:46is executing CLS or Clear Host.

18:48Cut, copy, paste, the modern day way, much easier to do in here.

18:53And then all your standard ones.

18:55So there you go.

18:56Now let's move on here and get familiar with Get Command,

18:59because this is the first thing you're

19:00going to want to do when you get into PowerShell

19:01is play a little bit.

19:02And this is the best command for learning

19:05how to learn in PowerShell.

19:06So let's get some space here, and let's just start typing.

19:08Get c o m.

19:10It knows what we're looking for.

19:12So we can Tab Complete that, and let's just run that by itself.

19:15First I'll highlight that, I'll hit F8, and there we go.

19:18A list of all the commands and functions here in PowerShell.

19:22That does not bring back any legacy Windows commands.

19:26Anything non PowerShell.

19:27To do that, we can just pass in a wild card.

19:30And what this'll do is the same thing,

19:31except it's going to go out and it's going to get,

19:34not only PowerShell stuff, but anything

19:36that's in the path environment variable too, which by the way,

19:40is anything inside of here.

19:41We can do environment colon path.

19:44Boom.

19:45There it is.

19:45So anything in those paths, it looked into

19:48and it's going to pull out.

19:49And by the way, PowerShell, any of those legacy utilities,

19:51anything that isn't a command letter,

19:53and it isn't in PowerShell as a function or an alias,

19:55all things we'll cover, is known as an application.

19:57And that's why you see all these here

20:00are tagged as applications.

20:01Look at them all.

20:02Tons of them.

20:03But we can use Get Command to find anything.

20:05We can use it to find again, PowerShell specific things, we

20:07can use it to look for utilities, anything.

20:10In fact, say we did want to just look for commandlets.

20:12Well we've got a parameter for that.

20:15It's called Command Type.

20:16Here it is.

20:16It's base, and look at that.

20:18We can find anything here.

20:19We can find an alias, commandlets.

20:21So if you want to see all the aliases here in the system,

20:24we'll highlight it, hit F8.

20:25Look at that.

20:25There's all the aliases in here.

20:27Let's see if we can find Dir up here.

20:29And I see it.

20:29There it is.

20:30Dir.

20:30[INAUDIBLE] forget child item.

20:32Pretty cool.

20:33Delete for remove item.

20:34So that's a great way to do it.

20:36And then we could also say, we just

20:38want to see everything that's a commandlet.

20:39We can type in Commandlet here.

20:41C m d l e t.

20:43Hit F8, and here's all the commandlets in the system.

20:47Now let's say that we were looking for something specific.

20:50Like say, a service.

20:52Any commandlet that has to do with service.

20:54So let's do this.

20:54Let's type in Service with some wild card surrounding it.

20:56Highlight it, hit F8.

20:57And look at this.

20:58Every commandlet that has service in the name.

21:01Now notice something interesting there.

21:02We didn't actually type this right here.

21:04We didn't type in Name.

21:05Although this would give us the exact same result.

21:08That's because this is known as a positional parameter.

21:11Meaning it's a common parameter, as long as we

21:13put the value where it shows up in that parameter set,

21:15we don't have to specify the name.

21:17So it can save you on some typing there.

21:19Let's take this to another level.

21:20Let's say that we've got a lot of service stuff down here,

21:23but we really only care about services

21:25within Active Directory, because that's our ultimate goal here.

21:27We can type in module as a parameter, and type

21:30in Active Directory.

21:32Highlight it, hit F8, and look at that.

21:33Now we have everything that has to do

21:35with service that's a commandlet inside of Active Directory.

21:38Now let's do another one.

21:39Now commandlets as you see here, have a verb now naming

21:43convention, which is just awesome for so many reasons.

21:46Number one, it makes it predictable.

21:47Makes it easy to find things.

21:49But it also makes it easy to do a search.

21:51A Google or Bing search, because there's nothing else out there.

21:54If you search for specific command on Google or Bing,

21:56you're going to get that help just for that command.

21:58So a lot of brilliant design decisions,

22:00as you're going to see as we go through this course

22:02with PowerShell.

22:02And just makes PowerShell a pleasure to work with.

22:05But watch this.

22:05Let's do Get Command and say we want to find everything

22:08with the verb get.

22:10Highlight it, hit F8, and look at that.

22:11There's everything with get in it.

22:13We could also do everything then with a noun of let's say

22:16service.

22:17Hit F8, and there it is.

22:19We've got one Get Service.

22:20That's the one we were looking for,

22:22and that's the one we were using up top there.

22:23Let's say we wanted to find all commandlets that have

22:26the computer name parameter.

22:28We can say parameter, computer name.

22:31Highlight, hit F8, and look at that.

22:33Here's everything that supports the computer name parameter.

22:35So you can see this is a very versatile a little

22:37search engine inside of PowerShell.

22:39Get Command.

22:40It's your friend.

22:41And remember, one of the things you

22:43can do when you're first learning this is just

22:45highlight it, hit Show Command.

22:47And now we can see all the parameters.

22:49These are both the parameter sets here,

22:50one for searching for commandlets, one

22:51for searching for everything.

22:53Here's all the parameters that we can use.

22:55Pretty cool.

22:56So we used up parameter name right there.

22:58You can even go to parameter type.

23:00Earlier we used a module.

23:01We used noun, we used verb.

23:02So we used a good amount of all the parameters

23:05here inside of the commandlets set parameter set.

23:09So that's a good way to get you started here.

23:11Just jump in, start playing with Get Command.

23:13You can do it either here in the console, or do it in the ISE.

23:17But do it in the ISE because you'll just get a lot of help

23:20with IntelliSense, and it makes it just a lot easier

23:23to work with and learn.

23:24In this CBT Nugget, we showed you

23:25how to Get Started with PowerShell, where we covered

23:27the tools that we're going to be spending all of our time

23:30in here, the console, and the ISE.

23:31We saw how to configure them, navigate around, and even

23:34execute some commands.

23:35I hope this has been informative for you,

23:37and I'd like to thank you for viewing.

0:00Getting help-- this is another one

0:02of those incredible features in PowerShell.

0:03The help system is great from so many perspectives--

0:06from installing it and keeping it updated to using it.

0:10It's comprehensive.

0:11It's simple.

0:11It's flexible.

0:12And if you're new to PowerShell, this Nugget

0:15is for you because this is how you're

0:16going to teach yourself how to learn everything

0:18there is to know in PowerShell.

0:20So in this Nugget, we're going to go over

0:21all of the things you need to know about the help system,

0:24and it's all wrapped in three commandlets-- Update-Help,

0:27Save-Help, and Get-Help.

0:28We'll even talk a little bit about syntax here,

0:30so we'll get familiar with parameter sets, different kind

0:32of parameters that commandlets support,

0:34and even talk a little bit about data types.

0:36And then we'll jump into the Virtual Nugget Lab,

0:37and we'll look at lots of demos to see the common ways to use

0:40help, and I'll even show you a couple of cool things

0:42you can do with the help system.

0:43Let's do it.

0:44The first commandlet we're going to look at here is Update-Help.

0:46Now, this is something that should

0:47be high in your post-installation checklist.

0:49In fact, the first thing you should do when you fire up

0:50PowerShell for the first time after installation

0:52is run Update-Help, and that's because PowerShell

0:55comes installed with minimal help information, just

0:57the bare bone information for all the topics,

1:00for all the modules here in PowerShell.

1:02And this is another brilliant design decision

1:04by the PowerShell team because by wrapping

1:05all of the operational side of help into a commandlet,

1:08they give us the power and flexibility

1:10to choose when and how we want to keep these help files

1:13updated.

1:13And it also obviously makes the download and installation

1:16much, much shorter.

1:17And because help is constantly changing, why wrap

1:19all that into the installation?

1:21So what Update-Help does is it will download all the latest

1:24information, all the latest help topics for all

1:27of the commandlets and the conceptual topics, which

1:30we'll talk about here shortly, in PowerShell.

1:32It's really cool how this works.

1:34This will actually do version checks for all the help topics

1:36and only download the differentials-- only

1:38the things that have changed since the last version

1:41for that help topic.

1:42Now, because Microsoft is hosting these help files,

1:45they do put some limitations in place,

1:47and that is, by default, Update-Help will only run once

1:51per 24-hour period on the machine

1:53that you run Update-Help on.

1:54So if you run it multiple times, any subsequent requests

1:56will be ignored.

1:57And there's also one-gigabyte limitation

1:59per uncompressed module.

2:01And, then of course, the other one

2:02is it does version checking.

2:04You can overwrite all three of those

2:05by using the force parameter in Update-Help.

2:07That will ignore version checking.

2:09It will ignore the one-gigabyte uncompressed content

2:11per module and the once-per-day limitation.

2:14Now, just to show you how easy this is,

2:16let me bring up a PowerShell command prompt.

2:18And I'm on my local production machine.

2:19This is not a machine that's in our virtual Nugget lab,

2:21so we'll do this again when we get into the virtual Nugget

2:22lab.

2:23But if we run a Update-Help, that's it.

2:25That's all you need to do.

2:26And I've already ran it on this machine-- today, in fact.

2:28So it's not actually downloading anything.

2:30It's doing version checking and moving on,

2:32and this will be very fast, see that?

2:33But if I were to run that with a force parameter,

2:35now it's going to go and actually download everything.

2:39So this would actually take a while to do

2:40because it's-- and these help topics are small for each

2:43commandlet, but it's still going to go out and download

2:44everything for every single module.

2:46So that's Update-Help.

2:48Now, the next we're going to look at here is Save-Help.

2:50So Save-Help is great because it allows

2:52us to save the help topics to the file system

2:55or to a file share somewhere.

2:57And this is going to be great for a couple of use cases,

2:58but the big one here is if we have client machines out there,

3:01say machine one and two here, that have restrictive internet

3:03access.

3:04Maybe they're behind a firewall or no internet access.

3:06We can still keep those machines' help topics updated.

3:09Actually, using the Save-Help commandlet is a breeze.

3:12We're going to call save-help.

3:13We can use the destination path parameter

3:15to specify exactly where these help files are going

3:17to get downloaded to, and then when we run Update-Help,

3:19well, they're going to use the source path parameter,

3:21pass in the share, and it will update that installation

3:25of PowerShell's help topics from the help in that share.

3:28Now, here's another great use case,

3:30and I would recommend setting up this process,

3:32because it's great for both connected and disconnected

3:35clients, and it centralizes all of your Update-Help operations.

3:38So let's say we've got a server out there

3:40that does have internet access.

3:41We could set up a PowerShell Java on that server

3:43to run Save-Help once a day, store it inside of a file share

3:47somewhere.

3:48Then, from our connected and disconnected clients,

3:50we could put an Update-Help pointing the, to that share

3:52inside of their profile script.

3:54So once a day, or any time when they

3:56launch PowerShell-- of course it will only happen once a day.

3:58But when they launch PowerShell, it'll

3:59go and get all the latest and greatest help,

4:02and that'll keep everything in sync

4:03across all the PowerShell clients in your network.

4:06We'll take a look at the script that does this from the server

4:08side, and we'll look at the profile script that does that

4:11from the client side once we get into, again,

4:13jobs and scripts later on in the course.

4:15On to the big one, Get-Help.

4:16So whether you're new or experienced with PowerShell,

4:18this is going to be your best friend,

4:19because this is how we're going to learn

4:21how to learn in PowerShell.

4:22Get-Help followed by the command will return the help topic

4:25for that command.

4:26We can also use help and man, which

4:29are aliases for Get-Help, but these pipe

4:31their other output, the help topic,

4:33to more, which will give us a paged view,

4:35rather than just spit out the entire topic

4:37and scroll us to the bottom.

4:38So when you're dealing with large help topics,

4:40it will help to use these, because we can go line

4:42by line through the topic

4:44Commandlet-?

4:45is the same as Get-Help for a specific commandlet,

4:47and it works the same as Get-Help.

4:49It just brings the whole topic, so it doesn't pipe it to more.

4:51You can also pipe Get-Help and commandlet to more,

4:54but help and man are great for that

4:56because they do it automatically.

4:57We also have about topics.

4:59These are great because it's essentially

5:00the documentation around all the core functionality

5:02and mechanics here in PowerShell.

5:04So I'll show you how you can find those and use them.

5:06And finally, you can use Get-Help as a search engine.

5:08So we just call Get-Help with a keyword,

5:10and it'll scan all of the full help topics

5:13and return us back things like commandlets and help files

5:16where that keyword shows up.

5:17Now, in order to become an effective learner PowerShell,

5:19we need to know how to interpret the help, and a lot of that's

5:22going to come down to understanding how

5:23to read syntax.

5:24The first thing you're going to do when you're learning

5:26a commandlet-- you want to know how to use it-- is you're

5:28going to look at the syntax to see what kind of parameters

5:31it supports.

5:31And understanding the different kinds of parameters

5:33and understanding perimeter sets will go a long way there.

5:36So let's start right there with parameter sets.

5:38Each commandlet has a number of ways that you can use it.

5:41Some of them have one or possibly more.

5:44Take Get-Help for instance; there's actually six or seven

5:46different parameter sets.

5:47I just included three in here.

5:49But a parameter set defines a specific way

5:51that we can use that commandlet.

5:53So here's how this works.

5:54Each parameter set has something unique about it.

5:56For instance, Examples has this example switch parameter.

5:58We'll talk about switch parameter shortly.

6:00But if we were to write a command that had the examples

6:01flag in it, for instance, get-help name of the help topic

6:04dash examples, we would be locked into this parameter set,

6:07and that's the functionality that we would get.

6:09If we were to write a very generic command,

6:11say get-help and followed by the name of the help topic, well,

6:14which one is PowerShell going to choose?

6:15These all have name in it.

6:16It would choose the first parameter set.

6:19And the All Users view for Get-Help,

6:21kind of think of it as the default parameter set.

6:23Because if we don't use anything specific in all

6:25the other parameter sets, then it's

6:27going to default here to the All Users view.

6:29It's also worth noting that you cannot mix and match these

6:31unique parameters across parameter sets

6:33because PowerShell won't know how to resolve the parameter

6:35set that you want to use.

6:36And just to give you an example of that,

6:37let's bring up PowerShell here.

6:39Let's say we wanted to get-help for say get-command.

6:42There's get-help for get-command, right?

6:44Let's say we wanted to see just the examples.

6:46I'm going to pipe this to more-- same as using

6:48Help rather than Get-Help.

6:49Now it's going to do it one line at a time, see that?

6:51So there's all the examples.

6:52I'm going to Control-C out of this.

6:53And let's say we wanted to add parameters in there.

6:56Now, we know this isn't going to work, right?

6:58Because we're mixing unique parameters

6:59across these parameter sets, so that should be parameter.

7:01And what parameter do we want to search for?

7:03Let's just put anything here.

7:04It doesn't matter because it's going to error out anyway

7:06and say the parameter set cannot be resolved using

7:08the parameters that we supplied.

7:10So those are parameter sets, and any time you launch Help,

7:13that's going to be the first area.

7:14Underneath Syntax, it's going to list all the parameter sets.

7:17In fact, let me just bring up PowerShell real quick

7:18once again.

7:19And let's do a help for Get-Help.

7:21Look at that.

7:21So since we did a Help, it's going

7:23to give us the paged approach starting from line one there.

7:25We can hit enter to go line by line through the help topic.

7:28But check this out; look at all these parameter

7:30sets in here-- lots of different ways to use Get-Help.

7:32And one thing I like about the online help-- notice back here

7:35I have these labeled with just one-word descriptions

7:39for these parameter sets.

7:40Well, let me Control-C out of this

7:41and add the online switch parameter to this command.

7:45It's going to launch a browser and take

7:46us right to the online documentation for Get-Help.

7:49And it's even going to launch us into the version

7:51that we launched it from.

7:52Look at that?

7:52It knew we were PowerShell Version 4,

7:54so it gave us the help topic for V4.

7:55If we were to launch this for Version 5,

7:57it would have taken us to this one.

7:58But here's what's cool about this.

7:59It actually adds the description for the parameter set.

8:02So we just used this one right here online.

8:04We used that unique parameter to this parameter set,

8:07so we were locked in to all these parameters,

8:09and that's what happened.

8:10Then it fired up the help topic here.

8:11We got that functionality.

8:13So this is great because it just allows you to quickly see

8:15what parameter set you'll need to use

8:17for whatever functionality you're looking for.

8:19Let's dig a little deeper into parameters.

8:21So parameters are how we pass data into a commandlet

8:24so it can perform its function.

8:25And when you're looking at syntax,

8:27you're going to see the name of the parameter, followed

8:28by the data type, the kind of data

8:30that you're going to pass into that parameter.

8:32And there's lots of data types out there-- strings, integers,

8:35dates, times, longs, Booleans, all these things

8:38that we'll see as we go throughout the course.

8:39But the most common one you're going to see by far here

8:41is the string parameter-- just passing in character data.

8:44But you may also see these open and closed brackets

8:46at the end of the data type.

8:48And that just tells us that this is accepts an array.

8:50It accepts multiple values.

8:51Take the computer name parameter, for instance,

8:53that we've used in previous Nuggets.

8:55We're going to specify the computer name parameter

8:57and specify computer name comma computer name comma computer

8:59name.

9:00That's specifying a list, a comma-separated list,

9:02that it's going to use to operate on all those machines.

9:05Now let's talk about the different kinds of parameters

9:07and all these brackets.

9:08Notice we have brackets over the place.

9:10We have brackets around just the parameter.

9:11Sometimes we have brackets around both the parameter

9:13and the data type.

9:14Sometimes we're missing brackets entirely.

9:16So let's start with positional parameters.

9:20You're going to see positional parameters are going

9:22to be the parameters that are going to be the most commonly

9:24used, and they're going to have brackets

9:25around just the name of the parameter--

9:27not the entire parameter, but just the name of the parameter,

9:30like name, for instance, with Get-Help.

9:32This means we don't have to actually supply

9:33the name of the parameter, and we've already seen this.

9:35We used this quite a bit here in PowerShell

9:37by just doing a get-help get-command.

9:40Notice that we didn't specify the name parameter.

9:44That is equivalent to this right here.

9:47So there it is.

9:48We can use either one of these.

9:49This, we're using it positionally.

9:51This, we're using it as a named parameter.

9:53So it's not a positional parameter,

9:55it's a named parameter.

9:56Every parameter is going to be one of those.

9:58And again, you're going to see name parameters for the most

10:00common parameters, and it's good because it saves you

10:02time, especially when you're just writing commands inside

10:05of the shell.

10:06As a best practice though, always

10:08specify names of parameters inside of your scripts,

10:11especially if you're working with other people.

10:13It just makes it much easier to work with, and it's very clear.

10:16Also worth mentioning, position the parameters are relative.

10:20Meaning, we can do this right here.

10:22Let's go back to our positional parameter,

10:25and let's just throw the example switch right here.

10:28First, notice we're using that first

10:29and then we're doing get-command.

10:31Yeah, it's still going to work because get-command-- or name,

10:34I should say-- is positional.

10:36So it was the first positional parameter that we used,

10:40and that's why it was OK to use.

10:42If we had other positional parameters inside of here,

10:45they would need to go in that order.

10:47So we would need to ensure, no matter where we put it,

10:49that the name parameter.

10:51If we didn't specify a name, would have to be first,

10:52and then so on and so forth.

10:54And I'll show you, when we get into deeper into the help

10:56topics here, how you can identify the position

10:58of a positional parameters.

11:00So that's positional parameters.

11:01It just simply means we do not specify the parameter name.

11:04So just a little great time saving

11:06feature there, especially either when you're fighting fires

11:09or when you're doing things like this, getting help.

11:10Who wants to type the dash name help topic

11:12every time they want to get help?

11:13Wouldn't it be better if we could just

11:14to get-help commandlet name?

11:15There you go.

11:16All right, so the next one we have here

11:18are mandatory parameters, and these

11:20are parameters that do not have brackets around anything.

11:25So, examples, for instance, is a required parameter inside

11:28of this parameter set.

11:29Parameter is a required parameter inside

11:30of this parameter set.

11:31So that's all mandatory parameters are,

11:33are ones that do not have any brackets around them.

11:36We also have optional parameters.

11:37Those are ones where you have bracket

11:39around both the name of the parameter and the data type.

11:42So full brackets around the whole thing

11:44just simply means it's optional.

11:46And we also have switch parameters,

11:47and those are parameters without a data type.

11:49That just simply means on or off.

11:50If you specify that parameter, it's on.

11:53By default, all switch parameters are off.

11:55Let's make sure we have this down.

11:57I'm going to quiz you, ready?

11:58Say it with me now.

11:59What is this right here?

12:01This is what?

12:02It is an optional positional parameter.

12:05It's positional because we have brackets

12:06around the name of the parameter,

12:07but it's also optional because we have brackets

12:09around the whole thing.

12:11Now, what about category?

12:13What's that one?

12:14That is a named parameter.

12:16That also accepts an array as a data type,

12:19so we can pass in multiple categories.

12:20But remember, if it's not positional, it is named.

12:23What about, let's do this one right here.

12:25What's that?

12:26That is a mandatory named parameter.

12:30What about this one right up here?

12:32Right, that's an optional switch parameter, cool.

12:34Now, there's one more parameter types

12:35that I want to mention here, and that's

12:36called partial parameters.

12:38This is another one of those time-saving features.

12:41So again, best practice, don't do this,

12:43especially if you're in scripts-- type everything out.

12:45But if you're just troubleshooting,

12:46you want to get things done quickly,

12:47or you know commandlets really well,

12:49this will save you some time.

12:50Partial parameters mean that we only

12:51need to type the parameter name up to the point

12:53that it's unique and PowerShell will know which one we mean.

12:56Just to give an example here, let's get back into PowerShell.

12:58If we were to do a get-service and we

13:00want to specify the computer name,

13:01usually we do this, right?

13:02We type the whole thing out and then pass

13:04in our list of computer names.

13:06We don't need to do that because there's only one parameter that

13:08starts with C. So we can do that,

13:10and we'll get the same exact effect.

13:12And here, just to show you how you

13:13can find that, let's do a help on get-service, and let's

13:17do a P. Look at that.

13:19I'm already using partial parameters.

13:20If we look down here, there's a-- oh, no, there's two.

13:23That wouldn't work.

13:24Look at that.

13:24There's path and parameters.

13:25We'd actually have to do par.

13:27There we go.

13:28Par is for parameter.

13:29And then let's just do a C*.

13:31We're wild card searching the parameters here

13:34for get-service, and it's only going to return one-- just

13:36computer name.

13:37That's it.

13:38So those are partial parameters.

13:39So that's interpreting Help.

13:40Understanding the syntax in all these different parameter

13:43types will help you immensely in teaching yourself

13:45how to learn PowerShell.

13:46And kind of my workflow, whenever

13:48I see a new commandlet, is I'll go to the Help topic for it.

13:50I'll look at all the different parameter sets,

13:52and then I'll start digging into the parameters themselves

13:55to understand what they all do and then look at some examples.

13:57It's a great workflow for learning how

13:59to use all these commandlets.

14:00With that, let's jump into the virtual Nugget lab.

14:02I want to show you how to use Update-Help, Save-Help,

14:03and the many cool things that we can do here with Get-Help.

14:06Welcome back to the virtual Nugget lab.

14:07Let's bring up the ISE here and let's open up our PowerShell

14:10file containing all the commands for this Nugget here, 04,

14:14getting help.

14:14So we'll open that up.

14:15Here's all the commands we're going to be working with,

14:16and we're going to start with updating help.

14:18Now, before we even run Update-Help,

14:19let's run Get-Help against Update-Help

14:21to see what we've got here.

14:22We'll run that selection, and you

14:23can see we just get the basic help topic here,

14:25a nice quick synopsis.

14:27We get our parameter sets listed here and a description.

14:30So we look at the differences between these parameter sets.

14:32Once has source path.

14:33That's what's unique to this one.

14:34So this is how we will run Update-Help

14:36against a copy of help that's been

14:38locally downloaded or downloaded on a file share somewhere.

14:41And then our second one here, the difference is literal path.

14:44So that's the difference.

14:44So we could get more information on those parameters

14:47by adding the detailed switch here,

14:49and we'll go over what all these mean here shortly.

14:51But detailed will give us the parameter description.

14:54So if we scroll up here, as well as examples,

14:56here are all the parameters.

14:57So now we can see here's our literal path.

15:00So this is different than the source path parameters

15:02because the value of literal path parameter

15:04is used exactly as it is typed.

15:06Then you can come down here and see the source path parameter

15:08as well.

15:09So that's Update-Help.

15:10Let's go ahead and run it here on this local machine.

15:12We'll highlight that.

15:13I'll hit F8, and that's going to go ahead and run Update-Help.

15:15So this is going to get our help,

15:17update it to all the latest content

15:19here on this local machine.

15:20So that's how we can Update-Help from the internet.

15:23What if we wanted to save help locally and then

15:25update it based on that path?

15:27Here's how we can do it.

15:28If we open up the directory here-- I

15:30made a directory inside of our Nugget lab files called Help,

15:32and right now it's empty.

15:34So if we run Save-Help and specify a destination

15:37path pointing to that directory on our file server,

15:40it's going to download help locally.

15:41So I'm going to hit F8 to run that.

15:43It's going to do pretty much the same thing we just saw.

15:45The difference being it's loading up this directory

15:47with all of the help topics.

15:49So now we could go ahead and run Update-Help and specify

15:52the source path parameter pointing to that directory,

15:55and it will Update-Help on that machine based

15:58on those help topics save there on the file share.

16:00Now, I mentioned the common thing to do

16:02is to automate this process, and there's

16:03a number of ways to do it.

16:04But the examples for the Update-Help help file

16:07actually show you how to do this.

16:09It's really cool.

16:10So let's just type in the example switch on Get-Help,

16:12and this will show us just the examples for Update-Help.

16:14And I'll show you a better way to navigate around here.

16:16It's painful doing this in the shell.

16:17Because if you click anywhere, you'll go back to the bottom,

16:19and it's just painful to find things.

16:21But example number four up here will actually

16:23show you how to Update-Help automatically using a job.

16:26So here's a job that will Update-Help for this everyday

16:30at 3:00 AM.

16:30And example number five shows you

16:32how to do it from a file share-- Update-Help

16:35on multiple computers from a file share.

16:36So it does a Save-Help, specifying

16:38the destination path-- exactly what we just did there.

16:40And then it uses remoting invoke command, computer name,

16:43passing in a servers.txt, which is just a text file that

16:47has a list for every computer that you want to update,

16:49and then the script block Update-Help at the source path,

16:51like we just did as well.

16:53So turning all that into a job on one machine

16:55will take care of everything you need.

16:56It will download the help file to your file share

16:59and then send the Update-Help commands to all the machines

17:01that you want to keep updated-- really nice

17:03simple way to do it.

17:04Let's move on to Get-Help.

17:06Remember I said you could use Get-Help as a search engine?

17:08Yes, it's very easy to do-- Get-Help

17:09followed by your keyword.

17:11Wild cards are supported here.

17:12If it doesn't find any specific commandlet to display help for,

17:16it'll display anything with that keyword in it,

17:18because this is going to scan all of the help topics

17:21for that keyword.

17:21And if I just run this selection here, check it out.

17:23So here's all the commandlets with variable

17:25in it, all the help files.

17:26This is a great way to find those conceptual about topics.

17:30So say we wanted to learn what automatic variables are all

17:32about.

17:33We could just do a help about_auto,

17:35and this also, by the way, supports tab completion.

17:38There we go.

17:38And I can hit Enter, and here it is--

17:40everything we need to know about automatic variables.

17:42And again, this is a huge topic, so scrolling

17:44will be quite painful.

17:45But if we get to the top here, you'll get a short description,

17:48and then the long description will

17:49list all of the automatic variables

17:51that PowerShell supports and what they do.

17:53So if we scroll down here, we can find host.

17:55We've used that one before, right?

17:56It contains an object that represents the current host

17:58application, and it allows us to control the properties

18:02of the host-- very, very cool.

18:04Now, here it is again, this time piped to more.

18:06The reason I wanted to show you this

18:08is because the more function is unsupported in the ISE.

18:10It'll always take you down to the bottom.

18:12But I'll show you how we can fix that when

18:13we get into functions.

18:14We'll write our own function that will paginate the output.

18:17What you can do in the meantime, though,

18:19and this is just great all around, is you show-window.

18:22Show-window is just fantastic because what it'll do

18:25is pop open the help topic in a separate window

18:28where we can find what we're looking for.

18:30So now we could easily find that host.

18:32Hit Next-- hey, there it is.

18:33There's host, and there's everything it does,

18:35and it'll highlight everything inside of here.

18:37So this is just awesome-- a great way, especially when

18:39you're learning, because this window will stay on top,

18:41so you can go over here and develop all day long,

18:43and you'll have the help topic right here

18:45to search through and find what you're looking for-- very,

18:47very, very handy feature there.

18:49Let's look at the many ways that we can use Get-Help.

18:51So let's say we want to learn all

18:52about the Get-Service commitment.

18:54We could run help get-service just by itself there,

18:56and this is going to give us very basic information-- just

18:58a synopsis, the syntax, a description, related links,

19:01commandlets, and remarks.

19:02If we wanted to get a little more detailed information,

19:05we could add the details switch, which

19:06is going to include parameters and examples-- just very

19:09basic parameter information.

19:10So let me scroll to the top here.

19:12We get, again, synopsis, syntax, description,

19:14but just basic information about each parameter, basically

19:16a description as well as the data type.

19:19And then if we scroll down, we get all the examples as well.

19:22So that's a great one.

19:23Let's see, what else do we got here?

19:24If we just want to see examples, as we saw,

19:26we can just run it with the example switch.

19:28And if we wanted full help, meaning detailed parameter

19:31descriptions, examples as well as notes

19:33and input/output types, we could use the full switch.

19:36And this is going to give us very, very detailed information

19:39here.

19:39And if I scroll down from parameters,

19:41you can see not only does it give us the description,

19:43but each parameter will have these five properties on it.

19:47This is a required parameter-- mandatory.

19:49Is it positional?

19:50If it's not positional, it'll be named.

19:51If it is positional, it'll have the number of position

19:54that it needs to show up relative to all

19:56of the other positional parameters.

19:58Default value-- see computer name here?

20:00If we don't type in anything, computer name

20:01will always default to the local machine.

20:03If it accepts pipeline input-- we'll

20:05talk about this more when we get into pipelining.

20:07And then if it accepts wild card characters--

20:09so great information here around each parameter.

20:11Not only does it tell us what the parameter does,

20:13but it gives us those properties around that parameter.

20:15If we scroll down here, let's see if we

20:17can find one that's positional.

20:18There it is.

20:19Look at that.

20:19Name, it's a positional parameter

20:21in the first position.

20:22Another really useful one here is the parameter parameter.

20:24This is a great way to discover what parameters are supported

20:28by a commandlet, and you can use wild card searches

20:31against this.

20:31So let's say let's see all the parameters that start with D

20:34for the get-service commandlet.

20:35I'll hit F8, and you can see we have two

20:37of them-- dependent services.

20:38This will only give the dependent services for whatever

20:41service you're looking for, and then display name,

20:43and this is we can specify the display name, rather than

20:45the system name of the service.

20:47Let's finish this up with a real world

20:49look at how to use Get-Help.

20:50So here's kind of the flow I go through when

20:51learning a new commandlet.

20:52The first thing I'll do is pop open

20:54that commandlet in show window.

20:55So now we have a nice Help window over here

20:57to the right, everything we know about that commandlet,

20:59and we still have our scripting pane over here on the left

21:01that we can use to play.

21:02And what I want you to do next is reverse

21:04engineer this command for me.

21:05Can you tell me what parameter set this command is

21:08using for Get-Service?

21:09We've got three over here in our help topic.

21:11Which one is this using?

21:12Well, the first parameter we're passing in

21:14as a positional parameters, so that's kind of a dead giveaway.

21:16Because if you look at these three,

21:18there's only one that supports positional parameters,

21:20and that is the first one.

21:21So we're using this, passing in a system name

21:23using wild card characters, and we're

21:25going to say, give us all the services that start with BI

21:27across both of these machines.

21:29So let's do that, and there they are.

21:31We've got two.

21:32But here's the thing, and we're going

21:33to get a little ahead of ourselves here

21:34because I want to do a little pipelining,

21:35but this is really neat stuff to get you moving forward

21:38and thinking about the future.

21:39Here's the thing, which machine are these running on?

21:42They're both stopped.

21:43What if one is running and one was stopped?

21:45How would we identify what machine is stopped

21:47and which one's running?

21:48Well, this is where pipelining can become very, very powerful.

21:52So we're going to pipeline that to

21:54the select-object commandlet.

21:56Again, we'll talk a lot more about this in the future.

21:58But I want to extract the machine name,

22:00and here we're pulling out what are known

22:01as properties of the object.

22:03This get-service is going to return us two objects.

22:06We're going to pass those objects over to select-object,

22:08and we're going to say, we want to pull out extra information

22:10that isn't in the default view.

22:12And that's going to be machine name status and, let's say,

22:14display name, just like so.

22:17And let's hit F8 to run that, and there it is.

22:19Now we have machine name.

22:20It's formatted a little funky, and here's status and display

22:22name.

22:23But we could fix that as well.

22:24Watch this.

22:25Let's go ahead and add to the end of this.

22:27Let's pipe all of that to the format-list commandlet.

22:31And now we get what we're looking for-- cool.

22:34So we're going to get all into objects and all

22:37into pipelining here in future Nuggets.

22:39Let's take that one step further.

22:41Let's say we want to do something

22:43with those two stopped services, like, how about start them?

22:46Well, thankfully, because of PowerShell's

22:48awesome verb-noun naming convention,

22:49we know if there's a get-service,

22:50there's probably a start-service.

22:51So let's bring up the Help inside of our Help window.

22:53Here we'll just do a Show Window Help on Start Service.

22:56So I'm gong to go ahead and execute that, and there it is.

22:58It loads up our Help here with Start service-- perfect.

23:00Now, there's three different ways to use this.

23:02One, is to pass in an input object.

23:05Hmm, that's interesting.

23:06Input object as a service controller also

23:10a positional parameter.

23:12So this is the data type here-- service controller,

23:14and we can pass in multiple services,

23:16and it just so happens that get-service returns service

23:19controller objects.

23:20So that's what we're doing right here.

23:22We're just running a get-service to get those two services, just

23:25like we did above, and we're passing those

23:27over to the start-service commandlet.

23:28So we're using this parameter set,

23:29and that's going to start those services for us.

23:31If we run this, and then we can head back and let's

23:34just run our previous get-service command here.

23:37Look at that.

23:38Now they're both running, as opposed to being

23:39stopped previously.

23:41What about the second way we could have done this here?

23:43Right here, by using display name,

23:45that's our second parameter set here is display name.

23:47It accepts an array of strings.

23:49Meaning it probably supports wild card characters.

23:52If we looked at the details for display name,

23:54we could scroll down here, find display,

23:56or we could just search for it.

23:57It probably would be a lot easier to do, right?

23:59Display name-- there we go.

24:00And we can see right-- here it is.

24:02Right here, one of the first ones--

24:04accepts wild card characters, true;

24:06position, named-- so everything we

24:08need to know about the parameter right there.

24:10And so we're just specifying the whole name,

24:12but this'll be the same thing.

24:12Also notice we're using a partial parameter for computer

24:15name because it is the only parameter that starts with C,

24:17but this would accomplish the same thing

24:19across those machines.

24:19It would start those based on their display name,

24:21rather than passing input objects.

24:23And the final one is pretty much how

24:24we've been using get-service, by just passing in the name,

24:27wild card character included, and that is, by the way,

24:30the default parameter set there.

24:31And if you were to do an online instead of show window,

24:34that would show us the exact same thing.

24:36It would show us these three parameter sets,

24:38only we'd get that nice name for each one.

24:40That's known as the default one when

24:42you work on the system name.

24:43Here's the input object parameter

24:44set that we were using, and here is the display name.

24:47So that's Help.

24:48Pretty cool, right?

24:49It can really help you learn how to use PowerShell.

24:52So my advice anytime you're learning anything

24:54in PowerShell, especially when you're learning commandlets,

24:56get into the Help, do a show window, and just start playing.

24:59Play with all the different kinds of parameter sets,

25:01get familiar with all the different kind of parameters,

25:02and definitely go through the examples

25:04because those can give you a nice head start on how

25:06to use commandlets.

25:07In this CBT Nugget, we saw how to get help in PowerShell.

25:09We covered the three help commandlets-- Update-Help,

25:12Save-Help, and Get-Help.

25:13We saw how to interpret the help by understanding

25:15syntax and parameter sets and different kinds of parameters

25:18out there.

25:18And we even did a demonstration in the virtual Nugget lab

25:20to show you how to use all three of those help commandlets.

25:23I hope this has been informative for you,

25:25and I'd like to thank you for viewing.

0:00Commands.

0:01In this Nugget, we're going to define what a command is.

0:03We're also going to go over the six different kinds of commands

0:06here in PowerShell, such as commandlets, applications,

0:08aliases, functions, scripts, workflows.

0:10So we'll define what all those are, and then

0:12we'll get into the Virtual Nugget Lab

0:13and we'll do some fun and useful things.

0:15I'll show you how to use Get-Command to search

0:17for commands of a specific type.

0:19We'll also get into aliases.

0:21Show you how you can use aliases,

0:22discover aliases, and even create your own aliases.

0:25At the end of this Nugget, I'm going

0:26to throw three challenges your way.

0:28Level 1, 2, and 3.

0:30Now that we're starting to build up

0:31that base of foundational PowerShell knowledge,

0:34I think it's a good time to start honing

0:36those problem solving skills.

0:38So at the end of Nuggets going forward,

0:39I'll give you some challenges.

0:41You can do them on your own.

0:42I'll also provide the solutions here in our Nugget Lab files,

0:45all right?

0:45So this will be a lot of fun, and it'll

0:47be a good way to get you involved,

0:48and start getting hands-on with PowerShell.

0:50Let's begin.

0:51Let's talk about commands.

0:52So in PowerShell we have six different kinds of commands.

0:55And command is really just a term used very loosely

0:58in PowerShell.

0:58Just think of it as an umbrella term

1:00that could be referring to any kind of command.

1:02Could be referring to a commandlet, an application,

1:05an alias, a function, a workflow, or script,

1:06and those are the six different kinds

1:08of commands that we have here in PowerShell.

1:10Let's start here with commandlets.

1:11Commandlets are the heart and soul of PowerShell.

1:14They are native PowerShell commands.

1:16They're internal, and specific, to PowerShell.

1:18Under the hood, commandlets are just simply compiled .NET

1:22framework binaries, such as .dll files.

1:24In fact, if you're a developer, or know a developer,

1:26they can easily write their own commandlets.

1:29So they'll use their favorite programming language,

1:31such as C# or Visual Basic, inside of their favorite

1:34development environment, such as Visual Studio.

1:36Build a commandlet compile it, give it to us.

1:38We can import it and then use it inside a PowerShell.

1:41The reason PowerShell is so awesome is

1:43because of commandlets, and the reason commandlets are

1:45so awesome is because of the .NET framework.

1:47And that's because everything is an object.

1:50Windows, it's an object oriented operating system.

1:52Visual Basic, C#, those are object oriented programming

1:55languages, and the .NET framework is an object oriented

1:58runtime of the deep type system.

1:59And if none of that makes sense, it will.

2:01We've got a Nugget dedicated to objects down the road.

2:04For now, just think of objects as these rich data structures

2:07that we can also do things with.

2:08And just to give you an example, I don't get too deep into this

2:10because we're going to get deep into it,

2:12but let's take Get-Service.

2:13We've actually used this commandlet many times.

2:16The Get-Service commandlet, if we

2:17were to call that and get back four service objects,

2:20we can then take those objects and pass them

2:22to another command.

2:23We can query those objects to get their state,

2:25those are known as properties.

2:27We can look at things like the name, the status, the machine

2:30name that they're running on.

2:31And then we could even do things with them right?

2:33We could start them, stop them, resume them,

2:35that kind of thing.

2:36So that's why commandlets are awesome,

2:38because they return objects that we can then do something with.

2:41So those are commandlets, and the more commandlets you know,

2:43the more you'll be able to accomplish in PowerShell.

2:45So my advice would be to try to learn

2:46at least one commandlet a day.

2:48Just read through the help file, get familiar

2:49with the syntax, the parameters.

2:51Go through a couple of examples and you'll

2:53be well on your way to mastering PowerShell in no time.

2:55The next command type we have here are applications.

2:57These are external commands.

2:58So all those utilities you were used

3:00to working with in the legacy command line, things

3:02like traceroute, ipconfig, ping, nslookup,

3:05those are all still accessible here inside of PowerShell.

3:07So there's very few, if any, reasons at all

3:10to go back to this old legacy command

3:11line Sure, we can still run ipconfig there, but guess what?

3:14We can come in to PowerShell and do the exact same thing.

3:17Very cool.

3:18In a lot of cases, some of these have better versions

3:21of commandlets.

3:22Ping is a good example.

3:22We now have Test-Connection, which

3:24gives us many more options.

3:25And of course it's object based, which means

3:27we can do a lot more with it.

3:29We also have aliases.

3:30Aliases are fantastic, right?

3:32These are named shortcuts to commands,

3:33and they serve a number of purposes.

3:35The obvious one is that they're going to save us on typing.

3:38The verb-noun naming convention is

3:40fantastic for so many reasons.

3:42But about the only reason they're not good for

3:44is typing, because they result in long names, even

3:47the short ones.

3:47Like Get-Content is still quite a bit of typing.

3:50So that's why we have aliases, number one,

3:51to reduce the amount of typing we have to do.

3:53But number two, this is how people could just

3:56jump into PowerShell and do what they did before.

3:58They were instantly comfortable because they could still

4:01do a dir.

4:02Or if they're from Linux, they could do an ls.

4:04These both map to the commandlet Get-ChildItem,

4:06a commandlet we'll be getting very familiar with.

4:08So aliases are great.

4:09I'll show you how we can use them, how we can discover them,

4:12how we can find them based on the command name,

4:13or how we can find commands based on alias names,

4:16and I'll even show you how we can create them here,

4:17later in this Nugget.

4:18We also have functions, which are a named

4:20grouping of commands, and they're

4:21extremely useful when you see yourself

4:23doing a lot of the same thing over and over across scripts.

4:26You can wrap that similar functionality into a function,

4:29and then call it by name, and that will give us code reuse.

4:33On top of that, it'll ensure that if we

4:35need to make a change we're only changing it in one spot,

4:37not in multiple scripts.

4:38Here's an example of a function, by the way, that I just threw

4:41together called Get-NewImages.

4:43Any idea what this does?

4:44Don't worry if not.

4:44We've got Nuggets down the road dedicated

4:46to writing scripts, and functions, and workflows,

4:48and all this code oriented stuff.

4:49But this is just going to get all the images, JPG images,

4:53in the user's profile for the last month.

4:56So it's going to take today's date, subtract a month from it,

4:59then store inside of a variable, called images,

5:02all of the images that live inside of, again,

5:04the user's profile directory, and all directories underneath

5:07that that have .JPG as a file extension.

5:10Then it's going to pipe that list into the Where-Object,

5:13which is going to pull out only the images that

5:15have a LastWriteTime that are greater than that start

5:18date, which is less than 30 days ago.

5:19And since I created that function,

5:21now I can use Get-Command with the command type of function,

5:23and it'll show up in the list.

5:25And then we can just call it by name.

5:26I created one image in there called lolcat, put it in there,

5:30and that's what it returns.

5:32If your head just exploded, no worries.

5:33We haven't even talked about half this stuff yet.

5:36Variables, pipelines, all this stuff we're going to get into.

5:38I just wanted to give you a quick idea

5:40of what a function looks like.

5:41Now we also have a command type known as workflows.

5:44Another very, very cool thing.

5:45So if you're familiar the Windows Workflow Foundation,

5:47think of it as kind of an execution engine

5:49here, that we can use to control processes.

5:51We can have them execute in sequence or in parallel

5:54across a number of machines.

5:56That's what-- kind of the power that we have brought

5:59into PowerShell here, natively.

6:00And it's absolutely incredible that we can now take commands

6:04and we can have them run all at the same time on a machine,

6:06or multiple machines, or we can sequence them across machines.

6:10It's going to make things very easy when

6:11you have an order of operation that you need explicitly

6:15defined inside of your scripts.

6:17And here's a really simple example here, actually.

6:19Workflow, called it parallelism, that's

6:21how we would call it then, as we do down here.

6:23And then we define a parallel group of commands.

6:26Meaning, these are going to execute at the exact same time.

6:29So if we execute it 10 times, chances

6:30are we're going to get different results.

6:32One's going to finish before the other one.

6:34Finally, we have scripts.

6:35This is really just a bunch of commands stored inside

6:37of a .ps1 file.

6:38But it's obviously a lot more than that,

6:39because this is where we're going to all the big stuff.

6:42Whenever we need to incorporate logistics, or control

6:45the flow of execution, we need variables to store data.

6:47We need to use lots of different commands.

6:49Maybe we need to do things across products.

6:51This is how we're going to get it done.

6:52Here's an example of when and how you would use a script.

6:55This one imports Active Directory Users

6:56from a CSV file.

6:57And it's not complete.

6:58We'll get in and clean this up down the road

7:00and make it actually work.

7:01But just to give you a general idea here,

7:02we've got a couple of variables here.

7:04One to store the domain name, one

7:05to import those users from a CSV file into a variable.

7:09Then we loop through each user for each record inside

7:13of that CSV file, and then we create an Active Directory User

7:15account.

7:16We set up some more variables inside of our loop,

7:18we call the New-ADUser command line, here,

7:20which will actually create the user.

7:21Then we set the password never expires to true on this user.

7:24Then finally, we enable the account.

7:26So it'll run this loop once for each user inside of that CSV

7:30file.

7:30We save this as a .ps1 file, and then we execute it through

7:34PowerShell.

7:34Pretty straightforward.

7:35Again, all stuff that we'll get into down the road, just

7:37want to give you an idea of what it looks like.

7:39Now that we're familiar with all the different command

7:41types in PowerShell, let's jump into the Virtual Nugget Lab

7:43and do a couple of demonstrations

7:45around commandlets, applications, and aliases.

7:47All right we're back in the Virtual Nugget Lab.

7:49Let's do some work.

7:49The first thing I want to do is show you

7:50how you can find commands of a specific type.

7:52So let's do a help on Get-Command

7:54here for the parameter of CommandType.

7:58So what this is going to do, is this parameter on Get-Command

8:01allows us to choose what we want to look for.

8:03Do we want to look for commandlets, aliases, scripts,

8:06workflows, functions, or all?

8:10So this all, by the way, is the same as doing Get-Command*

8:14which will give us everything.

8:15Just doing a Get-Command without specifying a command

8:18type, as you see, the default value down here

8:19will get commandlets, functions, workflows, and aliases.

8:22So what this means, here, is we could do something like this.

8:24If we wanted to find all commands that started, or let's

8:28say that had proc in it, for process,

8:30for the command type of say, commandlet.