2013
CBT Nuggets
Don Jones
08:13:44
English
Take PowerShell to the next level... stop being a "tool user" and start being a "tool MAKER!"
PowerShell guru, MVP, author, and trainer Don Jones shows you how to build reusable tools that look, feel, smell, and taste just like "real" PowerShell commands - all with a minimum of programming and with an emphasis on real-world usage. You'll learn all of the advanced, practical techniques administrators need in production, including how to access databases, how to create delegated administration tools, and much more. Don walks you through the entire process one step at a time, building on fundamental concepts and techniques to produce truly amazing results.
Don recommends completing his PowerShell Foundations course prior to beginning this "Toolmaking" series.
Introduction
A quick look at what will be covered in this series, along with a brief overview of system requirements.
00:05:25
Scripting Language Overview
Learn about PowerShell's five main scripting constructs for logic and loops, and briefly review some of the biggest "gotchas" around PowerShell variables. Remember that Don's "PowerShell Foundations" series is a prerequisite to this series; you'll get the basics about variables in that other series.
00:31:36
Simple Scripts and Functions
Take a straightforward PowerShell command and evolve it into a script... a parameterized script... and a simple PowerShell function, all serving as the basis for more complex and powerful tools. Learn to output objects instead of text, add PowerShell-standard help to your new tool, and much more.
00:25:56
Scope
Tackle the sometimes-tricky and often-overlooked concept of scope in PowerShell scripts and tools. Learn to avoid some of the most common scope mistakes, how to observe best practices around scope management, and how to recognize some of the crazier stuff that you'll run across "in the wild."
00:27:28
Designing a Tool for Reusability
Learn the best practices around PowerShell tool design - and actually SEE why those ARE the BEST practices! Don demonstrates how best practices can save you time, and how poorer approaches can actually make for more work, and for less flexibility, in the long run.
00:31:15
Writing Advanced Functions
Combine your new knowledge of scope and tool design with the tool you've been building so far, and create an amazing Advanced Function - also known as a "script cmdlet." You'll learn how PowerShell can help with things like parameter validation, how to handle pipeline input, and much more, along with tips for writing tools more quickly and easily using PowerShell's native tool set.
00:27:58
Adding Output
Polish up your PowerShell tools by adding verbose output (for those "warm and fuzzies"), warnings, and even progress bars - all following standard PowerShell patterns and using native PowerShell capabilities. This Nugget also emphasizes the desirability of working "the way PowerShell wants you to" so that your work can enjoy maximum flexibility and compatibility.
00:25:34
Putting it All to Use: Creating HTML Reports
Take everything you've learned to this point in Toolmaking and put it to use. You'll be introduced to a module that's designed to make HTML-based report creation easier and more natural, and see solid examples of how proper PowerShell design can speed development and maximize re-use of your hard work. Plus, you'll gain the ability to produce awesome, interactive HTML reports right within your own environment!
00:29:32
Error Handling Techniques
Learn the right way to anticipate, trap, and handle errors in your PowerShell scripts and tools. You'll learn techniques applicable both to PowerShell commands and to other functionality (such as executing methods). Don also shows you the old v1 "trap" technique, so that you can understand it when you run across it in older scripts. You'll be catching, logging, and dealing with errors in no time!
00:27:56
Debugging Techniques
Get a real-world look at PowerShell script debugging, as Don walks you through an actual debugging scenario. You'll also learn tips and techniques for avoiding simple bugs like syntax errors, and learn about PowerShell's native tools for debugging your scripts. Above all, Don shares his tried-and-true (and terribly un-fancy) approach to debugging, guaranteeing that you'll never again need to bash your head against the wall in frustration!
00:30:52
Custom Format Views
Fed up with PowerShell's half-hearted attempts at formatting your script and tool output? Frustrated that Don keeps telling you to NOT bother formatting your output for a prettier display? Fret no more, because in this Nugget you'll learn how to PROPERLY create awesome-looking default formatting for your output, without compromising its ability to be piped to other PowerShell commands.
00:23:25
Script Modules and Manifest Modules
Your tools are starting to involve multiple files - the main script, formatting XML views, and more - and it's getting tough to keep all the right files in all the right places and to have everything load and unload together. It's time to put everything into a module, a single unit that can be distributed, loaded, unloaded, discovered, and maintained.
00:20:29
Accessing Databases
Ready to start working with databases? Using the free SQL Server Express as an example, Don extends the tool he's been building to query computer names from a database, grab system information from those computers, and then save that system information back to the database. You'll even be introduced to a free PowerShell module that makes database work a bit easier!
00:29:33
Adding WhatIf and Confirm Support
The tool we've made to this point just retrieves information, but eventually you'll start writing tools that change the system in some way. When you do, it's smart to follow PowerShell's standard pattern of supporting the -WhatIf and -Confirm parameters, so in this Nugget, Don will show you how. You'll also get some tips for easier code re-use, such as how to create and use PowerShell ISE snippets.
00:21:11
Troubleshooting Pipeline Input
PowerShell becomes the most frustrating thing ever when things don't work as expected. Often times, that means adjusting your expectations to fit with PowerShell's reality, and THAT means being able to peek under the hood to see what's really happening with a command. In this Nugget, you'll draw back the curtain on PowerShell's pipeline binding and see how to trace exactly how data is being passed from one command to another.
00:24:45
Using Object Hierarchies for Complex Output
Learn how to create tools that output complex, hierarchical information - like a "system information" object that has child objects for each network adapter or local hard drive. Don also shows you how to work with that hierarchical data, and how to properly preserve it in an XML file, if desired.
00:21:02
Utilizing the .NET Framework in a Script
Found a .NET Framework class that lets you accomplish some crucial task, but can't figure out how to use it within PowerShell? This short Nugget will show you how to look up class documentation, instantiate classes, use static class methods, and more. Don even provides a quick walk-through example that shows how he goes about finding and learning to use classes on his own!
00:18:09
Creating a Graphical User Interface
You'll often have need to share your PowerShell tools with less-technical colleagues, and a graphical user interface (GUI) might be the best way to do that. In this Nugget, Don shows you how to use a third-party tool to quickly create a GUI that can wrap around existing PowerShell commands (including ones you've written yourself), and packaged and distributed to anyone you like.
00:29:00
Creating Proxy Functions
Proxy functions are a way to create a wrapper around an existing PowerShell command, either removing, hard-coding, or adding functionality to it. Don walks you through two examples, one that creates an all-new command based upon an existing one's functionality, and another that removes functionality from a command in order to provide a "dumbed-down" tool that could be shared with colleagues.
00:17:43
Delegated Remoting and Constrained Remoting Endpoints
In this final Nugget, Don brings all of your toolmaking skills together to create a powerful tool for delegated administration. You'll create a tool that lets specified end users perform an administrative task... WITHOUT actually giving them permission to perform that task! You'll combine proxy functions, remoting, and several new capabilities to start creating an amazing delegation infrastructure for your environment.
00:24:48
http://www.cbtnuggets.com/it-training-videos/series/cbtn_pwrshl_tool
Download File Size:1.79 GB
|
