CBT Nuggets - PowerShell Reference Training

This Windows PowerShell training course serves as a broad reference library of all the Microsoft's dynamic programming language and interactive command line shell can do. This course is a powerful reference for PowerShell versions 2, 3, and 4, and clearly explains everything an administrator might want to do with the shell.

Start from absolute zero and learn PowerShell as it was meant to be used. Advance into scripting and “toolmaking,” learning to make command-line and graphical tools from scratch. Move into advanced, real-world, field-proven topics such as reporting, trend analysis, and more. Learn super-advanced features like workflow and Desired State Configuration. Or find topics that go beyond the shell, such as using Component Object Model and .NET Framework classes in the shell.

It’s one course, with everything the shell touches. Encompassing more than 30 hours of instruction, combined with self-paced, hands-on labs (and video lab reviews), this Microsoft PowerShell training is the ultimate course for learning Windows PowerShell.

Content:

1. Course Introduction and Lab Setup (8 min)
2. Windows PowerShell Orientation and Requirements (24 min)
3. Finding and Discovering Commands (23 min)
4. Interpreting Command Help (23 min)
5. Running Commands (26 min)
6. Working with PSProviders and PSDrives (17 min)
7. Variables, Strings, Hashtables, and Core Operators (24 min)
8. Regular Expression Basics (23 min)
9. Running External Commands: Tips and tricks (11 min)
10. Learning the Pipeline: Exporting and converting data (23 min)
11. Understanding Objects in PowerShell (23 min)
12. Core Commands: Selecting, sorting, measuring, and more (27 min)
13. How the PowerShell Pipeline Works (35 min)
14. Formatting Command Output (19 min)
15. Comparison Operators and Filtering (17 min)
16. Advanced Operators (26 min)
17. Setting Default Values for Command Parameters (20 min)
18. Enumerating Objects in the Pipeline (16 min)
19. Soup to Nuts: Completing a new task (19 min)
20. Lab A: PowerShell core review (27 min)
21. PowerShell Remoting Basics (45 min)
22. Persistent Remoting: PSSessions (14 min)
23. Implicit Remoting: Using commands on another computer (22 min)
24. Advanced Remoting: Passing data and working with output (27 min)
25. Advanced Remoting: Crossing domain boundaries (22 min)
26. Advanced Remoting: Custom session configurations (28 min)
27. Web Remoting: PowerShell web access (20 min)
28. Lab B: PowerShell remoting review (12 min)
29. WMI and CIM: WMI, docs, and the repository (23 min)
30. WMI and CIM: Using WMI to command query qata (23 min)
31. WMI and CIM: Using CIM command to query data, part 2 (25 min)
32. WMI and CIM: Filtering and WMI query language (20 min)
33. WMI and CIM: Associations (18 min)
34. WMI and CIM: Working with CIM sessions (18 min)
35. WMI and CIM: Executing instance methods (22 min)
36. Lab C: WMI and CIM review (11 min)
37. Background Job Basics: Local, WMI, and Remoting jobs (19 min)
38. Scheduled Background Jobs (24 min)
39. Lab D: Jobs review (10 min)
40. PowerShell Script Security (25 min)
41. Prompting for Input, Producing Output (17 min)
42. Creating Basic Parameterized Scripts (19 min)
43. PowerShell Scripting: Logical constructs (22 min)
44. PowerShell Scripting: Looping constructs (23 min)
45. PowerShell Scripting: Basic functions, filters, and pipeline functions (35 min)
46. PowerShell Scripting: Best practices (17 min)
47. PowerShell Scripting: From command to script to function to module (14 min)
48. PowerShell Scripting: Scope (20 min)
49. PowerShell Scripting: Combining data from multiple sources (16 min)
50. Lab E: PowerShell scripting review (13 min)
51. Advanced Functions: Adding Help (15 min)
52. Advanced Functions: Parameter Attributes (17 min)
53. Advanced Functions: Pipeline Input (16 min)
54. Advanced Functions: Parameter Sets (18 min)
55. Lab F: Advanced Functions Review (22 min)
56. Creating Private Utility Functions and Preference Variables (16 min)
57. Adding Error Capturing and Handling to a Function (20 min)
58. Advanced Error Handling (26 min)
59. Error Handling the Old Way: Trap (8 min)
60. Debugging Techniques (32 min)
61. Creating Custom Formatting Views (25 min)
62. Creating Custom Type Extensions (21 min)
63. Working with SQL Server (and other) Databases (40 min)
64. Working with XML Data Files (29 min)
65. Supporting –WhatIf and –Confirm in Functions (13 min)
66. Troubleshooting and Tracing the Pipeline (16 min)
67. Using Object Hierarchies for Complex Output (17 min)
68. Creating a Proxy Function (19 min)
69. Lab G: Advanced Scripting Review (16 min)
70. From the Field: Enhanced HTML Reporting (43 min)
71. From the Field: Trend Analysis Reporting (18 min)
72. From the Field: Scraping HTML Pages (9 min)
73. Introduction to PowerShell Workflow (36 min)
74. Desired State Configuration: The Basics (14 min)
75. Desired State Configuration: Configuration Scripts and Pull Servers (37 min)
76. Desired State Configuration: Writing Resources (25 min)
77. Controller Scripts: Automating Business Processes (10 min)
78. Controller Scripts: A Menu of Tools (9 min)
79. Creating a GUI Tool: The GUI (10 min)
80. Creating a GUI Tool: The Code (11 min)
81. Creating a GUI Tool: The Output (15 min)
82. Creating a GUI Tool: Using Data Tables (8 min)
83. Lab H: Automating a Business Process (7 min)
84. Globalizing a Function or Script (11 min)
85. Discovering and Using COM Objects (10 min)
86. Discovering and Using .NET Classes and Instances (14 min)
87. Using Type Accelerators (12 min)
88. The Big Gotchas in PowerShell (23 min)
89. Fun With Profiles (18 min)
90. Random Tips and Tricks (26 min)