Target Audience
This course is intended for administrators in a Microsoft-centric environment who want to build reusable units of automation, automate business processes, and enable less-technical colleagues to accomplish administrative tasks.
Course Objectives
After completing this course, students will be able to:
- Create and execute PowerShell scripts to automate administrative tasks.
- Develop reusable PowerShell functions, modules, and custom tools.
- Work with variables, arrays, loops, and conditional logic in PowerShell scripts.
- Manage files, services, processes, and system resources using PowerShell.
- Query and manipulate data from Windows systems and administrative tools.
- Implement error handling, debugging, and script troubleshooting techniques.
- Build automation solutions for Windows administration and enterprise operations.
- Apply PowerShell best practices for script design, maintenance, and reuse.
Course Content
Module 1: Tool Design
This module explains how to design tools and units of automation that comply with native PowerShell usage patterns.
Lessons : Describe the native shell patterns that a good tool design should exhibit
- Tools do one thing
- Tools are flexible
- Tools look native
- Lab : Designing a Tool
Module 2: Start with a Command
Lessons : Start the scripting process by beginning in the interactive shell console
- Why start with a command?
- Discovery and experimentation
- Lab : Designing a Tool - Start with a command
Module 3: Build a Basic Function and Module
Lessons : Build a basic function and module, using commands already experimented with in the shell.
- Start with a basic function
- Create a script module
- Check prerequisites
- Run the new command
- Lab : Designing a Tool - Build a basic function and module
Module 4: Adding CmdletBinding and Parameterizing
Lessons : Extend the functionality of a tool, parameterize input values, and use CmdletBinding
- About CmdletBinding and common parameters
- Accepting pipeline input
- Mandatory-ness
- Parameter validation
- Parmeter aliases
- Lab : Designing a Tool - Adding CmdletBinding and Parameterizing
Module 5: Emitting Objects as Output
Lessons : Create tools that produce custom objects as output.
- Assembling information
- Constructing and emitting output
- Quick tests
- Lab : Designing a Tool - Emitting objects as output
Module 6: An Interlude: Changing Your Approach
Lessons : Re-think tool design, using concrete examples of how it’s often done wrong.
- Examining a script
- Critiquing a script
- Revising the script
- Describe the native patterns that a good tool design should exhibit
- Redesign a script to meet business requirements and conform to native patterns
Module 7: Using Verbose, Warning, and Informational Output
Lessons : Use additional output pipelines for better script behaviors.
- Knowing the six channels
- Adding verbose and warning output
- Doing more with verbose output
- Informational output
- Lab : Designing a Tool - Using Verbose, Warning, and Informational Output
Module 8: Comment-Based Help
Lessons : Add comment-based help to tools.
- Where to put your help
- Getting started
- Going further with comment-based help
- Broken help : Identify causes of broken comment-based help
- Lab : Designing a Tool - Comment-based help
Module 9: Handling Errors
Lessons : Create tools that deal with anticipated errors.
- Understanding errors and exceptions
- Bad handling
- Two reasons for exception handling
- Handling exceptions in our tool
- Capturing the actual exception
- Handling exceptions for non-commands
- Going further with exception handling
- Deprecated exception handling
- Lab : Designing a Tool - Handling errors
Module 10: Basic Debugging
Lessons : Use native PowerShell script debugging tools.
- Describe the tools used for debugging in PowerShell
- Two kinds of bugs
- The ultimate goal of debugging
- Developing assumptions
- Write-Debug
- Set-PSBreakpoint
- The PowerShell ISE
- Lab : Designing a Tool - Basic debugging - Debug a broken script
Module 11: Going Deeper with Parameters
Lessons : Define parameter attributes in a PowerShell command
- Parameter positions
- Validation
- Multiple parameter sets
- Value from remaining arguments
- Help messages
- Aliases
- More CmdletBinding
Module 12: Writing Full Help
Lessons : Ceate external help for a command
- External help
- Create external help using PlatyPS and Markdown
- Supporting online help
- “About” topics
- Making your help updatable
- Lab : Designing a Tool - Writing full help
Module 13: Unit Testing Your Code
Lessons : Use Pester to perform basic unit testing.
- Sketching out the test
- Making something to test
- Expanding the test
- Going further with Pester
- Lab : Designing a Tool - Unit testing your code - Write basic unit tests for PowerShell functions
Module 14: Extending Output Types
Lessons : Extend objects with additional capabilities.
- Understanding types
- The Extensible Type System (ETS)
- Extending an object
- Using Update-TypeData
Module 15: Analyzing Your Script
Lessons : Use Script Analyzer to support best practices and prevent common problems.
- Performing a basic analysis
- Describe the use of Script Analyzer
- Analyzing the analysis
- Lab : Designing a Tool - Analyzing your script
Module 16: Publishing Your Tools
Lessons : Publish tools to public and private repositories.
- Begin with a manifest
- Publishing to PowerShell Gallery
- Publishing to private repositories
- Lab : Designing a Tool - Publishing your tools
Module 17: Basic Controllers: Automation Scripts and Menus
Lessons : Create controller scripts that put tools to use.
- Describe the purpose of basic controller scripts
- Building a menu
- Using UIChoice
- Writing a process controller
- Lab : Designing a Tool - Basic controllers
Module 18: Proxy Functions
Lessons : Create and use proxy functions.
- A proxy example
- Creating the proxy base
- Modifying the proxy
- Adding or removing parameters
- Lab : Designing a Tool - Proxy functions
Module 19: Working with XML Data
Lessons : Work with XML data in PowerShell.
- Simple: CliXML
- Importing native XML
- ConvertTo-XML
- Creating native XML from scratch
- Use XML data within a PowerShell function
- Lab : Designing a Tool - Working with XML
Module 20: Working with JSON Data
Lessons : Use JSON data in PowerShell.
- Describe the use of JSON data within PowerShell
- Converting to JSON
- Converting from JSON
- Lab : Designing a Tool
- Working with JSON data
- Use JSON data within a PowerShell function
Module 21: Working with SQL Server Data
Lessons : Use SQL Server from within a PowerShell script.
- SQL Server terminology and facts
- Describe the use of SQL Server from within PowerShell
- Connecting to the server and database
- Writing a query
- Running a query
- Invoke-SqlCmd
- Thinking about tool design patterns
- Design tools that use SQL Server for data storage
Module 22: Final Lab and exam
This module provides a chance for students to use everything they have learned in this course within a practical example.
- Lab problem
- Break down the problem
- Do the design
- Test the commands
- Code the tool
Course Prerequisites
The course assumes a basic working knowledge of PowerShell as an interactive command-line shell, and teaches students the correct patterns and practices for building reusable, tightly scoped units of automation.
Before attending this course, students must have:
- Basic understanding of Windows administration and management tasks.
- Familiarity with Windows networking, file systems, and administrative tools.
- Experience using the Windows command line or PowerShell console is beneficial.
- Basic scripting or automation knowledge is helpful but not required.
- Fundamental knowledge of Microsoft server or desktop environments is recommended.
Test Certification
None