Thomas Maurer (tm) » PowerShell

Hyper-V 3: Import and Export VMs with PowerShell

Thomas Maurer — Mon, 19 Dec 2011 21:01:29 +0000

Aidan Finn (Virtual Machine MVP) just made a blog post about Hyper-V & PowerShell in Windows Server 8 and how you can enable Hyper-V via PowerShell in Windows Server 8. So this gave me the idea about doing a little more with PowerShell and Hyper-V 3.

I already did a blog post about how you can attach multiple VHDs to a SCSI Controller with PowerShell in Windows Server 8. In this post I will show how easy you can export and import a lot of Virtual Machines.

First you can run a Get-VM Test*, to check which VMs you will export.


Get-VM Test*

Now you can export the Virtual Machines


Get-VM Test* | Export-VM -Path "C:\VMs"

Now I removed the Virtual Machines in Hyper-V with Powershell (You could also add the -confirm parameter so you don’t have to press “y” for each VM.


Get-VM Test* | Remove-VM

And now you can import the Virtual Machines again


Get-Childitem "C:\VMs" -Recurse *.xml | Import-VM

I will post more about PowerShell in Windows 8 and Windows Server 8 (Hyper-V 3) in the next upcommig weeks. If you want know more about what new Hyper-V features and improvments are coming in Windows Server 8, you can read the following blog post: “Hyper-V: Version 3 kills them all”

Automated Active Directory Deployment with PowerShell

Thomas Maurer — Mon, 12 Dec 2011 19:06:08 +0000

For a small presentation at KTSI I created a PowerShell script will automatically will deploys Active Directory Servers, adds other member servers, creates Organization Units and adds users via Powershell Remoting. As source there is a XML configuration file and CSV files for User Data.

This script is just for Lab deployments not for production, and it is not perfect, but I think maybe some people will enhance this script with their own code.

I do not support this script. it is just something I need to deploy my test environments and nothing more. More it shows diffrent

You can find more information about it works in this document.

XML Config file:

The PowerShell Script:


 

# ---------------------------------------------------------------------------------------------- #

# Powershell AD Creator $Rev: 748 $

# (c) 2011 Thomas Maurer. All rights reserved.

# created by Thomas Maurer

# last Update by $Author: tmaurer $ on $Date: 2010-11-22 14:07:36 +0100 (Mo, 04 Nov 2011) $

# ---------------------------------------------------------------------------------------------- #

 

 

# Set Debug Mode (true/false)

$DebugOn = $false

 

 

 

#region [INFO BLOCK]

# INFO

Write-Host " " -BackgroundColor Black -ForegroundColor White

Write-Host "PowerShell AD Deplyoment" -BackgroundColor Black -ForegroundColor White

Write-Host " " -BackgroundColor Black -ForegroundColor White

Write-Host "Enter Credentials for Remote System:" -BackgroundColor Black -ForegroundColor White

#endregion

 

 

#region [VERBOSE BLOCK]

# Verbose Loop

 

if ($DebugOn -eq $true){

#Debug

Clear-Host

Write-Host "Debug mode on" -BackgroundColor Red -ForegroundColor White

$VerbosePreference = "Continue"

}

else {

#NoDebug

Clear-Host

$VerbosePreference = "SilentlyContinue"

}

#endregion

 

#region [CONFIG BLOCK]

# Get XML Information and create some funny objects...

[Xml]$global:xmlData = get-content ".\config.xml"

 

# Get Credentials for Remotesystems

$cred = Get-Credential

 

$global:xmlServer01 = $xmlData.lab.config.servers.server | Where-Object { $_.id -eq "1"}

$global:xmlServer02 = $xmlData.lab.config.servers.server | Where-Object { $_.id -eq "2"}

$global:xmlDomain = $xmlData.lab.config.ad.domain

$global:xmlOUS = $xmlData.lab.config.ous

 

#endregion

 

#region [FUNCTION BLOCK]

 

function ConvertTo-Scriptblock {

<#

Function to Convert a String into a Script Block

#>

Param(

[Parameter(

Mandatory = $true,

ParameterSetName = '',

ValueFromPipeline = $true)]

[string]$string

)

Begin {

Write-Verbose "Starting Begin Section"

}

Process {

Write-Verbose "Starting Process Section"

try {

Write-Verbose "Convert String to Scriptblock"

$sb = [scriptblock]::Create($string)

return $sb

}

catch {

Write-Host "Could not convert String to Scriptblock" $Error[0]

 

}

}

End {

Write-Verbose "Starting End Section"

}

}

 

 

function Enable-ICMP {

<#

Function to enable ICMP

 

Enable-ICMP -hostip $xmlServer01.ip

#>

Param(

[Parameter(

Mandatory = $true,

ParameterSetName = '',

ValueFromPipeline = $true)]

[string]$hostip

)

begin {

# Write Command

$step001 = @"

netsh firewall set icmpsetting 8

"@

}

process {

try {

# Run Scriptblock

Write-Host "Enable ICMP on " $hostip "..." -BackgroundColor Black -ForegroundColor White

 

Invoke-Command -ComputerName $hostip -ScriptBlock (ConvertTo-Scriptblock -String $step001) -Credential $cred

Write-Host "ICMP successfully enabled..." -BackgroundColor Green -ForegroundColor Black

 

 

}

catch {

# Sending status to CP and EventLog

throw "ERROR: Could not enable ICMP"

}

}

end {

# Cleanup

$step001 = $null

}

}

 

 

 

function Create-ADServer {

<#

Function to Create AD on the first Server

#>

begin {

# Prepair for First AD Server

Write-Host "Preparing Script Block for " + $xmlServer01.name + "..." -BackgroundColor Black -ForegroundColor White

$domainName = $xmldomain.name

$domainNetBiosName = $xmldomain.netbiosname

$domainForestLevel = $xmldomain.forestlevel

$domainDomainLevel = $xmldomain.domainlevel

$domainSafemodePW = $xmldomain.safemodepw

$adTempFolder = "temp4"

$adTempPath = "C:\" + $adTempFolder

$adFilePath = $adTempPath + "\adinstall.txt"

}

process {

try {

# Script Block for First AD Server

$step001 = @"

New-Item -ItemType directory $adTempPath

New-Item -ItemType file $adFilePath

Add-Content $adFilePath "[DCINSTALL]"

Add-Content $adFilePath "InstallDNS=yes"

Add-Content $adFilePath "NewDomain=forest"

Add-Content $adFilePath "NewDomainDNSName=$domainName"

Add-Content $adFilePath "DomainNetBiosName=$domainNetBiosName"

Add-Content $adFilePath "ReplicaOrNewDomain=domain"

Add-Content $adFilePath "ForestLevel=$domainForestLevel"

Add-Content $adFilePath "DomainLevel=$domainDomainLevel"

Add-Content $adFilePath "RebootOnCompletion=yes"

Add-Content $adFilePath "SafeModeAdminPassword=$domainSafemodePW"

Write-Host "Unattend File created successfully..." - -BackgroundColor Green

dcpromo /unattend:$adFilePath

"@

# Run Scriptblock

Write-Host "Configure " $xmlServer01 "..." -BackgroundColor Black -ForegroundColor White

Invoke-Command -ComputerName $xmlServer01.ip -ScriptBlock (ConvertTo-Scriptblock -String $step001) -Credential $cred

Write-Host "Configuration for " $xmlServer01.name " successfully..." -BackgroundColor Green -ForegroundColor Black

}

catch {

# Sending status to CP and EventLog

throw "ERROR: Could not Create AD"

}

}

end {

# Cleanup

$step001 = $null

}

}

 

function Join-AD {

<#

Function to add second AD Server

 

Join-AD -hostname $xmlServer02.name -hostip $xmlServer02.ip -dnsip $xmlServer01.ip -domainName $xmldomain.name -adminpw $xmlServer01.adminpw

 

#>

Param(

[Parameter(

Mandatory = $true,

ParameterSetName = '',

ValueFromPipeline = $true)]

[string]$hostname,

[Parameter(

Mandatory = $true,

ParameterSetName = '',

ValueFromPipeline = $true)]

[string]$hostip,

[Parameter(

Mandatory = $true,

ParameterSetName = '',

ValueFromPipeline = $true)]

[string]$dnsip,

[Parameter(

Mandatory = $true,

ParameterSetName = '',

ValueFromPipeline = $true)]

[string]$domainName,

[Parameter(

Mandatory = $true,

ParameterSetName = '',

ValueFromPipeline = $true)]

[string]$adminpw

)

begin {

# Prepair for Second AD Server

}

process {

try {

# Script Block join AD

$step001 = @"

netsh interface ipv4 add dnsserver name="Local Area Connection" address=$dnsip index=1

netdom join $hostname /domain:"$domainName" /userd:administrator /passwordd:$adminpw /REBoot

"@

 

# Run Scriptblock

Write-Host "Adding " $hostname " to domain..." -BackgroundColor Black -ForegroundColor White

 

Invoke-Command -ComputerName $hostip -ScriptBlock (ConvertTo-Scriptblock -String $step001) -Credential $cred

Write-Host "Domainjoin for " $hostname " successfully..." -BackgroundColor Green -ForegroundColor Black

 

 

}

catch {

# Sending status to CP and EventLog

throw "ERROR: Could not add System to AD"

}

}

end {

# Cleanup

$step001 = $null

}

}

 

function Add-ADServer {

<#

Function to add a second AD to the Domain

#>

begin {

# Prepair for First AD Server

Write-Host "Preparing Script Block for DCPROMO " $xmlServer02.name "..." -BackgroundColor Black -ForegroundColor White

$server01ip = $xmlServer01.ip

$domainName = $xmldomain.name

$server01pw = $xmlServer01.adminpw

$domainSafemodePW = $xmldomain.safemodepw

}

process {

try {

# Script Block for First AD Server

$step001 = @"

Dcpromo /unattend /replicaOrnewDomain:replica /replicaDomainDNSName:$domainName /ConfirmGC:yes /username:administrator /Password:$server01pw /safeModeAdminPassword:$domainSafemodePW

"@

# Run Scriptblock

Write-Host "Running DCPROMO " $xmlServer02.name "..." -BackgroundColor Black -ForegroundColor White

Invoke-Command -ComputerName $xmlServer02.ip -ScriptBlock (ConvertTo-Scriptblock -String $step001) -Credential $cred

Write-Host "DCPROMO " $xmlServer02.name " successfully..." -BackgroundColor Green -ForegroundColor Black

}

catch {

throw "ERROR: Could not add Second Server to AD"

}

}

end {

# Cleanup

$step001 = $null

}

}

 

function Add-ADOU {

<#

Function to add OU to AD

 

Add-ADOU -hostip $xmlServer01.ip -name $namedings -path $pathdings

 

#>

Param(

[Parameter(

Mandatory = $true,

ParameterSetName = '',

ValueFromPipeline = $true)]

[string]$hostip,

[Parameter(

Mandatory = $true,

ParameterSetName = '',

ValueFromPipeline = $true)]

[string]$name,

[Parameter(

Mandatory = $true,

ParameterSetName = '',

ValueFromPipeline = $true)]

[string]$path

)

begin {

# Prepair for Second AD Server

}

process {

try {

# Script Block join AD

$step001 = @"

Import-Module ActiveDirectory

New-ADOrganizationalUnit -name "$name" -Path "$path"

"@

 

# Run Scriptblock

Write-Host "Adding OU " $name " to " $path "..." -BackgroundColor Black -ForegroundColor White

 

Invoke-Command -ComputerName $hostip -ScriptBlock (ConvertTo-Scriptblock -String $step001) -Credential $cred

Write-Host "OU added " $name " successfully..." -BackgroundColor Green -ForegroundColor Black

}

catch {

# Sending status to CP and EventLog

throw "ERROR: Could not add OU to AD"

}

}

end {

# Cleanup

$step001 = $null

}

}

 

function Add-UsersfromFile {

<#

Function to add OU to AD

 

Add-UsersfromFile -hostip $xmlServer01.ip -filename $xmlData.lab.config.users.file.name -path $xmlData.lab.config.users.file.path

 

#>

Param(

[Parameter(

Mandatory = $true,

ParameterSetName = '',

ValueFromPipeline = $true)]

[string]$hostip,

[Parameter(

Mandatory = $true,

ParameterSetName = '',

ValueFromPipeline = $true)]

[string]$SamAccountName,

[Parameter(

Mandatory = $true,

ParameterSetName = '',

ValueFromPipeline = $true)]

[string]$UserPrincipalName,

[Parameter(

Mandatory = $true,

ParameterSetName = '',

ValueFromPipeline = $true)]

[string]$name,

[Parameter(

Mandatory = $true,

ParameterSetName = '',

ValueFromPipeline = $true)]

[string]$DisplayName,

[Parameter(

Mandatory = $true,

ParameterSetName = '',

ValueFromPipeline = $true)]

[string]$GivenName,

[Parameter(

Mandatory = $true,

ParameterSetName = '',

ValueFromPipeline = $true)]

[string]$SurName,

[Parameter(

Mandatory = $false,

ParameterSetName = '',

ValueFromPipeline = $true)]

[string]$Manager,

[Parameter(

Mandatory = $false,

ParameterSetName = '',

ValueFromPipeline = $true)]

[string]$Department,

[Parameter(

Mandatory = $true,

ParameterSetName = '',

ValueFromPipeline = $true)]

[string]$path

)

begin {

 

}

process {

try {

# Script Block join AD

$step001 = @"

Import-Module ActiveDirectory

New-ADUser -SamAccountName $SamAccountName -UserPrincipalName $userprinicpalname -DisplayName $displayname -GivenName $GivenName -SurName $SurName -Path "$path" -AccountPassword (ConvertTo-SecureString "test41;" -AsPlainText -force)

"@

 

# Run Scriptblock

Write-Host "Adding Users " $userprinicpalname " to " $path "..." -BackgroundColor Black -ForegroundColor White

 

Invoke-Command -ComputerName $hostip -ScriptBlock (ConvertTo-Scriptblock -String $step001) -Credential $cred

Write-Host "Users " $userprinicpalname " added successfully..." -BackgroundColor Green -ForegroundColor Black

}

catch {

# Sending status to CP and EventLog

throw "ERROR: Could not add Users to AD"

}

}

end {

# Cleanup

$step001 = $null

}

}

 

 

function WaitFor-Host {

<#

Function to wait for Host after Reboot

 

WaitFor-Host -hostip $xmlServer01.ip -service servicename

 

#>

Param(

[Parameter(

Mandatory = $true,

ParameterSetName = '',

ValueFromPipeline = $true)]

[string]$hostip,

[Parameter(

Mandatory = $false,

ParameterSetName = '',

ValueFromPipeline = $true)]

[string]$service

)

begin {

#

}

process {

try {

# Wait until Server is offline

Write-Host "Waiting for Reboot " $hostip "..." -BackgroundColor Black -ForegroundColor White

Start-Sleep -Seconds 10

 

# Wait for Server Reboot

Write-Host "Waiting for Host " $hostip "..." -BackgroundColor Black -ForegroundColor White

while (!(Test-Connection $hostip -quiet)) {

Write-Host 'Unreachable!'

}

Write-Host "Server up..." -BackgroundColor Green -ForegroundColor Black

Start-Sleep -Seconds 30

}

catch {

# Sending status to CP and EventLog

throw "ERROR: Waiting for reboot failed"

}

}

end {

}

}

 

 

 

 

#endregion

 

 

 

 

#region [MAIN BLOCK]

 

# Enable ICMP

Enable-ICMP -hostip $xmlServer01.ip

Enable-ICMP -hostip $xmlServer02.ip

 

# Create first AD Server

Create-ADServer

Start-Sleep -Seconds 30

WaitFor-Host -hostip $xmlServer01.ip

 

# Add Second AD Server to Domain

Join-AD -hostname $xmlServer02.name -hostip $xmlServer02.ip -dnsip $xmlServer01.ip -domainName $xmldomain.name -adminpw $xmlServer01.adminpw

Start-Sleep -Seconds 30

WaitFor-Host -hostip $xmlServer02.ip

 

# Run DCPROMO on Second AD Server

Add-ADServer

 

# Add OUs to Domain

foreach ($ou in $xmlOUS.ou){

Add-ADOU -hostip $xmlServer01.ip -name $ou.name -path $ou.path

}

 

 

# Add Users to Domain

foreach ($file in $xmlData.lab.config.users.file){

$tempfile = ".\" + $file.name

Import-Csv $tempfile | Foreach-Object {

$userprinicpalname = $_.SamAccountName + "@" + $xmlDomain.name

Add-UsersfromFile -hostip $xmlServer01.ip -SamAccountName $_.SamAccountName -UserPrincipalName $userprinicpalname -Name $_.name -DisplayName $_.name -GivenName $_.GivenName -SurName $_.SurName -Manager $_.Manager -Department $_.Department -Path $file.path

}

}

 

 

 

# Add Members to Domain

foreach ($member in $xmlData.lab.config.members.member){

Join-AD -hostname $member.name -hostip $member.ip -dnsip $xmlServer01.ip -domainName $xmldomain.name -adminpw $xmlServer01.adminpw

}

 

#endregion

PowerShell 3.0: Show-Command

Thomas Maurer — Fri, 18 Nov 2011 07:54:48 +0000

Just a simple note about a new cmdlet in PowerShell 3.0. Show-Command is something very useful if you try out a new PowerShell Command. It shows all the options and possible parameters you have with the cmdlet.

Show-Command Get-Childitem

Powershell: Convert String to Scriptblock

Thomas Maurer — Mon, 07 Nov 2011 16:49:03 +0000

If you use PowerShell remoting in some scripts you will se you cannot use a string to send it with the Invoke-Command cmdlet.

So you can simple convert a String to a Scriptblock

 $scriptBlock = [Scriptblock]::Create($string)

Now here an example

$remoteCommand =
@"
Import-Module ActiveDirectory
New-ADOrganizationalUnit -name
"@

$scriptBlock = [Scriptblock]::Create($remoteCommand)

Invoke-Command -ComputerName AD01 -ScriptBlock $scriptBlock

Basically you could create a function for that.

function ConvertTo-Scriptblock  {
<#
 Function to Convert a String into a Script Block
#>
	Param(
        [Parameter(
            Mandatory = $true,
            ParameterSetName = '',
            ValueFromPipeline = $true)]
            [string]$string
        )
       $scriptBlock = [scriptblock]::Create($string)
       return $scriptBlock
}

PowerShell: Ping IP range

Thomas Maurer — Wed, 02 Nov 2011 16:31:04 +0000

Some you need to know which IP in a specific range is already in use. With Windows PowerShell there is a simple way to ping a IP range.

You can use the .Net class System.Net.Networkinformation.Ping to do this.


$ping = New-Object System.Net.Networkinformation.Ping
1..254 | % { $ping.send(“192.168.100.$_”) | select address, status }

Commands for Windows Server Core & Hyper-V Core Server

Thomas Maurer — Mon, 31 Oct 2011 14:45:15 +0000

For some KTSI projects I have been working a lot with Windows Server Core or Hyper-V Server. Now I had to do a lot of automation, so I made this little connection of commands. If you configure the server manually you can do the most important things with the sconfig utility.

Networking

Set Hostname

netdom renamecomputer %COMPUTERNAME% /NewName:

Join Domain

netdom join %COMPUTERNAME% /domain: /userd: /passwordd:*

Remove Domain

netdom remove

Rename Network Interface

netsh interface set interface name=”old name” newname=”new name”

Configure IP Address

netsh interface ipv4 set address name=”” source=static address= mask= gateway=

Configure DNS Servers

netsh interface ipv4 add dnsserver name=”” address= index=1

Disable Firewall (not recommended)

netsh advfirewall set allprofiles state off

Remoting

Enable PowerShell Remoting

Enable-PSRemoting

Enable Remotedesktop

netsh advfirewall firewall set rule group=”remote desktop” new enable=yes

Enable Remote Administration

advfirewall firewall set rule group=”Remote Administration” new enable=yes

Enable Remote Firewall Administration

netsh advfirewall firewall set rule group=”Windows Firewall Remote Management” new enable=yes

Enable ICMP (Ping)

netsh firewall set icmpsetting 8

Enable Remote Disk Management

netsh advfirewall firewall set rule group=”Remote Volume Management” new enable=yes

Licensing

Enter License key

slmgr.vbs -ipk XXXXX-XXXXX-XXXXX-XXXXX-XXXXX

Activate Windows

slmgr.vbs -ato

Windows Update

Enable automatic updates

cscript C:'Windows'System32'Scregedit.wsf /au 4

Disable automatic updates

cscript C:'Windows'System32'Scregedit.wsf /au 1

Roles & Features

Get availibale features & roles

Dism /online /get-features /format:table

Enable feature & roles

Dism /online /enable-feature /featurename:

Basics

Change Administrator password

net user administrator *

Restart Computer

shutdown /r /t 0

Logoff

logoff

More information about Server Core: TechNet

Change Office 365 password expiration policy

Thomas Maurer — Fri, 14 Oct 2011 08:17:32 +0000

The default password expiration policy of Office 365 is set to 90 days. That means that users have to change their password every 90 days. I think basicly this is a good and secure policy but maybe your company has other security policy or for some other reason you have to deactivate this. We can change this setting through PowerShell with the MicrosoftOnline PowerShell Module.

First connect to Office 365 via PowerShell more on this here

Now you can use the following cmdlet

Set-MsolUser -UserPrincipalName user@contoso.com –PasswordNeverExpires $true

Quick note on PowerShell 3.0

Thomas Maurer — Wed, 28 Sep 2011 18:20:21 +0000

Today I had some time to test some of the new Windows PowerShell 3.0 feature and changes. And after playing a while with the Windows PowerShell 3.0 CTP I have to say Microsoft did besides the big new features, like workflows, a lot of small but really important improvements.

First I will show you two very small but very cool things which make working with PowerShell a lot easier.

New help view, which I really like. Here quick PowerShell 2.0 versus PowerShell 3.0:

Second I would like you to show how they simplified PowerShell for daily use. Here Get-Childitem for an example:

In PowerShell 2.0:

Get-Childitem | Where {$_.name -eq "Desktop"}

In PowerShell 3.0 you can do this now much friendlier:

Get-Childitem | where name -eq Desktop

Windows Management Framework 3.0 Community Technology Preview

Thomas Maurer — Mon, 26 Sep 2011 14:56:29 +0000

Some days ago the Microsoft Powershell Team released the Community Technology Preview of the Windows Management Framework 3.0 which includes Windows PowerShell v3. You can download the the CTP1 here and it requires Windows 7 SP1 or Windows Server 2008 R2 with SP1.

You can use very easy both PowerShell versions sie by site.

powershell.exe -Version 3.0

powershell.exe -Version 2.0

But the Windows Management Framework 3.0 CTP1 does not only includes PowerShell 3, it also contains new versions of WMI, WinRM and the new Windows PowerShell Webservice.

Windows PowerShell 3.0

Workflows
Workflows that run long-running activities (in sequence or in parallel) to perform complex, larger management tasks, such as multi-machine application provisioning. Using the Windows Workflow Foundation at the command line, Windows PowerShell workflows are repeatable, parallelizable, interruptible, and recoverable.
Robust Sessions
Robust sessions that automatically recover from network failures and interruptions and allow you to disconnect from the session, shut down the computer, and reconnect from a different computer without interrupting the task.
Scheduled Jobs
Scheduled jobs that run regularly or in response to an event.
Delegated Administration
Commands that can be executed with a delegated set of credentials so users with limited permissions can run critical jobs
Simplified Language Syntax
Simplified language syntax that make commands and scripts look a lot less like code and a lot more like natural language.
Cmdlet Discovery
Improved cmdlet discovery and automatic module loading that make it easier to find and run any of the cmdlets installed on your computer.
Show-Command
Show-Command, a cmdlet and ISE Add-On that helps users find the right cmdlet, view its parameters in a dialog box, and run it.

WMI

A new provider development model
This new model brings down the cost of provider development and removes the dependency on COM.
A new MI Client API to perform standard CIM operations.
The API can be used to interact with any standard WsMan + CIMOM implementation, allowing management applications on Windows to manage non-Windows computers.
The ability to write Windows PowerShell cmdlets in native code
The new WMI Provider APIs supports an extended Windows PowerShell semantics API allowing you to provide rich Windows PowerShell semantics. e.g., Verbose, Error, Warning, WhatIf, Confirm, Progress

WinRM

Connections are more robust
Session disconnect and reconnect, with or without client session reconstruction, allows long-running tasks to continue even when the session in which they were started is closed and the client computer is shut down. This feature also allows administrators to reconnect from different computers to check the status of remote running tasks and get results.
Connections are more resilient
In Windows PowerShell 3.0 CTP1, connections can survive short-term network failures; the client-server connection is not severed at the first sign of trouble. If network problems persist, the client is safely disconnected and can reconnect by using the Connect-PSSession or Receive-PSSession cmdlets.

Windows PowerShell Web Service

Windows PowerShell Web Service enables an administrator to expose a set of PowerShell cmdlets as a RESTful web endpoint accessible via the Open Data Protocol (OData). This provides remote access to invoke cmdlets from both Windows and non-Windows clients.

You can get more Information about the Windows Management Framework 3.0 Community Technology Preview on the Windows PowerShell Team Blog.

Hyper-V 3: Attach multiple VHDs via PowerShell

Thomas Maurer — Thu, 22 Sep 2011 15:40:40 +0000

We are already testing some Windows Server 8 installations and to test some of the new storage features I needed to attach a lot of VHDs to a Virtual Machine. Now with this Windows PowerShell script its very easy and fast.

Important:

Needs Windows Server 8 (Developer Preview)
Needs Hyper-V 3 (Inculded in Windows Server 8 )
Needs PowerShell v3 (Also included in Windows Server 8 )

$filePath = "\\storage01\VHDStorage\Virtual Hard Disks\"
$fileName = "server03-disk" # Your VHD will be called yourvhdnameX.vhdx (X = Number)
$serverName = "server03"
$controllerNumber = "0"
[int64]$vHDSizeGB = "100" # in GB
$vHDFormat = "vhdx" # vhdx or vhd
$vHDType = "Dynamic"
$numberofVHDs = "8"

for ($i=1;$i -le $numberofVHDs; $i++){

    $vHDPath = $filePath + $fileName + $i + "." + $vHDFormat
    New-VHD -Path $vHDPath -SizeBytes ($vHDSizeGB * 1073741824) -VHDFormat $vHDFormat -VHDType $vHDType
    Add-VMHardDiskDrive -VMName $serverName -ControllerType SCSI -ControllerNumber $controllerNumber -Path $vHDPath

}

The best thing overall is how you fast you can create such scripts with PowerShell v3. It took me like 10-12 minutes to get this thing done, and if you think how I would have to create and attach all of those VHDs with the wizard, I saved myself a lot of time.