For the installation of software on the instance we use the user-data YAML file. In the following sections, we discuss some of the more obvious candidates you want to have on your station. Remember that the basic idea of the series is to have a “cattle” station to test/run (and optionally develop) your scripts.

Scripting Packages

PowerShell

Let’s start by installing PowerShell on the instance. This comes down to adding a couple of instructions to the YAML file we used in Part 1.

#cloud-config
hostname: ubuntubionicps
fqdn: ubuntubionicps.local.lab
write_files:
- path: /etc/netplan/50-cloud-init.yaml
  content: |
    network:
     version: 2
     ethernets:
      ens192:
       addresses: [192.168.10.82/24]
       gateway4: 192.168.10.1
       dhcp6: false
       nameservers:
         addresses:
           - 192.168.10.2
           - 192.168.10.3
         search:
           - local.lab
       dhcp4: false
       optional: true
- path: /etc/sysctl.d/60-disable-ipv6.conf
  owner: root
  content: |
    net.ipv6.conf.all.disable_ipv6=1
    net.ipv6.conf.default.disable_ipv6=1
runcmd:
- netplan --debug apply
- sysctl -w net.ipv6.conf.all.disable_ipv6=1
- sysctl -w net.ipv6.conf.default.disable_ipv6=1
- apt-get -y update
- add-apt-repository universe
# PowerShell
- wget https://raw.githubusercontent.com/PowerShell/PowerShell/master/tools/install-powershell.sh
- chmod 755 install-powershell.sh
# PowerShell v6
- ./install-powershell.sh
# PowerShell v7
- ./install-powershell.sh -preview
- apt-get -y clean
- apt-get -y autoremove --purge
timezone: Europe/Brussels
system_info:
  default_user:
    name: default-user
    lock_passwd: false
    sudo: ["ALL=(ALL) NOPASSWD:ALL"]
disable_root: false
ssh_pwauth: yes
users:
  - default
  - name: luc
    gecos: LucD
    lock_passwd: false
    groups: sudo, users, admin
    shell: /bin/bash
    sudo: ['ALL=(ALL) NOPASSWD:ALL']
chpasswd:
  list: |
    default-user:$6$aPp//e2ueP$ETEXcAhAyQuJ4qNCbqxmmSYGZbg2wFwpP/YITvoXdgxwZBnf32drePKi2OIn5fLqtH5pHO03yRdPXK3ToLG6b0
    luc:$6$kW1WwJ2K$M6415du1BZd.qt92SvR6X.RuyDhEZmgR4hz4NcKH9XHn2850Vc6zHpubXM6uUeqMUaJQ740ogROB74gfBEhn9.
    root:$6$Js9CVr06$br9qf0VxuBsdY7Vtg/0pk9jLlycYBDLVsvbKwLDleCK7dSDheOxWaFOWdjkiqSPRrWG./N8V5RgCVwugZGnTc1
  expire: false
package_upgrade: true
package_reboot_if_required: true
power_state:
  delay: now
  mode: reboot
  message: Rebooting the OS
  condition: if [ -e /var/run/reboot-required ]; then exit 0; else exit 1; fi

Annotations

Line 33-39: The instructions to install PowerShell are added to the runcmd section.

Line 33: You can use comments in your YAML file. I highly recommend doing that. It will help others, and probably yourself later on.

Line 34-35: The method uses the install-powershell.sh bash script to install the latest PowerShell v6 and the latest PowerShell v7 Preview. I personally prefer this method vs the apt-get method, since it is globally usable on multiple Linux distributions. The install-powershell.sh script determines on which distro it is running, and launches the appropriate command(s).

Result

Git & repo cloning

For your scripts, you, of course, use a repository. That means you will need to configure git, and a way to clone repositories to your instance.

The following extract of the YAML file only shows the lines in the runcmd section.

runcmd:
- netplan --debug apply
- sysctl -w net.ipv6.conf.all.disable_ipv6=1
- sysctl -w net.ipv6.conf.default.disable_ipv6=1
- apt-get -y update
- add-apt-repository universe
# PowerShell
- wget https://raw.githubusercontent.com/PowerShell/PowerShell/master/tools/install-powershell.sh
- chmod 755 install-powershell.sh
# PowerShell v6
- ./install-powershell.sh
# PowerShell v7
- ./install-powershell.sh -preview
# Git
- git config --global user.name "LucD"
- git config --global user.email "lucd@lucd.info"
- mkdir /home/luc/vCheck-vSphere
- chown luc:luc /home/luc/vCheck-vSphere
- git clone https://github.com/alanrenouf/vCheck-vSphere /home/luc/vCheck-vSphere
- apt-get -y clean
- apt-get -y autoremove --purge

Annotations

Line 14-16: Since git is by default installed in the Ubuntu 18.04 LTS Cloud Image OVA file, we only need to configure some settings. In this we update some configuration settings, primarily to be able to correct sign off commits.

Line 17-19: As part of the deployment process through cloud-init, you can clone specific repositories to the instance. In these lines I used Alan Renouf‘s vCheck-vSphere repository as an example.

Result

Going GUI

There might be occasions when you need to provide a temporary station with a GUI. That can also be done with cloud-init’s user-data YAML file.

The Desktop

The choice of which desktop and which desktop manager is completely up to you. Just be aware that some of these might require more resources to be assigned to the instance.

The following sample is intended for an Ubuntu 18.04 LTS instance. Again this extract only shows the runcmd section of the YAML file.

# Install GUI
- apt-get install -y tasksel
- tasksel install lubuntu-core
# ==> know issue
- apt-get --purge remove -y light-locker
- service lightdm start
# Install RDP
- apt-get install -y apt-transport-https
- apt-get install -y xrdp
- systemctl enable xrdp

Annotations

Line 1-10: In this example, I use lubuntu as the desktop. Primarily because it is fast and resource-friendly.

Line 2: We use tasksel to install the desktop, so we have to make sure that it is available.

Line 5: There is a known issue with the light-locker package. Until a final fix is available, the easiest solution is to just uninstall it. If you absolutely need a screen-saver, install one of the alternatives. Like for example xscreensaver.

Line 6: Next we start the display manager lightdm.

Line 7-10: We need a way to connect to the station we are deploying. In this example, I opted for RDP as my protocol.

Line 8: The apt-transport-https package is a pre-requisite.

Line 10: Configure the xrdp service to automatically start at the boot.

Visual Studio Code

Now that we have a GUI, we can use several GUI based applications. For working with PowerShell, the Visual Studio Code editor with the PowerShell extension is an obvious choice.

# Install Visual Studio Code
- add-apt-repository "deb [arch=amd64] https://packages.microsoft.com/repos/vscode stable main"
- apt-get update
- apt-get install -y code
- mkdir /home/luc/.vscode
- chown luc:luc /home/luc/.vscode
- code --install-extension ms-vscode.powershell --user-data-dir /home/luc/.vscode/ --extensions-dir /home/luc/.vscode/extensions/
- code --install-extension eamodio.gitlens --user-data-dir /home/luc/.vscode --extensions-dir /home/luc/.vscode/extensions/

Annotations

Line 2-4: The standard installation procedure for Code on a Linux platform.

Line 5-8: This installs the extensions for PowerShell and GitLens. Remember that the cloud-init stages run under the root account, if you need to install packages for a user, make sure to change the owner.

Result

Conclusion

We have now set the stage to actually start using these instances. In one of the next posts in this cloud-init series, we will show how to run scripts on these stations.

If you have suggestions or questions about specific additions on these instances, feel free to use the comments.

Enjoy!

VSC offers features that are currently not present in the PowerShell ISE, one of the more important ones for now being Git support. And another, not negligible feature, VSC is a free product. On the VMware{code} powercli Slack channel, which you should check out, the new editor was discussed briefly.

With the 0.6.0 release of PowerShell for VS@Code, a couple of important new features were introduced. For the PowerCLI users, the addition of a VSC specific ‘profile‘, makes editing your PowerCLI scripts in VSC a lot easier. Want to try it out, read on!

Setting up VSC for PowerCLI

PowerCLI, at the time of writing, still consists of a number of PSSnapins and Modules. In my Universal PowerCLI Loader post, I introduced a generic function, named Enable-PowerCLI, that will, for each official PowerCLI release, make sure that all PSSnapins and Modules (from v6.* onwards) are loaded. We will use this function to set up PowerCLI in our VSC.

The VSC profile is stored in a file called “%UserProfile%\Documents\WindowsPowerShell\Microsoft.VSCode_profile.ps1“.

In that file I store my Enable-PowerCLI function, and at the end of the file I call the function.

Since the PowerShell for VS@Code 0.6.1 release, the execution of the profile.ps1 is set to true by default. You can skip the following paragraph.

In the 0.6.0 release, the execution of the profile was not set by default. You could enable this via the <File><Preferences><User Settings> menu entry. In the editor the default settings and your personal settings.json file are opened. In your settings.json file, enter the line “powershell.enableProfileLoading”: true, this will make sure the profile.ps1 is executed the next time you open VSC.

Now restart your VSC, and lo and behold, all PowerCLI cmdlets are known and available under Intellisense.

Snippets

In VSC there is a snippet feature, which allows you to define a code block that can be called by using a shortname in the editor. This is a handy way to have your PowerCLI code templates available at all times, no need to learn by hearth or “feeling lucky” in the search engine of your choice.

A snippet is packaged in a JSON file. The snippets file for PowerShell is “%appdata%\Code\User\snippets\powershell.json”. In that file you have one or more snippets of code.

The following is a short example of template code for the Get-Stat cmdlet for VMs.

In the snippets folder in the powershell.json file we add the definition for the PCLIStatVM snippet.

We can now call the snippet by just entering the name.

When we hit <Enter>, while the entry is selected, the code will be inserted in our current document.

The syntax of a VSC snippet is documented in the online VSC documentation.

PowerShell Editor Services

The PowerShell Editor Services offer a common extensibility model which allows one to write extension code in PowerShell. In the 0.6.0 release this is now made available through the $psEditor object and the Register-EditorCommand cmdlet. More information can be found in the, also newly introduced, PowerShell Editor Services documentation.

As an example of the use of the Register-EditorCommand I created the following example. It adds a command to the VSC that allows me to open a browser with the pages I normally use as reference and help when I work with PowerCLI. Add the following code to your profile.ps1 file.

$pclihelp = {
  $browser = 'chrome.exe'
  $pclisites = 'https://communities.vmware.com/community/vmtn/automationtools/powercli/content?filterID=contentstatus[published]~objecttype~objecttype[thread]',
  'https://www.vmware.com/support/developer/PowerCLI/PowerCLI63R1/html/index.html',
  'https://pubs.vmware.com/vsphere-60/topic/com.vmware.wssdk.apiref.doc/right-pane.html',
  'https://blogs.vmware.com/PowerCLI',
  'https://lucd.info'
  
  Start-Process $browser $pclisites
}

Register-EditorCommand `
-Name "PowerCLI.HelpSites" `
-DisplayName "PowerCLI Help Sites" `
-ScriptBlock $pclihelp

In the VSC you can now use this new command as the following short video will show.

A second example will actually allow you to act on selected text in the editor. With the EditorContext object you can actually what the user has selected, and take action accordingly. In this trivial example it takes the PowerCLI cmdlet that was selected, and open the online Help page for that cmdlet. Note that there is no checking implemented whatsoever, if you select something else than a PowerCLI cmdlet, the browser will go to an invalid page.

$pclicmdhelp = {
  param([Microsoft.PowerShell.EditorServices.Extensions.EditorContext]$context)

  $cmdlet = $context.CurrentFile.GetText($context.SelectedRange)
  $browser = 'chrome.exe'
  $cmdhelp = "https://www.vmware.com/support/developer/PowerCLI/PowerCLI63R1/html/$($cmdlet).html"
  
  Start-Process $browser $cmdhelp
}

Register-EditorCommand `
-Name "PowerCLI.HelpCmdlet" `
-DisplayName "PowerCLI Cmdlet Help" `
-ScriptBlock $pclicmdhelp

And a short video that shows how this works.

• Select the PowerCLI cmdlet
• Press <F1>
• Type ‘ps ad’ and the fuzzy search will bring you to the additional commands menu
• Select the PowerCLI Cmdlet Help

In this third example, I show how you can interrogate the AST and also how you can send feedback to the user. This command counts the different cmdlets and variables that are present in the file. And displays the result in the Output area.

$pscountcmdlet = {
  param([Microsoft.PowerShell.EditorServices.Extensions.EditorContext]$context)

  $cmdArr = @()
  $varArr = @()
  foreach($token in $context.CurrentFile.Tokens){
    switch($token.GetType().Name){
      'StringLiteralToken'{
        if($token.TokenFlags -eq 'CommandName'){
          $cmdArr += $token.Value
        }
      }
      'VariableToken'{
        $varArr += $token.Name
      }
    }
  }

  $cmdArr = $cmdArr | Sort-Object -Unique
  $varArr = $varArr | Sort-Object -Unique

  Write-Output "You used $($cmdArr.Count) different cmdlets"
  Write-Output "`t$($cmdArr -join '|')"
  Write-Output "You used $($varArr.Count) different variables"
  Write-Output "`t$($varArr -join '|')"
}

Register-EditorCommand `
-Name "PowerShell.CountCmdletVar" `
-DisplayName "Count Cmdlets/Variables" `
-ScriptBlock $pscountcmdlet

And a short video to demonstrate.

At the end of this post, you can download a sample VSC profile.ps1, it contains the PowerCLI Universal Loader function and the Register-EditorCommand example.

I’m currently still exploring all the possibilities of the the VS@Code and PowerShell for VS@Code. There is a whole lot more to discover, and I intend to keep this post updated with new discoveries and additional features that will come in future releases.

If you want to play with VSC and the PowerShell feature, there are a couple of excellent blog posts from Keith Hill, that will help you get started.

Getting Started with Visual Studio Code for Use with PowerShell
Debugging PowerShell Script with Visual Studio Code

And there is of course the extensive, online VSC documentation.

Enjoy!