Microsoft Exchange Server PowerShell Essentials

Windows PowerShell is the evolution of the Windows command-line shell, which provides a scripting environment for MS-DOS and the Windows operating system. In MS-DOS and Windows 9X, the shell was command.com, and it was cmd.exe for Windows NT family of the operating system. In the UNIX world, there are different shells such as SH, KSH, CSH, and BASH.

Almost all of these shells provide an environment to execute a command or utility and present the output as text. These shells have some built-in commands such as dir in cmd.exe in Windows NT or later versions, but these built-in commands are limited; and hence, new utilities are written to fill the gap. Shells supported the use of a scripting language (batch files) to automate tasks. There were limitations when it came to creating complex scripts and automating all other aspects provided by a Graphical User Interface (GUI) as equivalent commands are not exposed and the scripting language was basic.

Windows scripting host (Wscript.exe) and its command-line counterpart called Cscript.exe was introduced in 1998 with the release of Windows 98 to address some of the challenges. It is a language-independent scripting environment and allows scripts written in Jscript and VBScript using the APIs exposed by applications. There were deficiencies in this scripting environment due to limited documentation and interoperability issues with shell and security vulnerabilities. There were several security breaches as computer viruses exploited features provided by WSH. There were a few other attempts made by Microsoft to build utilities for specific purpose—for example, netsh—with their list of supported command sets, but they were not integrated with the shell and were inoperable.

In 2005, Microsoft released a new shell called Monad (also known as Microsoft Shell(MSH)), which is designed to automate a wide range of administrative tasks and is based on a new design as opposed to its predecessors.

Similar to the command.com and cmd.exe shells, Windows PowerShell can run three types of programs: built-in commands, external programs, and scripts. However, unlike a command shell, the built-in commands are not embedded into the shell environment but are available as modules in one or more .DLL files. This allows both Microsoft and vendors to write custom modules to manage their applications using PowerShell. Now, most of Microsoft and vendor's applications support management through Windows PowerShell, for example, Windows Server, Exchange Server, SharePoint, Lync Server/Skype for business, and VMWare.

Windows PowerShell is different than its predecessors in the following ways:

With the release of PowerShell 2.0, some APIs (application programming interface) were released that could be used to invoke PowerShell commands right from within your applications. Applications can then use certain PowerShell commands to perform a specific operation, which earlier could only be performed by GUI.

Starting from Exchange Server 2007, this capability has been used to its best advantage as will be explained over the course of the book. Learning PowerShell will help you in managing Microsoft, vendor applications, and services that support PowerShell. It will provide you the skillset required to manage and automate different aspects of Microsoft cloud-based offerings such as Office 365 and Windows Azure. Both of these support PowerShell and have specific modules for management. However, our focus in this book will be on managing Exchange through Windows PowerShell. At times, GUI is strictly used for illustration.

If you are interested in a .Net development, you can write your own cmdlet (pronounced as command-lets) in PowerShell that will perform a specific operation. For this, you will need PowerShell 2.0 Software Development Kit (SDK) and Visual Studio Express Edition. Both of these are free downloads.

The following table summarizes the history of the different versions of Windows PowerShell:

Windows PowerShell uses a verb-noun pair as a naming system. The name of each cmdlet includes a standard verb hyphenated with a specific noun. Verbs are used for specific actions in Windows PowerShell, and nouns are used to describe objects by users and system administrators. Here are some of the examples that show how little effort is required to work with cmdlets, and one does not have to memorize them.

Nouns in a cmdlet describe what the cmdlet will act on. For example, get-process, get-service, stop-process and stop-service. If this is used regularly, one can get to know the standard set of verbs and nouns used in PowerShell. With these verb-noun pair, hundreds of cmdlet names can be remembered and used.

You will be able to recognize the operation performed by a cmdlet by just reading the name as it is mostly apparent about the name used by a new command should relate to the operation. For example, get-computer will give you a list of computers on your network. Get-date and get-time will display the system date and time respectively. Similarly, stop-computer will shut down a computer. Set-date and set-time will set the system's date and time.

Let's look at how to list all the commands that have the particular verbs called Get and Set using Get-command with the –verb parameter. The output of this command is piped to display in a table format (more on this will be covered later in the Usage of pipelines section).

In the next example, we will just use instead of a format table:

Now, let's use the -Noun parameter, and we will find a list of commands that affect the same object type. For example, if you want to see commands that are available for managing computers, type the following command:

Traditionally, the commands in the earlier shells usually do not have a consistent parameter name. Sometimes, they don't have a name at all, and even if they do, they are abbreviated to make typing easier. But, this makes it difficult for new users to understand the parameters that are used. In Windows PowerShell, consistency is encouraged by using developer guidance on the usage of parameter names.

The names of the parameters in Windows PowerShell have a hyphen '-' prepended to them to allow PowerShell to demarcate them as parameters. In the get-command –Noun example, the name of the parameter is Noun and is typed as –Noun.

The cmdlets in Windows PowerShell support several common parameters as the PowerShell engine controls these parameters. So, no matter how they are implemented, they will behave in a similar way. Another way to drive the consistency and learning of Windows PowerShell are some of the common parameters like—Confirm, WhatIf, outvariable, warningaction, warningvariable, debug, and verbose.

This section will cover the use of help in Windows PowerShell. The help topic for a particular command or conceptual help can assist an administrator who is new to Windows PowerShell or using a particular set of cmdlets to understand its syntax and usage.

The Help parameter (?)

The -? parameter with a cmdlet will display Windows PowerShell help for the cmdlet:

PS C:\>get-help * | more

PS C:\>get-help gps -detailed

PS C:\>get-help get-process -parameter i*

PS C:\>get-help get-process -Parameter *

PS C:\>(get-help select-object).syntax

The transcript feature in PowerShell helps you to record all your cmdlets and activities at the prompt. This feature is not available for use in the PowerShell application during the writing of this book. This will help you capture all the commands and outputs from the commands that appear in the console in a text file that you specify using the start-transcript cmdlet.

The Start-transcript cmdlet initializes a transcript file, and then creates records of all the subsequent actions in the PowerShell session.

The syntax is shown as follows:

Here are some of the important parameters that you should know about the start-transcript cmdlet. To save the transcript file to a specified path, use the –Path parameter. You cannot use wildcards when you set the path, but you can also use variables. The directories in the path must exist or the command will fail.

The default behavior of the Start-Transcript cmdlet is to overwrite any file that is in the transcript path unless the –noClobber parameter is specified, which prevents Windows PowerShell from overwriting an existing file.

The –Append parameter will add the new transcript to the end of an existing file. For example, take a look at the following:

PS C:\> Start-Transcript -Path C:\transcript\transcript01.txt –NoClobber

When you want to stop recording the transcript, you can either exit the console or type Stop-transcript. The Stop-Transcript cmdlet requires no additional parameters.

The Stop-transcript cmdlet stops recording actions that was started by the start-transcript cmdlet. Use the following syntax:

PS C:\> stop-transcript

In PowerShell, the data is stored, retrieved, and modified using the methods listed next. In this section, we are going to cover only variables:

A variable is virtual storage to store information that will be utilized later in a script or the information that is the output of running a script. Variables can contain different data types such as text strings, objects, and integers. There are few special variables that you can use, which are defined in PowerShell.

The examples of some of the special variables are as follows:

If you are looking for a full list of automatic variables available for use in Windows PowerShell, type the following:

PS C:\> get-help about_automatic_variables

In PowerShell, all the variable names must start with the $ character. Data is assigned to a variable using the = operator:

PS C:\> $Number = 25

There are the Set-Variable and Get-Variable cmdlets that can also be used to set and retrieve the values of the variable.

Here, the value 401B is passed to the variable ExamCode:

PS C:\> Set-Variable -Name ExamCode -Value 401B
PS C:\> Get-Variable ExamCode

A little bit about operators that are used for assignment and comparison of values assigned to variables.

$Bookk = "Microsoft Exchange PowerShell Essentials"

$x = 12
$ = 34

$i += 3
$i = ($i +3)

$n *= 4
$n = ($n * 4)

[int]$Number = 12
[string]$Book = "Microsoft Exchange PowerShell Essentials"

[string]$s =  56
$s += 8
$s
568

[int]$Book 

At line:1 char:1
+ [int]$b 
+ ~~~~~~~
    + CategoryInfo          : InvalidArgument: (:) [], RuntimeException
    + FullyQualifiedErrorId : InvalidCastFromStringToInteger

PS C:\> get-help about_assignment_operators

PS C:\> "apple" -eq "apple"
True
PS C:\> "apple" -eq "orange"
False

PS C:\> "apple" -ne "apple"
False
PS C:\> "apple" -ne "orange"
True

PS C:\> 5 -gt 8
False
PS C:\> 23,34,56 -gt 50
56

PS C:\> "Windows PowerShell" -like "*shell"
True
PS C:\> "Windows PowerShell", "Server" -like "*shell"
          Windows PowerShell

PS C:\> get-help about_comparison_operators

A pipeline is a series of cmdlet statements connected through the pipeline (|) character (ASCII 124). Pipelines are used to send the output objects from one command as an input to another command. This can be used in scripts and console to build complex statements.

The output of Get-Service is piped to more command that displays information one screen at a time:

Get-Servince | more

You can use pipelines to build complex queries. For example, the following example will get the output of the Get-Service cmdlet and pipe it to the Where-Object cmdlet that will filter the services whose names match the MSExchange text, and the status is set to Running. The logical and operator is used in this case to combine the two conditions:

Get-Service | Where-Object {($_.Name –like "MSExchange*") –and ($_.Status –eq "Running")}

So far, we saw how to take output from one command and feed it into the next one. Now, let's take it further by adding one more piping. The following statement will get the output of the Get-Service cmdlet and pass it to Where-object where it will filter it for Exchange services, which are stopped, and then it will pass the output using another pipeline to Start-Service cmdlet. So, using this one-line command, you can check which Exchange Services are not running and start them. We have used the—autosize parameter to format the output based on the number of columns and their sizes:

Get-Service | Where-Object {($_.Name –like "MSExchange*") –and ($_.Status –eq "Stopped")} | Start-Service

In this section, we will review the usage of loops in Windows PowerShell. Every scripting language has multiple ways to loop through an array of items and execute a block of statements. Windows PowerShell has a variety of looping mechanisms described next.

          do {<command block>} while (<condition>)
          do {<command block>} until (<condition>)

PS C:\> Do { $a++ ; Write-Host $a } while($a -ne 5)

 PS C:\>  Do { $a++ 
          Write-Host $a
        } while($a -ne 5) 

PS C:\>  $Count = 1
do {Write-Host $Count; $Count++}
until ($Count -gt 5)

                     foreach ($<Element> in $< group of items>){Command Block>}

$Numbers = "1","2","3","4","5"; foreach ($No in $Numbers) {Write-Host $No}

  $Numbers = "1","2","3","4","5"
  foreach ($No in $Numbers)
  {
  Write-Host $No
  }

foreach ($item in Get-ChildItem)
        {
              Write-Host $item
        }

 $Fruit = @("Apple","Peach","Banana","Strawberry") foreach ($fruit in $fruit) { "$fruit = " + $fruit.length }
The following example displays all the numbers in the series except 2:
foreach ($num in 1,2,3,4,5) { if ($num -eq 2) { continue } ; $num }

while (<condition to be evaluated>) {<Command Block>}

  while ($value -ne 9)
  {
  $value++
  Write-Host $value
  }

while($value -ne 9){$value++; Write-Host $value}

An array is a variable that stores multiple items that are either of the same or different data type. An array can be created by assigning multiple values to a variable separated by a comma. The operator is used to assign values is the assignment operator (=). The following example creates an array that contains numbers 34, 56, 2, 23, and 8:

$Array = 34, 56, 2, 23, 8

A range operator (..) can also be used to create and initialize an array. The following example will create an array that will store the numbers from 1 to 5:

$Number = 1..5

This will store the values 1, 2, 3, 4, and 5 into the $Number.

If you do not specify the data type during creation, PowerShell creates an array of type:System.Object[]. You can use the GetType() method to display the type of array object created. For instance, the data type of the $Number array will be listed by:

$Number.GetType().

If you need an array that can have items of a particular data type, use the strongly typed array by preceding the array variable name with the data type such as the following example where $intarray contains 32-bit integer values:

[int32[]]$intarray = 1000, 2000, 3000, 4000

This will result in $intarray containing only integers as we have specified that no values other than int32 data type is allowed as value in this array.

In Windows Powershell, you can create arrays consisting of any supported data type in the Microsoft .Net framework.

Now, let's take an example of an array with multiple data types:

$mixedArray = 6,"Hello",4.5,"World"

The array subexpression operator is used to create an array with zero or more objects. Use the following syntax for the operator @( ... ):

$mixedArray = @(6,"Hello",4.5,"World")

Some other examples are as follows:

The following example creates an empty array:

$EmptyArray = @()

Create an array with a single element:

$Array = @("Hello World")

Create a multidimensional array:

$MultiDimArray = @(
             (4,5,6),
             (24,30,36)
   )

$Array

$Array[0]  

$Array[4]

$Array[-4..-1]

$Array[1..5]

$Array[0,1,3+5..8]

 $Array.Count

Foreach ($item in $Array) {$item}

For ($n = 0; $n –le ($Array.length -1); $n+=3) {$Array[$n]}

$i=0
while($i -lt 5) {$a[$i]; $i++}

$Array[3] = 23 

$Array.SetValue(34,2)

$Array +=250

$x = $array[0,1,3 + 5..($array.length - 1)]

        $a = 2,4,6,8,10
        $b = 1,3,5,7,9
        $c = 11,12,13,14,15
        $x= $a+$b+$c

PS C:\> get-help about_arrays

In order to understand how powerful Windows PowerShell is, you need to look at the filtering capabilities it offers. With an understanding of objects and pipelining, you can retrieve the exact information you are looking for. The Usage of Pipeline section talks about how pipelines can be used to pass one or more objects, which are the output of one command, and feed them into another cmdlet. In Windows PowerShell, there are commands that will help you to refine and get the desired output. Some of these cmdlets that we will look in this section are Where-Object, Sort-Object, Select-Object, and Select-String.

The Where-Object cmdlet helps you to filter the output returned by other cmdlets. For example, the Get-service cmdlet without any parameter retrieves information about the services installed on the computer on which it is called:

Now, let's filter the output of Get-Service to find the list of services that are stopped:

Windows PowerShell supports the following logical operators that we are going to use in our next example of filtering the output of a Get-Service cmdlet:

We will now find services that are running whose name starts with Windows using the –and operator:

By default, Windows PowerShell will sort the output of commands using an alphabetical order. You can then use the Sort-object cmdlet to sort it using any way you like. For example, the following example will first sort the output of the Get-Process cmdlet by the Process ID and then the CPU time:

At times, you might need to filter your results based on certain specific property names. This is where the Select-Object cmdlet comes in handy. It selects the stated properties of a single or group of objects. You can use Select-Object to select objects that are unique in a group of objects It supports parameters such as First, Last, Skip, and Index. You can select one or multiple object properties using the –Property parameter. Let's take an example of the output of the Get-Process cmdlet, and let's say you are troubleshooting a performance issue on a server and are only interested to know about the CPU time and process name properties. The output of the Get-Process cmdlet will be piped to Select-Object with the –property parameter set to the process name and CPU. The Format-list cmdlet will format the output displayed in the console:

PS C:\> Get-Process | Select-Object -Property Processname, CPU | format-list

Now, let's use another parameter called –Unique of Select-Object. This will select a single member from a number or objects with same properties and values. In the following example, you will notice that the –Unique parameter is case sensitive and reports "c" and "C" as unique.

Another useful filtering cmdlet is Select-String, used to select text patterns in strings and files. If you are familiar with UNIX shells, it is used as Grep or Findstr in Windows. It can display all the matches or stop after the first match depending on the usage of the cmdlet. You can search files of Unicode text using this command as well.

First, we will create a file using the redirection operator (>) to store the list of services running on a server to a text file:

PS C:\> Get-Service > service.txt

Now, we will find the text "Network" and "Windows" to get a list of all the services that have the word in it. We will then use the –notmatch parameter to list all the services except this word:

Note that the search performed here is a case insensitive search; you can use the —case sensitive parameter to make it case sensitive, which means you won't get any output if you use the parameter with the previous command as there are no matches found.

In this section, we will use the if conditional statement If to execute statements based on a specific condition test to be true. We can also use the If command to do tests on more than one condition or even if all the other conditions are evaluated to be false.

The following example shows the If statement syntax:

        if (<Condition1>) 
                {<Command Block 1>}
        [elseif (<Condition2>)
                {<Command Block 2>}]
        [else
                {<Command Block 3>}]

We will use the if command to check the status of the services running on the computer, and if the status is stopped, it will be displayed in red and the running services will be displayed in green. We will use a combination of pipeline, the foreach-object cmdlet, and the if statement.

PS C:\> get-service | foreach-object {if ($_.status -eq "stopped") {write-host -foregroundcolor red $_.Displayname}` else {write-host -foregroundcolor green $_.Displayname }} 

Let's take a look at another example where you would like to find whether a particular folder is created. We will use a Test-Path cmdlet, which will return true if it finds the folder and false if it does not. As I am using the statement on my Active Directory domain controller, the folder is not present under Program Files, and this is what you will see in the output:

PS C:\> $ExchangeFolder = "C:\Program Files\Microsoft\Exchange Server"
PS C:\> $FolderPresent = Test-Path $ExchangeFolder
PS C:\> if ($FolderPresent -eq $True) {Write-Host "Exchange installation Folder found on this Server"} else {Write-Host "Exchange installation folder not present"}
Exchange installation folder not present

A Switch statement is used to check multiple conditions. It is equivalent to a series of If statements. The Switch statement lists each condition and an optional action. If a condition is true, the action is performed:

Syntax:

        Switch (<test-value>)
        {
            <condition> {<action>}
            <condition> {<action>}
        }

The Switch statement compares the value of 2 to each of the conditions listed. Once the test value matches the condition, the action is performed:

        PS> switch (2) 
         {
            1 {"It is one."}
            2 {"It is two."}
            3 {"It is three."}
            4 {"It is four."}
         } 
        It is two.

In the previous example, the value is compared to each condition in the list and there is a match for the value of 2. Let's take a look at the same example where we have added another condition that matches the value of 2:

        PS> switch (2) 
         {
            1 {"It is one."}
            2 {"It is two."}
            3 {"It is three."}
            4 {"It is four."}
            2 {"Two again."}
         } 
        It is two.
        Two again.

Using the Break statement, you can directly switch to stop the comparison after a match and terminate the switch statement:

        PS> switch (2) 
         {
            1 {"It is one."}
            2 {"It is two."; Break}
            3 {"It is three."}
            4 {"It is four."}
            2 {"Two again."}
         } 
        It is two.

Now that we have covered the basics of Windows PowerShell, let's write our first script. PowerShell uses the .ps1 format to save scripts. Before we get into executing scripts, let's first understand the following PowerShell Script Execution Policies that are in place to prevent unwanted scripts from being executed on your computer.

The cmdlet Set-Execution Policy helps you to change the Policy of which scripts you can run on your computer. There are four different execution policies:

Now, let's set the execution Policy to Remote Signed and verify using Get-Execution Policy cmdlet:

PS C:\> Set-ExecutionPolicy RemoteSigned
PS C:\> Get-ExecutionPolicy

I am going to introduce the PowerShell Integrated Scripting Engine (ISE) that makes it easier to run scripts with features, such as syntax-coloring, tab completion, IntelliSense, visual debugging, and context sensitive Help, as compared to the PowerShell console.

The following script will query the win32_logical disk WMI class. This is a representation of a local storage device on a Windows Computer. There are six possible Drive Types, and we will use a Switch statement to get the output in text describing the type of storage:

In this chapter, you learned the usage of the cmdlet syntax in Windows PowerShell and the help system. We also covered variables and arrays used to store data. This data can then be exported and filtered in a lot of different ways by the use of operators, pipelines, and loops. Finally, the use of If statement is reviewed, which can be used to run a block of code based on a conditional test. These basics will be used throughout the rest of this book in examples and scripts.

In the next chapter, we are going to look at ways to manage recipients in an Exchange organization.