Introduction to PowerShell Scripting

PowerShell scripts are powerful tools for automating tasks, managing systems, and streamlining workflows. They allow you to execute a series of commands in a structured and repeatable manner.

A PowerShell script is a text file with the extension .ps1. It contains PowerShell commands, expressions, and constructs.

Why Script?

  • Automation: Automate repetitive tasks like file management, user creation, or software deployment.
  • Efficiency: Save time and reduce manual errors by executing complex operations with a single command.
  • Consistency: Ensure that tasks are performed in the same way every time.
  • Scalability: Manage multiple systems and complex environments effectively.

Variables

Variables are used to store data. In PowerShell, variable names begin with a dollar sign ($).

Syntax:

$variableName = value

Example:

$computerName = "MyServer01"
$portNumber = 80
$isActive = $true

PowerShell is dynamically typed, meaning you don't need to declare the type of a variable. However, you can explicitly cast variables if needed.

Operators

PowerShell supports a wide range of operators for performing operations on variables and values.

Common Operators:

  • Arithmetic: +, -, *, /, %
  • Comparison: -eq, -ne, -gt, -ge, -lt, -le, -like, -notlike, -match, -notmatch
  • Logical: -and, -or, -xor, -not
  • Assignment: =, +=, -=
  • Member Access: . (e.g., $process.Name)
  • Type: -is, -isnot

Example:

$a = 10
$b = 5
if ($a -gt $b) {
    Write-Host "$a is greater than $b"
}

Control Flow

Control flow statements allow you to direct the execution of your script based on certain conditions.

Conditional Statements:

  • If-Else: Executes code based on a condition.
  • Switch: Compares a value against multiple conditions.

If-Else Example:

$status = "Active"
if ($status -eq "Active") {
    Write-Host "User is active."
} else {
    Write-Host "User is inactive."
}

Switch Example:

$serverRole = "WebServer"
switch ($serverRole) {
    "WebServer" { Write-Host "Configuring web server roles." }
    "DatabaseServer" { Write-Host "Configuring database roles." }
    default { Write-Host "Unknown server role." }
}

Loops:

  • For: Executes a block of code a specified number of times.
  • ForEach: Iterates over a collection of items.
  • While: Executes a block of code as long as a condition is true.
  • Do-While/Do-Until: Executes a block of code at least once and continues based on a condition.

ForEach Example:

$files = Get-ChildItem *.txt
foreach ($file in $files) {
    Write-Host "Processing file: $($file.Name)"
}

Functions

Functions are reusable blocks of code that perform a specific task. They help organize your scripts and promote modularity.

Syntax:

function FunctionName {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [string]$Parameter1,
        [int]$Parameter2 = 0
    )

    # Script block
    process {
        Write-Host "Received: $Parameter1, $Parameter2"
    }
}

Calling a Function:

FunctionName -Parameter1 "Hello" -Parameter2 10

The [CmdletBinding()] attribute enables common parameters and advanced function features. The param() block defines the function's parameters.

Objects and Properties

PowerShell is an object-oriented shell. When you run a cmdlet, it often returns objects, not just text. These objects have properties and methods that you can access.

Example: Get process information.

$process = Get-Process -Name "notepad"
Write-Host "Process Name: $($process.Name)"
Write-Host "Process ID: $($process.Id)"
Write-Host "CPU Usage: $($process.CPU)"

You can use cmdlets like Get-Member to discover the properties and methods of an object.

Get-Process | Get-Member

Error Handling

Robust scripts need to handle potential errors gracefully. PowerShell provides several mechanisms for this.

Common Error Handling Constructs:

  • Try-Catch-Finally: The primary mechanism for structured error handling.
  • Trap: A statement-level error handler that catches terminating errors.
  • $ErrorActionPreference: Controls how PowerShell responds to non-terminating errors.

Try-Catch Example:

try {
    # Code that might cause an error
    $file = Get-Content "nonexistent_file.txt"
    Write-Host "File content loaded."
} catch [System.IO.FileNotFoundException] {
    Write-Host "Error: The specified file was not found." -ForegroundColor Red
} catch {
    Write-Host "An unexpected error occurred: $($_.Exception.Message)" -ForegroundColor Red
} finally {
    Write-Host "This block always executes."
}

Modules

Modules are packages that group related cmdlets, functions, variables, and other resources. They help organize and distribute PowerShell functionality.

Key Module Concepts:

  • Installation: Use Install-Module to install modules from the PowerShell Gallery.
  • Importing: Use Import-Module to make a module's commands available in your session.
  • Finding: Use Find-Module to search for available modules.
  • Creating: You can create your own modules to package your custom scripts and functions.

Example: Installing and using the Az module for Azure management.

# Install the Az module (run with administrator privileges)
# Install-Module Az -Force

# Import the module
Import-Module Az

# Connect to Azure
# Connect-AzAccount

# List resource groups
# Get-AzResourceGroup