Several of the methods I showed, are already discussed on other blogs (to which I will include the links of course), but there is a new PowerShell feature that hasn’t been used until now (afaik).

And since I never found a complete overview of all the available methods, I decided to create this post.

Method 1 – On a Connection Server

Method 1A – From the View PowerCLI prompt

This is the most straightforward method, and also the first one shown in the View documentation. You start a View PowerCLI session through the provided Start menu shortcut, or you start a plain PowerShell session and make sure the VMware.View.Broker PSSnapin is loaded.

Note that the View PowerCLI PSSNapin has a problem when you use it in a PowerShell v3 (or higher) engine. A bypass for this problem is to start the PowerShell engine in Version 2 mode.

One way of doing that is by adding a parameter to the View PowerCLI shortcut in the Start menu. The following short script will update the Start menu entry to do this.

$extraArgument = "-version 2 "

if($PSVersionTable.PSVersion.Major -gt 2) {
  $relativePath = "VMware\View PowerCLI.lnk"
  $shell = New-Object -com "WScript.Shell"
  $start = $shell.SpecialFolders.item("AllUsersPrograms")
  $shortcut = $shell.CreateShortcut("$($start)\$relativePath")
  if($shortcut.Arguments -notmatch $extraArgument){
    $shortcut.Arguments = "$($extraArgument)$($shortcut.Arguments)"
    $shortcut.Save()
  }
}

The shortcut will have an extra argument, the Version parameter, after you run the script on your Connection server.

A short demo of this

Method 1B – As a PowerShell background job

An alternative, that uses the same concept, is to run your View PowerCLI cmdlets and script as background jobs, and use the PSVersion parameter.

This method was described by Andre Leibovici in his How to use VMware View PowerCLI with PowerShell 3.0 post.

A short demo of this method

The major disadvantage of this method in all it’s forms, is that you are logging on to a Connection Server and running your script interactively on the server. Something that might not be permitted in a production environment.

Another disadvantage, is that while you are running in a Version 2 engine, you will not have access to any of the PowerShell v3 (or higher) cmdlets.

Method 2 – Remote Session

The first mention of using a PowerShell Remote Session to run View PowerCLI cmdlets and scripts comes from Alan Renouf in his Using the View PowerCLI cmdlets from another machine post.

Andre Leibovici did a post on this concept later on in his Remote use of VMware.View.Broker PowerCLI post. The great novelty that he introduced there, was that he uses PowerCLI’s Invoke-VMScript cmdlet to configure the winrm settings on the Connection server.

But neither of these posts seems to mention that you need PowerShell v1 or v2 on the Connection Server. And with the New-PSSession cmdlet you do not have the option to pass a Version parameter.

In PowerShell v4 the PSSessionConfiguration concept was introduced. With the Register-PSSessionConfiguration cmdlet you create and register a session configuration on a computer. With this we can solve the requirement that the View PowerCLI PSSnapin needs PowerShell v1 or v2.

We can define a PS v2 configuration on the Connection Server remotly like this. Note that this assumes that remote sessions to the Connection server are already configured. If not, you can use Andre’s PSRemoteSession-Configure function to do that.

$PS2 = {Register-PSSessionConfiguration -Name PS2 -PSVersion 2.0 -Confirm:$false}
$session = New-PSSession -ComputerName view1
Invoke-Command -Session $session -ScriptBlock $PS2
Remove-PSSession -Session $session

Once this session configuration is defined, we can run our View PowerCLI cmdlets and scripts like this

$session = New-PSSession -ComputerName view1 -ConfigurationName PS2
Invoke-Command -Session $session -ScriptBlock {Add-PSSnapin VMware.View.Broker}
Invoke-Command -Session $session -ScriptBlock {Get-Pool}
Remove-PSSession -Session $session

A short demo

No more holding back on your PowerShell updates on the Connection servers.

A closing thought; the fact that the View PowerCLI PSSnapin officially still requires PowerShell v1, is to say the least annoying. Perhaps the team that develops the View PowerCLI PSSnapin could put PowerShell v4 support, and a few other improvements I will gladly share with them if needed, on their New Year’s resolution list

Enjoy !

In the session I tried to show how easy it is to produce decent performance and capacity reports about your vSphere environment with PowerCLI. During the session I did some demos to show some aspects of PowerCLI and statistics. This post contains the code, and some annotations, I used during these demos.

I started off by showing what is available in PowerCLI for working with vSphere statistics.

# What is available in PowerCLI ?
Get-Command -Name *stat* -Module VMware.VimAutomation.Core

# Let's start with the intervals
Get-StatInterval

# What else is possible with this cmdlet ?
Get-Help -Name Get-StatInterval

# In PS v3 help can be displayed in a window
Get-Help -Name Get-StatInterval  -ShowWindow

# Our first source of information for the counters
Get-Help -Name Get-StatType -ShowWindow

# Let's try it out
Get-StatType -Entity esx1.local.test -Name cpu*

# There is a difference between the intervals

# Realtime
Get-StatType -Entity esx1.local.test -Name cpu* -Realtime |
Measure-Object | Select-Object -ExpandProperty Count

# Historical Interval 1
Get-StatType -Entity esx1.local.test -Name cpu* -Interval 300 |
Measure-Object | Select-Object -ExpandProperty Count

# Historical Interval 2
Get-StatType -Entity esx1.local.test -Name cpu* -Interval 1800 |
Measure-Object | Select-Object -ExpandProperty Count

# Historical Interval 3
Get-StatType -Entity esx1.local.test -Name cpu* -Interval 7200 |
Measure-Object | Select-Object -ExpandProperty Count

# Historical Interval 4
Get-StatType -Entity esx1.local.test -Name cpu* -Interval 86400 |
Measure-Object | Select-Object -ExpandProperty Count

# Retrieving the metrics
Get-Stat -Entity esx1.local.test -Stat cpu.usage.average -Realtime -MaxSamples 5

# The instance concept
# CPU
Get-Stat -Entity esx1.local.test -Stat cpu.usage.average -Realtime -MaxSamples 5 |
Group-Object -Property Instance

# Network
Get-Stat -Entity esx1.local.test -Stat net.received.average -Realtime -MaxSamples 5 |
Group-Object -Property Instance

# Some counters not available through Get-Stat
# Use the PerformanceManager methods
. ./Get-Stat2.ps1
Get-Stat2 -Entity (Get-VMHost esx1.local.test).ExtensionData -Stat net.received.average -QueryInstances -Interval RT

Annotations

Line 10: In PowerShell v3 you can have your help displayed in a separate window, very handy to have the window open while writing your code.

Line 13-39: The Get-StatType cmdlet is used to find which counters are available for which VIObject in which time interval. See my PowerCLI & vSphere statistics – Part 1 – The basics post for additional info on counters.

Line 21-39: Depending on the interval you select, and the Statistics Level that is set in your vCenter, you will see a different number of available counters.

Line 44-51: Several counters return metrics for all the available instances and an aggregate counter. That aggregate metric is in fact the average over all the available instances. On the PerformanceManager pages that list the counters, you can see if a specific counter reports on instances or not. This also the first sample use of the Group-Object cmdlet, a cmdlet you must master when you are working with vSphere metrics.

Line 53-56: In the current PowerCLI release some counters can not be retrieved with the Get-Stat cmdlet. In that case you will have to fall back on the QueryPerf method available on the PerformanceManager object. Or you can use my Get-Stat2 function where I encapsulated that method in a PowerShell function.

Line 55: This line shows dot-sourcing at work. The code for the Get-Stat2 function is stored in the file Get-Stat2.ps1 and with the dot-sourcing we tell the PowerShell engine to read the file and thus “know” the definition of the function. After this dot-sourcing of the file, we can use the Get-Stat2 as a normal cmdlet in our scripts. This avoids that we will have to include this function code in all our scripts.

In the following script I present a quick method to create your own Counter Reference page.

$perfMgr = Get-View (Get-View ServiceInstance).content.perfManager

$perfMgr.PerfCounter |
Select @{N="Counter";E={$_.GroupInfo.Key + "." + $_.NameInfo.Key + "." + $_.RollupType}},
  @{N="Description";E={$_.NameInfo.Summary}},
  Level,@{N="Unit";E={$_.UnitInfo.Key}},StatsType,Key |
Sort-Object -Property Counter |
Export-Xlsx -AutoFilter -FreezePanes -Path E:\SkyDrive\Scripts\vSphere-Counter-Xref.xlsx

Annotations

Line 8: The Exports-Xlsx function is available in Export-Xlsx, the sequel, and ordered data, or on Gilbert’s blog ITPilgrims A personal sandbox.

The resulting worksheet looks something like this.

The Level column shows the Statistics Level at which this counter is available.

The StatType column shows the type of statistical measurement that is used for a counter. See PerfStatsType.

The Key column shows the internal key that vCenter uses for the counter. This value is unique for each environment, it depends on the features and components that are installed in your vCenter. This Key is used when you create for example an Alarm that is triggered on a performance counter exceeding a threshold. See for example Alarm expressions – Part 1 : Metric alarms.

In the following demo I tried to show how you can improve the performance of your statistic data gathering scripts. The first script shows the non-optimal method of gathering the data. A Get-Stat call for each counter and for each VIObject.

Measure-Command {
  $esxAll = Get-VMHost
  $metrics = "cpu.usage.average","mem.usage.average"

  foreach($esx in $esxAll){
    foreach($metric in $metrics){
      Get-Stat -Entity $esx -Stat $metric -Realtime |
      Select Timestamp,Entity,MetricId,Value
    }
}} | Select -ExpandProperty TotalMilliseconds

By limiting this to just one Get-Stat call your script will be considerably faster.

Measure-Command {
  $esxAll = Get-VMHost
  $metrics = "cpu.usage.average","mem.usage.average"

  Get-Stat -Entity $esxAll -Stat $metrics -Realtime |
  Select Timestamp,Entity,MetricId,Value
} | Select -ExpandProperty TotalMilliSeconds

The use of the Group-Object cmdlet is key when retrieving statistical data. It allows your script to execute only one Get-Stat call and then separate the retrieved metrics based on a number of properties of the returned objects.

$esx = Get-VMHost
$metrics = "net.bytesRx.average"

Get-Stat -Entity $esx -Stat $metrics |
where {$_.Instance -ne ""} |
Group-Object -Property {$_.Entity.Name,$_.Instance} |
Select @{N="VMHost";E={$_.Values[0][0]}},
  @{N="vmnic";E={$_.Values[0][1]}},
  @{N="Counter";E={$_.Group[0].MetricId}},
  @{N="Avg Received";E={
    $_.Group | Select -ExpandProperty Value |
    Measure-Object -Average | Select -ExpandProperty Average
  }},
  @{N="From";E={
    $_.Group | Sort-Object -Property Timestamp |
    Select -First 1 | Select -ExpandProperty Timestamp
  }},
  @{N="To";E={
    $_.Group | Sort-Object -Property Timestamp -Descending |
    Select -First 1 | Select -ExpandProperty Timestamp
  }} |
Format-Table -AutoSize

Annotations

Line 5: We don’t want the aggregate metric for this report, so we filter it out with a Where-clause

Line 6: The returned metrics are grouped by the name of the entity and the instance.

Line 10-13: Another cmdlet that is indispensable for working with statistical data is the Measure-Object cmdlet, it allows you to perform simple statistical functions on the data.

Line 14-20: In the results we want to see over which time period the data was collected, so we use the Timestamp on the first and the last returned metric to get these DateTime values.

The final demos showed some ways to add graphics to your reports.

The first one uses the Chart feature of Excel. With the Export-Xlsx function you easily add a chart to the worksheet or on a separate worksheet.

$esx = Get-VMHost esx1.local.test
$metric = "datastore.totalReadLatency.average"

Get-Stat -Entity $esx -Stat $metric -Realtime -MaxSamples 25 |
where {$_.Instance -ne ""} |
Sort-Object -Property Timestamp |
Group-Object -Property Timestamp | %{
  $propSplat = [ordered]@{
    Timestamp = $_.Values[0][0].ToString("hh:mm:ss")
  }
  $_.Group | Sort-Object -Property Instance | %{
    $propSplat.Add($_.Instance,$_.Value)
  }
  New-Object PSObject -Property $propSplat
} | Export-Xlsx -Path e:\skydrive\scripts\demo2a.xlsx -ChartType xlLine -WorksheetName $esx.Name

This way you have access to nearly all the charting features that are available in Excel. The result looks something like this.

You can also use a commercial product like for example PowerGadgets. They offer a number of cmdlets to produce and annotate graphs.

$esx = Get-VMHost esx1.local.test
$metric = "datastore.totalWriteLatency.average"

$array = Get-Stat -Entity $esx -Stat $metric -Realtime -MaxSamples 25 |
where {$_.Instance -ne ""} |
Sort-Object -Property Timestamp |
Group-Object -Property Timestamp | %{
  $propSplat = [ordered]@{
    Timestamp = $_.Values[0][0].ToString("hh:mm:ss")
  }
  $_.Group | Sort-Object -Property Instance | %{
    $propSplat.Add($_.Instance,$_.Value)
  }
  New-Object PSObject -Property $propSplat
}

$values = $array | gm -MemberType NoteProperty | where {$_.Name -ne "Timestamp"} | %{$_.Name}
$array | Out-Chart -Gallery Lines `
  -AllSeries_MarkerSize 0 `
  -Title "Datastore Write Latency" `
  -AxisX_Title_Text "Date" `
  -AxisY_Title_Text "msec" `
  -Values $values `
  -Label {([datetime]::Parse($_.Timestamp,$localCulture)).ToString("hh:mm:ss")}

Annotations

Line 17: In the $values variable the script collects the names of the Instances, which are the property names in the objects that were created before. These names are used to define which columns contain the data that needs to be added to the produced graph.

Line 19-24: There are numerous parameters on the Out-Chart cmdlet that can be used to annotate the produced graph.

Line 24: Since we collected the metrics in the Realtime interval we only want to see the time part of the Timestamp property. Notice how you easily use a .Net function in your PowerShell scripts.

The result looks something like this.

This post can of course not replace a “live” session, but I hope the demos that are in this post will help you to do your own discovery tour of PowerCLI, vSphere statistics and reporting.

Enjoy !

The 17th edition, the so-called “Blogger Edition“, was completely sold out. All 170 attendees, a new record, had a great day and the presenters  all gave a peak performance. The list of presenters was impressive to say the least.

I was honored to have been selected to do a presentation as well. Since it was in Belgium, I decided to give the subject of my session a local twist. The subject was PowerCLI and beer, you can’t live without them.

You’ll be missing the story I told during the presentation, but on request, the slides.

Update: all presentations are now available here (requires a VMUG account).

Thanks again to Erik Schils for organising a great VMUG meeting (and for having me). And thanks to Cisco Belgium for providing the pleasant environment.

Let’s do this again soon !

With VMFS5 comes a bunch of new features. Just to name a few:

• 64TB VMFS Volumes in 1 extent
• 64TB physical RDM
• Unified block size of 1MB
• Support for more files (> 100000)

For a complete list of the features that VMFS5 introduces, have a look at Cormac‘s post, called vSphere 5.0 Storage Features Part 1 – VMFS-5.

The vSphere 5 Client has an option to upgrade your VMFS3 datastores to VMFS5 datastores.

Handy option, but we want to automate this of course

And as a bonus I’ll throw in a function to get the partition information from a datastore.

The script

function ConvertTo-Vmfs5{
<#
.SYNOPSIS  Upgrade a datastore to VMFS5
.DESCRIPTION The function will convert the datastores that
  are passed to it to VMFS5.
.NOTES  Author:  Luc Dekens
.PARAMETER Datastore
  The datastore(s) to be upgraded
  The parameter accepts a string or an object returned by the
  Get-Datastore cmdlet.
.EXAMPLE
  PS> ConvertTo-Vmfs5 -Datastore "DS*"
.EXAMPLE
  PS> Get-Datastore -Name "DS1" | ConvertTo-Vmfs5
#>

  param(
  [CmdletBinding()]
  [parameter(Mandatory = $true, ValueFromPipeline = $true)]
  [PSObject[]]$Datastore
  )

  process{
    foreach($ds in $Datastore){
      if($ds.getType().Name -eq "string"){
        $ds = Get-Datastore -Name $ds
      }
      $poweredHosts = $ds.ExtensionData.Host | %{Get-View -Id $_.Key} |
      where {$_.Runtime.PowerState -eq "PoweredOn"}
      
      $oldHost = $poweredHosts | 
      where {$_.Capability.SupportedVmfsMajorVersion -notcontains 5}
      if($oldHost){
        Write-Warning "One of the connected hosts doesn't support VMFS5"
        exit
      }
      $vmfsPath = $ds.ExtensionData.Host[0].MountInfo.Path
      $storSys = Get-View ($poweredHosts | Get-Random).ConfigManager.StorageSystem

      $storSys.UpgradeVmfs($vmfsPath)
    }
  }
}

function Get-VmfsPartitionInfo{
<#
.SYNOPSIS  Retrieves partition info for a datastore
.DESCRIPTION The function will retrieve partition information
  for one or more datastores
.NOTES  Author:  Luc Dekens
.PARAMETER Datastore
  The datastore(s) for which the partition info shall be
  returned. The parameter accepts a string or an object
  returned by the Get-Datastore cmdlet.
.EXAMPLE
  PS> Get-VmfsPartitionInfo -Datastore "DS*"
.EXAMPLE
  PS> Get-Datastore -Name "DS1" | Get-VmfsPartitionInfo
#>
  param(
  [CmdletBinding()]
  [parameter(Mandatory = $true, ValueFromPipeline = $true)]
  [PSObject[]]$Datastore
  )

  process{
    foreach($ds in $Datastore){
      if($ds.getType().Name -eq "string"){
        $ds = Get-Datastore -Name $ds
      }
      $poweredHosts = $ds.ExtensionData.Host | %{Get-View -Id $_.Key} |
      where {$_.Runtime.PowerState -eq "PoweredOn"}
      $storSys = Get-View ($poweredHosts | Get-Random).ConfigManager.StorageSystem

      $ds.ExtensionData.Info.Vmfs.Extent | %{
        $devicePath = "/vmfs/devices/disks/" + $_.DiskName
        $storSys.RetrieveDiskPartitionInfo($devicePath) | %{
          New-Object PSObject -Property @{
            Name = $ds.Name
            Version = $ds.FileSystemVersion
            Device = $_.DeviceName
            PartitionFormat = $_.Spec.PartitionFormat
            BlockSizeMB = $ds.ExtensionData.Info.Vmfs.BlockSizeMb
            Blocks = $_.Layout.Total.Block
          }
        }
      }
    }
  }
}

Annotations

Line 25-27: A rather simple Object By Name implementation.

Line 28-29: Collect the hosts, connected to the datastore, that are powered on. The reason is that we can’t use the UpgradeVmfs method via the StorageSystem of a powered off host.

Line 31-36: Check if all the powered on and connected hosts support VMFS5. If not, leave the function.

Line 37: Get the devicepath to the datastore.

Line 38: Get the HostStorageSystem. Note that the function randomly selects 1 host from the powered on hosts. There is no real reason to do this, but I wanted to spread the method call over all available hosts.

Line 40: Convert the datastore to VMFS5

Line 68-70: Another example of my rather simple Object By Name implementation.

Line 71-73: We randomly take 1 of the connected hosts to fetch the HostStorageSystem.

Line 75: We loop through each VMFS extent of the datastore

Line 76-77: The function uses the RetrieveDiskPartitionInfo method to fetch the partition information.

Line 78-85: The function fetches the information for each partition and puts it on the pipeline as a PSObject.

Sample usage

In our vSphere 4 environment we have a number of VMFS3 datastores.

First, I use the Get-VmfsPartition function to check the partitioninfo of each datastore.

Get-Datastore DS* | Get-VmfsPartitionInfo | ft -AutoSize

The result.

Notice the BlockSizeMB column in the output, all 4 possible blocksizes for VMFS3 datastores are present.

Let’s upgrade these VMFS3 datastores to VMFS5 datastores.

Get-Datastore DS* | ConvertTo-Vmfs5

The convert function produces no output, but we can check what the new properties are with the Get-VmfsPartitionInfo function.

The VMFS version is 5.54, so the conversion worked.

But the attentive viewer might have noticed a couple of values he didn’t expect.

• The PartitionFormat still says ‘MBR’. Shouldn’t that be ‘GPT’ ?
• The BlocksizeMB stayed the same as before the VMFS5 conversion. Shouldn’t that be 1MB for VMFS5 datastores ?

The answer to both questions can be found in Cormac’s post called vSphere 5.0 Storage Features Part 1 – VMFS-5.

• A converted datastores keeps the ‘MBR’ format until it grows bigger than 2TB.
• A converted datastores keeps the original VMFS3 blocksize.

And I want to repeat Cormac’s final advise in his post, if you have the luxury to do so, it’s better to create new VMFS5 datastores instead of converting VMFS3 datastores !

VIProperty

Derived from the Get-VmfsPartitionInfo function, I created a New-VIProperty definition to return the format of the first datastore partition.

New-VIProperty -Name PartitionFormat -ObjectType Datastore `
  -Value {
    param($ds)

    $storSys = Get-View (Get-View $ds.ExtensionData.Host[0].Key).ConfigManager.StorageSystem
    $partInfo = $storSys.RetrieveDiskPartitionInfo("/vmfs/devices/disks/" + 
      $ds.ExtensionData.Info.Vmfs.Extent[0].DiskName)
    $partInfo[0].Spec.PartitionFormat
  } -Force | Out-Null

Note that you will only get the partition format (MBR or GPT) when you use this in a vSphere 5, or higher, environment. The partitionFormat property in the HostDiskPartitionSpec object is only available since API 5.

Enjoy !

Note that this feature requires distributed Switches (dvSwitch). In fact I could have also written this post in my dvSwitch series with the title dvSwitch scripting – Part 10 – NetIOC.

The script

function New-dvSwNetworkResourcePool{
<#
.SYNOPSIS Create a user-defined network resource pool
.DESCRIPTION The function will create a user-defined
  resourcepool on a specific dvSwitch.
.NOTES  Author:  Luc Dekens
.PARAMETER dvSw
  The dvSwitch on which the user-defined network resource pool
  will be created.
.PARAMETER Name
  The name of the user-defined network resource pool.
.PARAMETER Description
  The description of the user-defined network resource pool.
.PARAMETER QoSTag
  The QoSTag that will be assigned to the user-defined
  network resource pool. A value from the range 0-7.
.PARAMETER Limit
  The QoSTag that will be assigned to the user-defined
  network resource pool. A value from the range 0-7.
.PARAMETER Shares
  The number of shares allocated. Can be "low","normal","high"
  or a number (a relative value compared with the shares value
  on other resource pools in case of contention)
.EXAMPLE
  PS> New-dvSwNetworkResourcePool -dvSw $dvSw -Name "NetPool1" `
  PS>> -Description "Dutch VMUG 2011"
.EXAMPLE
  PS> New-dvSwNetworkResourcePool -dvSw $dvSw -Name "NetPool2" `
  PS>> -Description "Dutch VMUG 2011" -Shares 75 -QoSTag 3
#>
  param(
  [parameter(Position = 0, Mandatory = $true, ValueFromPipeline = $true)]
  [VMware.Vim.VmwareDistributedVirtualSwitch]$dvSw,
  [parameter(Position = 1, Mandatory = $true)]
  [string]$Name,
  [parameter(Position = 2)]
  [string]$Description,
  [string]$QoSTag,
  [long]$Limit = -1,
  [string]$Shares = "normal"
  )

  $spec = New-Object VMware.Vim.DVSNetworkResourcePoolConfigSpec
  $spec.Name = $Name
  $spec.Description = $Description
  $spec.Key = "dummy"
  $spec.allocationInfo = New-Object VMware.Vim.DVSNetworkResourcePoolAllocationInfo
  $spec.allocationInfo.Limit = $Limit
  $spec.allocationInfo.priorityTag = &{if($QoSTag){[int]$QoSTag}}
  $spec.allocationInfo.Shares = New-Object VMware.Vim.SharesInfo
  if("high","low","normal" -contains $Shares){
    $spec.allocationInfo.Shares.Level = $Shares
  }
  else{
    $spec.allocationInfo.Shares.Level = "custom"
    $spec.allocationInfo.Shares.Shares = [int]$Shares
  }

  $dvSw.AddNetworkResourcePool(@($spec))
}

function Remove-dvSwNetworkResourcePool{
<#
.SYNOPSIS Remove a user-defined network resource pool
.DESCRIPTION The function will remove a user-defined
  resource pool from a specific dvSwitch.
.NOTES  Author:  Luc Dekens
.PARAMETER dvSw
  The dvSwitch on which the user-defined network resource pool
  shall be removed.
.PARAMETER Name
  The name of the user-defined network resource pool.
.EXAMPLE
  PS> Remove-dvSwNetworkResourcePool -dvSw $dvSw -Name "NetPool1"
#>
  param(
  [parameter(Position = 0, Mandatory = $true, ValueFromPipeline = $true)]
  [VMware.Vim.VmwareDistributedVirtualSwitch]$dvSw,
  [parameter(Position = 1, Mandatory = $true)]
  [string]$Name
  )

  $pool = $dvSw.NetworkResourcePool | where {$_.Name -eq $Name}
  if($pool){
    $dvSw.RemoveNetworkResourcePool($pool.Key)
  }
}

function Get-dvSwNetworkResourcePool{
<#
.SYNOPSIS Retrieve user-defined network resource pool(s)
.DESCRIPTION The function return all or a specific set
  of user-defined network resource pools from a dvSwitch
.NOTES  Author:  Luc Dekens
.PARAMETER dvSw
  The dvSwitch from which the user-defined network resource pool
  shall be retrieved.
.PARAMETER Name
  The name of the user-defined network resource pool.
  If no name is specified, all user-defined network
  resource pools on the dvSwitch will be returned.
.EXAMPLE
  PS> Get-dvSwNetworkResourcePool -dvSw $dvSw
.EXAMPLE
  PS> Get-dvSwNetworkResourcePool -dvSw $dvSw -Name "Net*"
#>
  param(
  [parameter(Position = 0, Mandatory = $true, ValueFromPipeline = $true)]
  [VMware.Vim.VmwareDistributedVirtualSwitch]$dvSw,
  [parameter(Position = 1)]
  [string]$Name = "*"
  )

  $dvSw.UpdateViewData()
  $dvSw.NetworkResourcePool | where {$_.Name -like $Name} | %{
    New-Object PSObject -Property @{
      Name = $_.Name
      Description = $_.Description
      Limit = $_.AllocationInfo.Limit
      QoSTag = &{if($_.AllocationInfo.PriorityTag -eq 0){"none"}else{$_.AllocationInfo.PriorityTag}}
      Shares = &{if($_.AllocationInfo.Shares.Level -eq "custom"){$_.AllocationInfo.Shares.Shares}else{$_.AllocationInfo.Shares.Level}}
    }
  }
}

function Set-dvSwSIOC{
<#
.SYNOPSIS Enable/disable NetIOC on a dvSw
.DESCRIPTION The function will enable or disable
  I/O Control on a dvSwitch
.NOTES  Author:  Luc Dekens
.PARAMETER dvSw
  The dvSwitch on which I/O Control will be
  enabled/disabled
.PARAMETER Enabled
  A switch that allows control of I/O Control. When
  the switch is $True, IOC will be enabled. If $False
  IOC will be disabled
.EXAMPLE
  PS> Set-dvSwSIOC -dvSw $dvSw -Enabled
#>
  param(
  [parameter(Position = 0, Mandatory = $true, ValueFromPipeline = $true)]
  [VMware.Vim.VmwareDistributedVirtualSwitch]$dvSw,
  [parameter(Position = 1)]
  [switch]$Enabled
  )

  $dvSw.EnableNetworkResourceManagement($Enabled)
}

function Get-dvSwSIOC{
<#
.SYNOPSIS Retrieve the IOC status
.DESCRIPTION Returns the status of IOC on a dvSwitch
.NOTES  Author:  Luc Dekens
.PARAMETER dvSw
  The dvSwitch from which the status of I/O Control will be
  returned
.EXAMPLE
  PS> Get-dvSwSIOC -dvSw $dvSw -Enabled
#>
  param(
  [parameter(Position = 0, Mandatory = $true, ValueFromPipeline = $true)]
  [VMware.Vim.VmwareDistributedVirtualSwitch]$dvSw
  )

  $dvSw.UpdateViewData()
  New-Object PSObject -Property @{
    Name = $dvSw.Name
    SIOCEnabled = $dvSw.Config.NetworkResourceManagementEnabled
  }
}

Annotations

Line 38: Although the QosTag is an [int], we use the [string] cast. Otherwise the absence of the parameter would set QosTag to 0, which is a valid 802.1p value.

Line 38-40: The absence of these 3 parameters on a call to the function will create a user-defined network resource pool with the same settings as if the resource pool was created in the vSphere Client.

Line 51-57: If the Shares parameter is not set to “normal”, “high” or “low”, it will be set to “custom” and the Shares value will be used as an [int] value.

Line 80: The removal of a user-defined network resource pool requires the Name parameter to be set.

Line 111: If no Name parameter is used, all the user-defined network resource pools on the dvSwitch will be returned.

Line 114: To get the most recent data, the script refreshes the dvSwitch object.

Line 120: This test will make sure, that the function returns the same values as displayed in the vSphere Client.

Line 121: When the Shares level is “custom”, the [int] value of the share will be returned.

Sample usage

We start with an empty dvSwitch. The Get-dvSwitch function can be found in my dvSwitch scripting – Part 2 – dvPortgroup post.

First we get the dvSwitch and we get a list of the current network resource pools.

$dvSw = Get-dvSwitch -DatacenterName "DC1" -dvSwitchName "dvSw1"
Get-dvSwNetworkResourcePool -dvSw $dvSw | ft -AutoSize

This will return the system network resource pools.

The same information as we can see in the vSphere Client under System network resource pools.

Note that NetIOC is not enabled by default.

Next we create a number of user-defined network resource pools.

New-dvSwNetworkResourcePool -dvSw $dvSw -Name "NetPool1" -Description "Dutch VMUG 2011"
New-dvSwNetworkResourcePool -dvSw $dvSw -Name "NetPool2" -Description "Dutch VMUG 2011" -Shares 75 -QoSTag 3
New-dvSwNetworkResourcePool -dvSw $dvSw -Name "NetPool3" -Description "Dutch VMUG 2011" -Limit 4500
Get-dvSwNetworkResourcePool -dvSw $dvSw | ft -AutoSize

The result shows the 3 newly created network resource pools.

And we see the same in the vSphere Client.

As we noticed earlier, NetIOC is not enabled by default. Let’s display the current setting.

Get-dvSwSIOC -dvSw $dvSw | ft -AutoSize

We change the setting and retrieve the value again

Set-dvSwSIOC -dvSw $dvSw -Enabled
Get-dvSwSIOC -dvSw $dvSw | ft -AutoSize

This gives

To conclude we will clean up the demo pools and disable NetIOC again.

Set-dvSwSIOC -dvSw $dvSw -Enabled:$false

Remove-dvSwNetworkResourcePool -dvSw $dvSw -Name "NetPool1"
Remove-dvSwNetworkResourcePool -dvSw $dvSw -Name "NetPool2"
Remove-dvSwNetworkResourcePool -dvSw $dvSw -Name "NetPool3"

Enjoy !

The FDM roles

The following script will show,for each cluster node, which FDM role it holds.

function Get-DasHostState{
  param(
  [PSObject]$Cluster
  )

  if($Cluster.GetType().Name -eq "string"){
    $Cluster = Get-Cluster -Name $Cluster
  }
  Get-View $cluster.ExtensionData.Host -Property Name,Runtime.DasHostState | %{
    New-Object PSObject -Property @{
      VMHost = $_.Name
      DasHostState = $_.RunTime.DasHostState.State
      StateReporter = (Get-View -Id $_.RunTime.DasHostState.StateReporter -Property Name).Name
    }
  }
}

To call the function you can pass a clustername or the output of a Get-Cluster cmdlet. Something like this.

Get-DasHostState -Cluster Cluster1

or this

$clus = Get-Cluster -Name Cluster1
Get-DasHostState -Cluster $clus

The output looks like this

Note that there are more DasHostState values, besides master and connectedToMaster, possible. The complete list can be found in the ClusterDasFdmAvailabilityState enumeration.

And you can of course provide this functionality as a New-VIProperty.

New-VIProperty -Name "DasHostState" -ObjectType Cluster -Value {
  param($cluster)

  Get-View $cluster.ExtensionData.Host -Property Name,Runtime.DasHostState | %{
    New-Object PSObject -Property @{
      VMHost = $_.Name
      DasHostState = $_.RunTime.DasHostState.State
      StateReporter = (Get-View -Id $_.RunTime.DasHostState.StateReporter).Name
    }
  }
} -Force | Out-Null

Now you can find the FDM states with a call like this

Get-Cluster -Name London | Select -ExpandProperty DasHostState

The output will look exactly the same as the output that comes out of the Get-DasHostState function.

The heartbeat datastore

Another HA novelty in vSphere 5 is that it will now use, besides a network-based heartbeat, a datastore heartbeat, to check the presence of the nodes. To find out which of the shared datastores is used as the heartbeat datastore, you can use the following function.

function Get-DasHostState{
  param(
  [PSObject]$Cluster
  )

  if($Cluster.GetType().Name -eq "string"){
    $Cluster = Get-Cluster -Name $Cluster
  }

  $cluster.ExtensionData.RetrieveDasAdvancedRuntimeInfo()  | %{
    $_.HeartbeatDatastoreInfo | %{
      New-Object PSObject -Property @{
        Datastore = (Get-View -Id $_.Datastore).Name
        VMHosts = [string]::Join(',',($_.Hosts | %{(Get-View -Id $_).Name}))
      }
    }
  }
}

The function can be called again with the name of a cluster or with the object returned by the Get-Cluster cmdlet.

Get-DasHostState -Cluster Cluster1

The output looks something like this.

And of course, the same functionality as a New-VIProperty.

New-VIProperty -Name HeartbeatDatastore -ObjectType Cluster -Value {
  param($cluster)

  $cluster.ExtensionData.RetrieveDasAdvancedRuntimeInfo() | %{
    [String]::Join(',',($_.HeartbeatDatastoreInfo |
    %{(Get-View -Id $_.Datastore).Name}))
  }
} -Force | Out-Null

You can now use the HeartbeatDatastore property to get the datastore that is used for the heartbeat.

Get-Cluster -Name Cluster1 | Select Name, HeartbeatDatastore

Which will result in

Enjoy !

This post is the first in a series, that will publish and document most of the scripts we used for the demos.

On the first position in the Top 10 we have Storage DRS. This feature brings intelligent placement of VMs and storage load balancing based on space usage and IO metrics. See part 4, part 5 and part 6 in Cormac‘s excellent series on vSphere 5 Storage Features.

In the current PowerCLI version (5, build 435426) there is apparently only 1 cmdlet that works with Datastore Clusters, the Get-DatastoreCluster cmdlet. Unfortunately the cmdlet doesn’t seem to provide everything we came to expect from the regular PowerCLI objects. There is for example no ExtensionData property that would give us access to the server-side object for a Datastore Cluster.

The other basic actions (create, remove, configure) around Datastore Clusters are, for the time being, unfortunately missing from PowerCLI. And as you might have guessed, I felt the need to have some functions in my toolkit, that would allow me to do some basic stuff with Datastore Clusters.

The functions

Please note that the VMware vSphere API Reference refers to a Datastore Cluster as a StoragePod.

function Set-DatastoreCluster{
<#
.SYNOPSIS  Configure a DatastoreCluster
.DESCRIPTION The function is used to configure a
  DatastoreCluster. This includes the settings and
  the Datastores that are part of the cluster.
.NOTES  Author:  Luc Dekens
.PARAMETER Pod
  The StoragePod object. This can a name, an object
  returned by Get-DatastoreCluster or a StoragePod
  object.
.PARAMETER SDRSEnabled
  A switch to define is SDRS shall be enabled or not in
  the DatastoreCluster
.PARAMETER AutomationLevel
  Specifies the default SDRS behavior for virtual machines
  in the DatastoreCluster.
.PARAMETER IOMetric
  A switch whether or not SDRS takes into account storage
  I/O workload while calculating the recommendations
.PARAMETER SpaceUtilization
  When space utiixation exceeds this threshold, on one or
  more of the datastores in the DatastoreCluster, SDRS will
  generate migration recommendations.
.PARAMETER SpaceUtilizationDifference
  SDRS will generate migration recommendations when the space
  utilization difference between any of the datastores in the
  DatastoreCluster exceeds this threshold
.PARAMETER IOLatency
  When latency exceeds this threshold, on one or more of the
  datastores in the DatastoreCluster, SDRS will generate
  migration recommendations.
.PARAMETER IOLatencyDifference
  SDRS will generate migration recommendations when the IO
  latency difference between any of the datastores in the
  DatastoreCluster exceeds this threshold
.PARAMETER Interval
  The interval, in minutes, that SDRS runs to load balance
  among datastores within a DatastoreCluster 
.PARAMETER Datastore
  An array of datastores to add to the DatastoreCluster. The
  value can be a name or an object returned by Get-Datastore
.EXAMPLE
  PS> Set-DatastoreCluster -Name DSC -SDRSEnabled:$false
.EXAMPLE
  PS> Set-DatastoreCluster -Name DSC -IOLatency 25
.EXAMPLE
  PS> Set-DatastoreCluster -Name DSC -Datastore $ds
#>

param(
  [CmdletBinding()]
  [parameter(Position = 0, Mandatory = $true, ValueFromPipeline = $true)]
  [PSObject]$Pod,
  [switch]$SDRSEnabled,
  [ValidateSet("automated","manual")]
  [string]$AutomationLevel,
  [switch]$IOMetric,
  [ValidateRange(50,100)]
  [int]$SpaceUtilization,
  [ValidateRange(1,50)]
  [int]$SpaceUtilizationDifference,
  [ValidateRange(5,100)]
  [int]$IOLatency,
  [ValidateRange(1,100)]
  [int]$IOLatencyDifference,
  [ValidateRange(60,43200)]
  [int]$Interval,
  [PSObject]$Datastore
  )

  begin{
    $srm = Get-View StorageResourceManager
  }

  process{
    if($Pod.GetType().Name -eq "string"){
      $Pod = Get-StoragePod -Name $Pod
    }
    elseif($Pod.GetType().Name -eq "DatastoreClusterImpl"){
      $Pod = Get-StoragePod -Name $Pod.Name
    }
    if(!($PSCmdlet.MyInvocation.BoundParameters.Count -le 2 -and
    $PSCmdlet.MyInvocation.BoundParameters.ContainsKey("Datastore"))){
      $spec = New-Object VMware.Vim.StorageDrsConfigSpec
      $spec.podConfigSpec = New-Object VMware.Vim.StorageDrsPodConfigSpec
      $spec.podConfigSpec.DefaultIntraVmAffinity = $true
      if($AutomationLevel){
        $spec.podConfigSpec.DefaultVmBehavior = $AutomationLevel
      }
      if($SDRSEnabled){
        $spec.podConfigSpec.Enabled = $SDRSEnabled
      }
      if($IOLatency -or $IOLatencyDifference){
        $spec.podConfigSpec.IoLoadBalanceConfig = New-Object VMware.Vim.StorageDrsIoLoadBalanceConfig
        if($IOLatency){
          $spec.podConfigSpec.IoLoadBalanceConfig.IoLatencyThreshold = $IOLatency
        }
        if($IOLatencyDifference){
          $spec.podConfigSpec.IoLoadBalanceConfig.IoLoadImbalanceThreshold = $IOLatencyDifference
        }
      }
      if($IOMetric){
        $spec.podConfigSpec.IoLoadBalanceEnabled = $IOMetric
      }
      if($Interval){
        $spec.podConfigSpec.loadBalanceInterval = $Interval
      }
      if($SpaceUtilizationDifference -or $SpaceUtilization){
        $spec.podConfigSpec.spaceLoadBalanceConfig = New-Object VMware.Vim.StorageDrsSpaceLoadBalanceConfig
        if($SpaceUtilizationDifference){
          $spec.podConfigSpec.spaceLoadBalanceConfig.MinSpaceUtilizationDifference = $SpaceUtilizationDifference
        }
        if($SpaceUtilization){
          $spec.podConfigSpec.spaceLoadBalanceConfig.SpaceUtilizationThreshold = $SpaceUtilization
        }
      }

      $srm.ConfigureStorageDrsForPod($Pod.MoRef, $spec, $true)
    }

    if($Datastore){
      $dsList = $Datastore | %{
        if($_.GetType().Name -eq "string"){
          (Get-Datastore -Name $_).ExtensionData.MoRef
        }
        else{$_.ExtensionData.MoRef}
      }
      $Pod.MoveIntoFolder($dsList)
    }
  }

  end{$Pod}
}

function New-DatastoreCluster{
<#
.SYNOPSIS  Create a DatastoreCluster
.DESCRIPTION The function is used to configure a
  DatastoreCluster. This includes the settings and
  the Datastores that are part of the cluster.
.NOTES  Author:  Luc Dekens
.PARAMETER Name
  The name of the DatastoreCluster
.PARAMETER Folder
  The Folder where the DatastoreCluster shall be created.
.PARAMETER SDRSEnabled
  A switch to define is SDRS shall be enabled or not in
  the DatastoreCluster
.PARAMETER AutomationLevel
  Specifies the default SDRS behavior for virtual machines
  in the DatastoreCluster.
.PARAMETER IOMetric
  A switch whether or not SDRS takes into account storage
  I/O workload while calculating the recommendations
.PARAMETER SpaceUtilization
  When space utiixation exceeds this threshold, on one or
  more of the datastores in the DatastoreCluster, SDRS will
  generate migration recommendations.
.PARAMETER SpaceUtilizationDifference
  SDRS will generate migration recommendations when the space
  utilization difference between any of the datastores in the
  DatastoreCluster exceeds this threshold
.PARAMETER IOLatency
  When latency exceeds this threshold, on one or more of the
  datastores in the DatastoreCluster, SDRS will generate
  migration recommendations.
.PARAMETER IOLatencyDifference
  SDRS will generate migration recommendations when the IO
  latency difference between any of the datastores in the
  DatastoreCluster exceeds this threshold
.PARAMETER Interval
  The interval, in minutes, that SDRS runs to load balance
  among datastores within a DatastoreCluster 
.PARAMETER Datastore
  An array of datastores to add to the DatastoreCluster. The
  value can be a name or an object returned by Get-Datastore
.EXAMPLE
  PS> New-DatastoreCluster -Name DSC -SDRSEnabled:$false
.EXAMPLE
  PS> New-DatastoreCluster -Name DSC -IOLatency 25
.EXAMPLE
  PS> New-DatastoreCluster -Name DSC -Datastore $ds
#>

  param(
  [CmdletBinding()]
  [parameter(Position = 0, Mandatory = $true, ValueFromPipeline = $true)]
  [string]$Name,
  [parameter(Position = 1)]
  [PSObject]$Folder = "datastore",
  [switch]$SDRSEnabled = $true,
  [ValidateSet("automated","manual")]
  [string]$AutomationLevel = "automated",
  [switch]$IOMetric = $true,
  [ValidateRange(50,100)]
  [int]$SpaceUtilization = 80,
  [ValidateRange(1,50)]
  [int]$SpaceUtilizationDifference = 5,
  [ValidateRange(5,100)]
  [int]$IOLatency = 15,
  [ValidateRange(1,100)]
  [int]$IOLatencyDifference = 5,
  [ValidateRange(60,43200)]
  [int]$Interval = 480,
  [PSObject[]]$Datastore
  )

  begin{
    if($Folder.GetType().Name -eq "string"){
      $Folder = Get-Folder -Name $Folder
    }
  }

  process{
    $podMoRef = $Folder.ExtensionData.CreateStoragePod($Name)
    $Pod = Get-View -Id $podMoRef
    Set-DatastoreCluster -Pod $pod `
    -SDRSEnabled:$SDRSEnabled -AutomationLevel $AutomationLevel `
    -IOMetric:$IOMetric -SpaceUtilization $SpaceUtilization `
    -SpaceUtilizationDifference $SpaceUtilizationDifference `
    -IOLatency $IOLatency -IOLatencyDifference $IOLatencyDifference `
    -Interval $Interval
    if($Datastore){
      Set-DatastoreCluster -Pod $pod -Datastore $Datastore
    }
  }

  end{$Pod}
}

function Get-StoragePod{
<#
.SYNOPSIS  Find a DatastoreCluster
.DESCRIPTION The function will return a StoragePod object.
  This is the server-side object used by vSphere for a
  DatastoreCluster.
.NOTES  Author:  Luc Dekens
.PARAMETER Name
  The name of the DatastoreCluster
.EXAMPLE
  PS> Get-StoragePod
.EXAMPLE
  PS> Get-StoragePod -Name "SDC*"
#>

  param(
  [CmdletBinding()]
  [parameter(Position = 0, ValueFromPipeline = $true)]
  [string]$Name = "*"
  )

  begin{
   function Get-StoragePodInternal{
     param(
     [CmdletBinding()]
     [parameter(Mandatory = $true,ValueFromPipeline = $true)]
     [VMware.Vim.Folder]$Folder
     )

     $Folder.ChildEntity | %{
       if($_.Type -eq "StoragePod"){
         Get-View -Id $_
       }
       elseif($_.Type -eq "Folder"){
         Get-View -Id $_ | Get-StoragePodInternal
       }
     }
    }
  }
  
  process{
    Get-StoragePodInternal -Folder (Get-Folder -Name datastore).ExtensionData |
    where {$_.Name -like $Name}
  }
}

function Remove-DatastoreCluster{
<#
.SYNOPSIS  Remove a DatastoreCluster
.DESCRIPTION The function will remove a DatastoreCluster.
.NOTES  Author:  Luc Dekens
.PARAMETER Name
  The DatastoreCluster to be removed.
  The parameter accepts a string, an object returned by the
  Get-DatastoreCluster cmdlet or a StoragePod object, returned
  by the Get-StoragePod function
.EXAMPLE
  PS> Get-DatastoreCluster -Name "SDC" | Remove-DatastoreCluster
.EXAMPLE
  PS> Remove-DatastoreCluster -Name $pod
#>
  param(
  [CmdletBinding()]
  [parameter(Position = 0, Mandatory = $true, ValueFromPipeline = $true)]
  [PSObject]$Pod
  )

  process{
    if($Pod.GetType().Name -eq "string"){
      $Pod = Get-DatastoreCluster -Name $Pod
    }
    elseif($Pod.GetType().Name -eq "DatastoreClusterImpl"){
      $Pod = Get-StoragePod -Name $Pod.Name
    }

    $pod.Destroy()
  }
}

Annotations

Line 73: To configure a DatastoreCluster we need the StorageResourceManager

Line 76-82: A kind of Object By Name logic. This will allow the function to access the Pod parameter as a Name in a string, or as an object returned by the Get-DatastoreCluster cmdlet or as a StoragePod object.

Line 83-84: The Set-DatastoreCluster function can be used to change settings of the DatastoreCluster but also to add Datastores to the DatastoreCluster. To avoid calling the ConfigureStorageDrsForPod method when no settings have to be changed, these lines check if only the Datastore parameter was passed.

Line 85-119: These lines set up the parameters for the call to the ConfigureStorageDrsForPod method. Since the script calls this method in ‘incremetal’ mode, we only set the properties in the StorageDrsConfigSpec object that are actually set. Hence all the tests in this part of the code.

Line 122-130: This part of the function adds the Datastores to the DatastoreCluster with the MoveIntoFolder method.

Line 133: Since we want to use the functions in pipeline constructs, the function places the DatastoreCluster in the pipeline as a StoragePod object.

Line 186-207: Note that the New-DatastoreCluster function uses all the defaults that are defined in the description of the StorageDrsConfigSpec object in the VMware vSphere API Reference

Line 209-213: The Object By Name functionality for the Folder parameter.

Line 216: The creation of the DatastoreCluster through the CreateStoragePod method.

Line 218-223: The function calls the Set-DatastoreCluster function.

Line 224-226: When the call passed Datastores, these are added to the DatastoreCluster through a 2nd call to the Set-DatastoreCluster function.

Line 229: Since we want to use the functions in pipeline constructs, the function places the DatastoreCluster in the pipeline as a StoragePod object.

Line 232-276: Normally you don’t need to use this function since there is already the Get-DatastoreCluster cmdlet in PowerCLI. This function returns a StoragePod object and is primarily for internal use. An exception could be when you want to report on properties in your DatastoreCluster that are not in the object returned by the Get-DatastoreCluster cmdlet.

Line 254-269: The function uses a local function called GetStoragePodInternal in order to recursively traverse the vSphere tree.

Line 274: When the function is called with a specific Name, this Where-clause will filter out the desired StoragePod objects.

Line 300-305: A kind of Object By Name logic. This will allow the function to access the Pod parameter as a Name in a string, or as an object returned by the Get-DatastoreCluster cmdlet or as a StoragePod object.

Sample use

The following samples will show you how you can use these functions to set up, configure and remove a DatastoreCluster.

In my testlab I have set up the following simple environment to demonstrate the functions. It consists of 3 VMFS5 datastores that I want to use to create a DatastoreCluster.

First we will create a DatastoreCluster, called DSC, with 2 datastores, DS2 and DS3. The code to do that looks as follows.

New-DatastoreCluster -Name DSC -Datastore DS2,DS3

The result looks like this

Since we didn’t specify any parameters, besides the datastores, for the DatastoreCluster, the DatastoreCluster took all the defaults. As a guide, this is a table showing the defaults as used in the New-DatastoreCluster function.

Now we want to add the Datastore DS4 to this DatastoreCluster.

Get-StoragePod -Name DSC |
Set-DatastoreCluster -Datastore (Get-Datastore -Name DS4)

The result.

As a guide to understand which parameter that corresponds with which property, I made the following screenshots.

The General option.

The SDRS Automation option

The SDRS Runtime options

The other settings are currently not implemented in the functions.

The supported parameters can all be changed with the Set-DatastoreCluster function. Something like this for example.

Get-StoragePod -Name "DSC" |
Set-DatastoreCluster -Interval 240 -SpaceUtilization 70

This call changes the SDRS interval to 240 minutes or 4 hours (instead of the default 8 hours). And it changes the Utilized Space threshold to 70% (instead of the default 80%).
To remove a DatastoreCluster, you can do

Get-StoragePod -Name "DSC" | Remove-DatastoreCluster

Enjoy the functions !

To make up for this technical mishap, the demo videos with a short explanation.

Demo 1

In this video I wanted to show how you can use PowerCLI‘s Web Service Access cmdlets (Get-View and Get-ViObjectByViView) to go from automation objects to and from SDK objects.

Demo 2

The 2nd demo shows how to find your way around in the SDK objects.

It also showcases the two scripts from Dutch VMUG event 2009 – handy scripts.

Demo 3

A sample debugging session in PowerShell Plus.

Shows how to set a breakpoint and investigate the properties of SDK objects.

Demo 4

A sample workflow created with PowerWF Studio.

The workflow is executed interactively and then it is used to build a snapin.