An In-Depth Guide to Windows PowerShell for Beginners

Windows PowerShell is a powerful command-line shell and scripting tool that allows system administrators and power users to manage Windows systems and automate administrative tasks. In this comprehensive guide, we will cover everything you need to know as a beginner – from understanding the basics of PowerShell to writing advanced scripts and functions.

What is Windows PowerShell?

PowerShell is an extensible command-line shell and scripting language that is built on top of the .NET framework. Key features include:

Powerful scripting capabilities based on .NET
Ability to access and manipulate objects directly instead of plain text
Hundreds of built-in commands and tools called cmdlets
Support for developing custom cmdlets in any .NET language
Consistent design across Windows OS versions and editions
Integrated help and documentation system
Open-source and cross-platform (supports Windows, Linux, and macOS)

In a way, PowerShell attempts to bring the flexibility of shells like Bash and Zsh on Linux systems over to the Windows world. Microsoft positions it as a more modern alternative to the traditional Windows Command Prompt.

Under the hood, PowerShell is built on top of the .NET Common Language Runtime (CLR). This means that instead of plain text, PowerShell deals with .NET objects which makes it extremely powerful for managing Windows environments – after all, the Windows OS itself and most management tools are also built on .NET technologies like WMI, ADSI, and SCOM.

This object-based architecture is the single biggest reason why PowerShell can do so much more than traditional shells when it comes to automating system management tasks.

Why Use PowerShell?

There are several compelling reasons why IT professionals should invest time in learning PowerShell:

Increased Productivity

Once you learn PowerShell, you can manage servers, networks, and other system much faster by automating repetitive tasks. No more clicking through GUIs!

Improved Governance and Auditability

Share PowerShell scripts instead of docs to standardize processes. All actions are logged for auditing.

Multi-system Management

Manage hundreds of Windows systems together through one PowerShell console.

Access to .NET Ecosystem

Directly leverage classes from .NET frameworks to perform powerful system administration tasks.

Future-proof Skillset

PowerShell skills will serve you well for the foreseeable future due its ubiquitous presence in most Windows environments.

As you can see PowerShell makes admins far more productive. It may have a learning curve, but knowledge of PowerShell often sets senior admins apart.

Concepts and Terminology

Before starting to use PowerShell, it is important get familiar with its terminology and understand how it is structured:

Cmdlets

The primary way of interacting with systems in PowerShell is through cmdlets (pronounced "command-lets").

Cmdlets are specialized .NET classes that implement specific system administration tasks. Out of the box, PowerShell provides hundreds of powerful cmdlets capable of managing Windows systems end-to-end. For example, Get-Process, Set-Content, Start-Service etc.

Most cmdlets follow a Verb-Noun naming convention for consistency, so their usage can be easily understood. The verb defines the action being performed, while noun identifies the entity being operated upon.

Pipelines

One of the key features of PowerShell is its pipeline which allows you to string a series of commands together so that output of one command can be passed as input to another command.

For example, you can fetch a list of running processes, filter it, format it and then save the output to a text file:

Get-Process | Where-Object {$_.CPU -gt 100} | Format-Table | Out-File processes.txt

This level of flexibility makes it very easy to manipulate data and compose functionality at scale.

Providers & Drives

PowerShell providers are plugins that allow different types of data stores to be treated like old-school drives and made accessible via drive letters.

Some common examples include:

FileSystem: Access file system via drives like C:
Registry: Access registry as if it were a drive
Certificate: Manage certs through a cert: drive
Variable: Directly access variables through a variable: drive

This unlocks interesting usage like traversing registry keys by simply cd-ing into them like directories!

Scripts

To automate repeated tasks, you can create reusable PowerShell scripts which have a .PS1 extension.

Scripts contain functions, workflow definitions, variables etc. that can be invoked on demand. PowerShell ships with a powerful IDE called PowerShell ISE to author and debug scripts.

Advanced scripts can even contain complete PowerShell modules which you can import and leverage as if they were native commands.

Getting Started with PowerShell

Now that we understand key PowerShell concepts, let us focus on getting up and running quickly so that we can get our hands dirty.

The first step is ensuring PowerShell is available and accessible on your Windows 10/Windows Server machine. Modern Windows OS come with PowerShell pre-installed out of the box.

Opening PowerShell Console

Launch PowerShell console by searching for "PowerShell" from the Windows start menu.

By default it opens in a simple text-based console window. But PowerShell can also be launched in other shells like Command Prompt or even using GUI tools like Visual Studio Code.

Common launch options:

# Open plaintext console 
powershell.exe  

# Open console in Cmd shell instead of PS
cmd /K powershsell.exe

# Open Visual Studio Code with PS add-on 
code --install-extension ms-vscode.powershell
code .

Upon launching plain vanilla console, you will see a simple Windows PowerShell prompt waiting for your command:

Windows PowerShell  
Copyright (C) Microsoft Corporation. All rights reserved.  

PS C:\Users\John> _

Let us run our first PowerShell command Get-Process which shows currently running processes on the system just like Linux/Unix ps:

PS C:\Users\John> Get-Process

You will now see a list of all processes on your system along with their IDs, memory usage etc.

And just like that congratulations – you have run your first PowerShell cmdlet!

PowerShell ships with hundreds more cmdlets that allow you to manage Windows systems. Time to learn a few more…

Discovering PowerShell Commands

Instead of trying to memorize all PowerShell commands upfront, it is easier to discover them when required.

Let us see how to lookup cmdlets when you are trying to figure out how to perform a specific system administration task:

Get All Commands

Get a list of ALL PowerShell commands available on your system with:

Get-Command

This prints all cmdlets, functions and aliases accessible to the current PowerShell session along with metadata like versions and descriptions.

Get Help

All cmdlets come with built-in help explaining its usage and provides handy examples:

Get-Help Get-Process

Run this on any cmdlet name to directly access the integrated help for it without needing to go online.

Using Aliases

Most common PowerShell commands come with shorter pre-defined aliases.

For example, Get-Process can be shortened to just ps or gps. This saves a lot of typing!

> gps
> Get-Process

To find the aliases for ANY command or cmdlet, use Get-Alias:

Get-Alias ps

CommandType     Name   ModuleName
-----------     ----   ----------
Alias           ps -> Get-Process

And just like that with Get-Command, Get-Help and Get-Alias you can easily lookup the exact PowerShell syntax for any system administration task!

Working with Local Filesystem

A common administrative task is managing files and directories on local or networked filesystems.

Let us go through some examples of filesystem manipulation using PowerShell:

Navigating Directories

Change your current directory using Set-Location or its in-built alias cd.

Call pwd to print working directory and ls to list files just like old-school UNIX shells:

PS C:\Windows\System32> cd C:\Users\John\Documents\
PS C:\Users\John\Documents> pwd

Path
----
C:\Users\John\Documents

PS C:\Users\John\Documents> ls


    Directory: C:\Users\John\Documents


Mode                LastWriteTime         Length Name                                                                                   
----                -------------         ------ ----                                                                                   
-a----         2/1/2023   8:19 PM              0 Document.txt

As you can observe the Unix-like commands work as expected but return richer .NET objects instead of plain text.

Creating & Deleting

Create new directories using mkdir, files usingNew-Item and delete using Remove-Item:

> mkdir MyNewDir
> New-Item TestFile.txt
> del TestFile.txt
> rmdir MyNewDir

These commands closely mirror Linux shell functionality while handling Windows filesystem objects.

Copying and Moving

For copying files and directories use Copy-Item and for moving use Move-Item.

The -Recurse flag can be used for recursive copy across directories:

> Copy-Item .\Documents\ MyBackup -Recurse -Verbose

Here we are copying entire Documents folder over to a backup location verbosely displaying all child files and folders being copied as well.

And that is it! Whether working locally or via remote PS sessions, you can easily achieve basic filesystem tasks using cmdlets.

Managing Windows Services

Another extremely common admin task is managing Windows services for monitoring server health and application statuses.

Here are the most handy PowerShell cmdlets for managing Window services:

Get All Services

Fetch and filter services using Get-Service. This lists crucial details like status, startup type and process IDs:

Get-Service

Get-Service | Where-Object {$_.Status -eq "Running"}  

Get-Service | Where-Object {$_.StartType -eq "Automatic"}

Start & Stop Services

Dynamically control services by piping to Start-Service and Stop-Service:

# Start a service
Get-Service SQLServer | Start-Service

# Stop a service 
Get-Service SQLServer | Stop-Service

Enable & Disable Services

For persistence configure whether a service should start-up automatically using Set-Service:

# Set SQL Server to start automatically
Get-Service SQLServer | Set-Service -StartupType Automatic

And that is really all you need! These simple commands provide complete control to manage the 1000s of Windows services running across servers.

Working with Registry

The Windows Registry is a crucial hierarchical database that stores system configs and OS settings.

Managing Registry keys and values is easily done through PowerShell‘s in-built registry provider exposing the registry as if it were a drive with paths representing keys.

Navigating Registry

First enable the PSRegistry provider. After that registry keys appear as folders which you can easily traverse using cd like a filesystem:

# Access HKEY_LOCAL_MACHINE hive 
cd HKLM:\SOFTWARE  

# Go inside specific key
cd Microsoft\Windows\CurrentVersion\Run

Calling dir lists subkeys and entries inside any registry key you navigate to just like folders!

Creating & Deleting Keys

Create new registry keys using New-Item and delete existing ones using Remove-Item:

> New-Item TestKey
> Remove-Item TestKey

These work recursively as well!

Modifying Registry Values

Create, edit or delete registry value entries inside any subkey opened using standard commands like New-ItemProperty, Set-ItemProperty and Remove-ItemProperty:

New-ItemProperty -Path . -Name TestValue -Value 1
Get-ItemProperty -Path . -Name TestValue

Set-ItemProperty -Path . -Name TestValue -Value 2
Get-ItemProperty -Path . -Name TestValue  

Remove-ItemProperty -Path . -Name TestValue

And within a few simple commands you have full access to modify any registry keys and values on Windows!

Scripting Like a Pro with PowerShell ISE

So far we have mainly run ad-hoc commands inside the PowerShell prompt. But the true power lies in scripting and automation by combining a sequence of commands inside reusable .PS1 scripts.

While you can create and run scripts using any text editor, I highly recommend using the integrated PowerShell ISE tool included with Windows by default.

Let us see how to write entire production-grade scripts with the ISE:

Accessing the ISE

Launch the PowerShell ISE editor using Windows start menu search for ISE or directly through console:

PS C:\Users\John> ise

This opens up a GUI-based script editor window with built-in console, debuggers, syntax helpers and tools to easily develop PowerShell scripts from scratch.

Writing Script Contents

The left pane is used for writing actual script contents sequentially like any typical code editor.

For example, here is simple script to automate checking service status across multiple Windows servers:

# Script to check status of services on remote servers

$Servers = "SERVER-A","SERVER-B","SERVER-C"  

Foreach ($Server in $Servers) {

  Write-Host "Checking services on: $Server" -ForegroundColor Cyan

  Get-Service -ComputerName $Server | Where-Object {$_.Status -ne "Running"}

}

The script uses PowerShell‘s in-built foreach functionality and remote service management to sequentially check multiple networked servers easily.

Such automation tasks are extremely convenient through scripting vs manual CLI usage!

Executing Scripts

Written scripts can directly executed in-place within the ISE itself through the in-built console pane at the bottom which mimics the standard PowerShell prompt.

For example, pressing the Play button or F5 key will run the contents of the active ISE tab directly in the console pane. All input/output gets logged in real-time.

This means you get to simultaneously:

Edit scripts in the ISE pane
Automatically execute them and see outputs in the console pane

Additionally you can also run scripts like normal .ps1files by specifying path or feeding input data from file.

Debugging Scripts

ISE also comes with integrated debugging capabilities via breakpoints and variable watches inside a dedicated tab:

# Set breakpoint
[System.Diagnostics.Debugger]::Break()

So overall, PowerShell ISE is an invaluable tool that transforms PowerShell from simple CLI usage to easy script development. This unlocks automation capabilities to the next level!

Developing Advanced Functions

While scripts allow sequencing commands, functions encapsulate business logic behind re-usable wrappers exposing clean interfaces.

Functions promote code re-use across scripts. Let us go through a quick example:

Function Syntax

Here is simple syntax to define a PowerShell function:

Function Invoke-SomeTask {

  param ($Name, $Delay) 

  Write-Host "Starting long task: $Name"

  Start-Sleep $Delay

  Write-Host "Finished $Name"  

}

The function accepts named input parameters, includes business logic and prints output. This can be saved into a .PSM1 file and imported anywhere.

Invoking Functions

After defining the function, invoke it by calling the function name directly:

# Call function 
Invoke-SomeTask -Name Deploy -Delay 10

Parameters get cleanly passed during runtime execution.

Reusing Functions

Such a function can be reused across multiple scripts and even by other functions without code duplication. For example:

Function Start-WebServer {

  Write-Host "Verifying prerequisites" 
  Invoke-SomeTasks -Name CheckDotNet -Delay 5

  Write-Host "Enabling Web Server"
  # ...

}

This way PowerShell functions enable easy re-use, abstraction and modularity!

By splitting scripts into modular functions, you get better code organization and avoid reinventing the wheel improving productivity significantly. This allows managing tens and hundreds of servers together easily.

Where To Go From Here?

And that‘s a wrap! In this detailed guide you went from getting started with PowerShell completely from scratch to writing advanced automation scripts and functions.

You learned key concepts like cmdlets, providers, pipelines as well as hands-on usage for filesystem, registry, service and script management. Finally, you also got a primer on authoring reusable PowerShell functions.

Of course there is still an endless amount to explore! Here some recommended next steps for leveling up further:

Read official Microsoft PowerShell documentation
Enroll in a PowerShell training course
Learn Desired State Configuration
Explore community modules and libraries
Study Scripting and Toolmaking best practices
Try running PowerShell Core on Linux/macOS

I hope this guide has helped demystify PowerShell providing strong basics to confidently work with Windows systems.

Let the PowerShell automation begin!