Learn how to automate your vSphere infrastructure.
The NQN is what enables the NVMe layer to communicate to the correct endpoints on the FC fabric.
In order to find the NVMe Qualified Name for each physical ESXi host in the vCenter, connect to the vCenter, and then run the following command:
Get-VMHost | select Name,@{n='NQN';e={(Get-EsxCli -V2 -VMHost $_.Name).nvme.info.get.Invoke().HostNQN}}WWNN (World Wide Node Name) and WWPN (World Wide Port Name) are unique identifiers used in Fibre Channel and Fibre Channel over Ethernet (FCoE) storage networks.
One can read them on the UI for sure, but reading using a script will help to perform some automation tasks.
The process of reading it is explained below:
$VMHosts = Get-VMHost -State Connected,Maintenance# Empty array to store the infromation
$AllVMHostHBAInfo = @()
# Loop for each object
foreach($VMHost in $VMhosts){
# For each host get collect the information and store it to the variable $VMHostHBAs
# like Device, Status, Driver, Model
# also convert WWPN and WWNN decimal format to a more readable value
$VMHostHBAs = $VMHost | Get-VMHostHba -Type FibreChannel | Select-Object Device, Status, Driver, Model, @{n='WWPN';e={$wwpn = "{0:x}" -f $_.PortWorldWideName; (0..7 | ForEach-Object {$wwpn.Substring($_*2,2)})}}, @{n='WWNN';e={$wwnn = "{0:x}" -f $_.PortWorldWideName; (0..7 | ForEach-Object {$wwnn.Substring($_*2,2)})}}
# Foreach Hba for that host
foreach($VMHostHBA in $VMHostHBAs){
# Create a hash-table and store the information
# foreach host, and then for each Hba in that host
# I used [ordered] - as I want the infromation below to be in this order when it is generated
$props = [ordered]@{}
$props.'vCenter' = $VMHost.vCenter
$props.'Cluster' = $VMHost.Parent.Name
$props.'VMHost' = $VMHost.Name
$props.'Device' = $VMHostHBA.Device
$props.'Status' = $VMHostHBA.Status
$props.'Driver' = $VMHostHBA.Driver
$props.'Model' = $VMHostHBA.Model
$props.'WWPN' = $VMHostHBA.WWPN
$props.'WWNN' = $VMHostHBA.WWNN
# Collect and store the inforamtion in to the Emtpy array that was created above
$AllVMHostHBAInfo += New-Object -TypeName PSCustomObject -Property $Props
}
}The result will look like this. Of course the data in the picture below is obfuscated.
The real data that will be generated on your environment will be used on scripts to perform other tasks, or as reporting.
Last but not least, you can create a function which can be used by anyone in your team. Add this function your PS module. It is going to look like this:
The function:
function Read-HBAFCWWPNandWWNNInfo {
param($VMHost)
# Connect on all vCenters
Connect-vCenter
# Empty array to store the infromation
$AllVMHostHBAInfo = @()
# Loop for each object
foreach($VMHost in $VMhosts){
# For each host get collect the information and store it to the variable $VMHostHBAs
# like Device, Status, Driver, Model
# also convert WWPN and WWNN decimal format to a more readable value
$VMHostHBAs = $VMHost | Get-VMHostHba -Type FibreChannel | Select-Object Device, Status, Driver, Model, @{n='WWPN';e={$wwpn = "{0:x}" -f $_.PortWorldWideName; (0..7 | ForEach-Object {$wwpn.Substring($_*2,2)})}}, @{n='WWNN';e={$wwnn = "{0:x}" -f $_.PortWorldWideName; (0..7 | ForEach-Object {$wwnn.Substring($_*2,2)})}}
# Foreach Hba for that host
foreach($VMHostHBA in $VMHostHBAs){
# Create a hash-table and store the information
# foreach host, and then for each Hba in that host
# I used [ordered] - as I want the infromation below to be in this order when it is generated
$props = [ordered]@{}
$props.'vCenter' = $VMHost.vCenter
$props.'Cluster' = $VMHost.Parent.Name
$props.'VMHost' = $VMHost.Name
$props.'Device' = $VMHostHBA.Device
$props.'Status' = $VMHostHBA.Status
$props.'Driver' = $VMHostHBA.Driver
$props.'Model' = $VMHostHBA.Model
$props.'WWPN' = $VMHostHBA.WWPN
$props.'WWNN' = $VMHostHBA.WWNN
# Collect and store the inforamtion in to the Emtpy array that was created above
$AllVMHostHBAInfo += New-Object -TypeName PSCustomObject -Property $Props
}
}
return $AllVMHostHBAInfo
}ViProperties in PowerCLI refer to the object properties retrieved for example, using the Get-VM cmdlet. These properties include essential information about virtual machines in VMware environments, such as their names, power state, hardware configuration, and more. ViProperties serve as the foundation for managing and automating virtual machine tasks in PowerCLI, allowing administrators to gather critical data and make informed decisions about their VMware infrastructure.
Find the vCenter where the object (VM, VMHost, Datastore, VMHost, Cluster) is stored to.
New-VIProperty -Name vCenter -ObjectType VirtualMachine -Value {
param($obj)
return (($obj.uid -split ":")[0] -split "@")[1]
} -Force | Out-Null
New-VIProperty -Name vCenter -ObjectType VMHost -Value {
param($obj)
return (($obj.uid -split ":")[0] -split "@")[1]
} -Force | Out-Null
New-VIProperty -Name vCenter -ObjectType Cluster -Value {
param($obj)
return (($obj.uid -split ":")[0] -split "@")[1]
} -Force | Out-Null
New-VIProperty -Name vCenter -ObjectType Datastore -Value {
param($obj)
return (($obj.uid -split ":")[0] -split "@")[1]
} -Force | Out-NullAfter they’re created, then someone may use them as mentioned in the example below:
Get-VM | Select Name, vCenter
Get-VMHost | Select Name, vCenterThese custom VI Properties can be packed into a function, that can be used whenever you connect to vCenter, otherwise you don’t need them.
Packing into a function is easy, the code can be found below:
function Create-VIProperties {
New-VIProperty -Name vCenter -ObjectType VirtualMachine -Value {
param($obj)
return (($obj.uid -split ":")[0] -split "@")[1]
} -Force | Out-Null
New-VIProperty -Name vCenter -ObjectType VMHost -Value {
param($obj)
return (($obj.uid -split ":")[0] -split "@")[1]
} -Force | Out-Null
New-VIProperty -Name vCenter -ObjectType Cluster -Value {
param($obj)
return (($obj.uid -split ":")[0] -split "@")[1]
} -Force | Out-Null
New-VIProperty -Name vCenter -ObjectType Datastore -Value {
param($obj)
return (($obj.uid -split ":")[0] -split "@")[1]
} -Force | Out-Null
}Not only you can put this function to the PS Module but it can be put within the Connect-vCenter function so that whenever you call the function the necessary VI Properties will be created.
Aliases in PowerCLI are shortcuts or alternative names for PowerShell cmdlets and functions. They provide a convenient way to execute common commands with shorter and more intuitive names. Aliases make PowerCLI scripting faster and more user-friendly by reducing the need for typing lengthy cmdlet names. While they enhance productivity, it’s important to use them judiciously and consider readability when sharing scripts with others, as excessive use of aliases can make code less clear and maintainable.
Aliases that I use on my daily work are:
PowerShell profiles might sound like a tech insider’s secret, but they’re a valuable tool for anyone who uses PowerShell regularly. In this brief blog, we’ll uncover why PowerShell profiles are important and what you can achieve with them.
A PowerShell profile is a script that runs when you start a PowerShell session. Think of it as your personalized setup for PowerShell. It allows you to define custom configurations, functions, and aliases that streamline your PowerShell experience.
In essence, PowerShell profiles empower you to make PowerShell your own. They transform it from a powerful command-line tool into a personalized, efficient, and consistent environment. Don’t miss out on the advantages – start crafting your PowerShell profile today to unlock your full PowerShell potential!
Some important things that you can include into profiles are:
PowerShell supports several profile files that are scoped to users and PowerShell hosts. You can have any or all these profiles on your computer.
For example, the PowerShell console supports the following basic profile files. The profiles are listed in order that they’re executed. More info.
$PSHOME\Profile.ps1$PSHOME\Microsoft.PowerShell_profile.ps1$HOME\Documents\WindowsPowerShell\Profile.ps1$HOME\Documents\WindowsPowerShell\Microsoft.PowerShell_profile.ps1Whatever you put into this file “$HOME\Documents\WindowsPowerShell\Profile.ps1” it will be loaded for all hosts (PS and ISE) for the current user.
Configuring PowerCLI settings using the Set-PowerCLIConfiguration cmdlet is a straightforward process that can greatly enhance your PowerCLI experience. It has different options which can be read by reading the help of it. However, two most important in my point of view are DefaultVIServerMode and Scope.
With the DefaultVIServerMode one should be careful as you may be connected to multiple vCenters on different environments (Test, or Prod) and think that you’re connected only to one server and run something which could affect Production as well. If someone know what he/she is doing or if he/she writes scripts which point exactly to a vCenter by utilizing -Server parameter of each cmdlet, then Multiple value would make more sense as it is easier to work with multiple environments.
This information can be read using Get-PowerCLIConfiguration cmdlet.
As organizations expand their virtual infrastructure, managing multiple vCenter servers becomes a common scenario. VMware’s vCenter Server provides a centralized platform for managing virtualized environments, but handling numerous vCenter servers can be overwhelming. Instead of repeatedly executing the “Connect-VIServer” command for each server, you can streamline the process by creating your own wrapper script. In this blog, we’ll explore why dealing with multiple vCenters is crucial and how building a wrapper script can simplify your management tasks.
Why Manage Multiple vCenters?
Large enterprises and service providers often operate multiple vCenter servers for various reasons, such as:
The Challenge: Connecting to Multiple vCenters
When dealing with multiple vCenters, a common challenge is connecting to each server individually using the “Connect-VIServer” command. Executing this command every time you need to manage a different vCenter can be time-consuming and cumbersome, especially if you have a complex infrastructure with many servers.
The Solution: Building Your Own Wrapper
To simplify the management of multiple vCenters, you can create your own wrapper script in PowerShell. This script automates the connection process, allowing you to manage multiple vCenters seamlessly. Here’s how you can build one:
Create a configuration file or PowerShell script that contains details about your vCenter servers, such as their names, IP addresses. Storing this information on a central location is crucial. Whenever, new vCenters come into play, you have to update the configuration file where it will be used by the wrapper.
There are different ways to store the information centraly.
Below is an example on how to write a wrapper.
Create a function:
function Connect-vCenter {
}Define the list of vCenters:
$ListOfvCenters = 'vcenter1.yourdomain.local','vcenter2.yourdomain.local'Ask for credentials:
$vCenterCredentials = Get-Credential -Message "Provide your vCenter credential"Connect to all vCenters:
Connect-VIServer -Server $ListOfvCenters -Credential $vCenterCredenialsCombine everything into a usable function
function Connect-vCenter {
# Define your vCenters
$ListOfvCenters = 'vcenter1.yourdomain.local','vcenter2.yourdomain.local'
# Request your vCenter credential
$vCenterCredentials = Get-Credential -Message "Provide your vCenter credential"
# Connect to your vCenters
Connect-VIServer -Server $ListOfvCenters -Credential $vCenterCredenials
}The function can be imported into your actual opened console by dot sourcing it. That can be done by placing a . (dot) in front of the full path. For example:
. "C:\Users\Administrator\Documents\Connect-vCenter.ps1" Then you can call the function Connect-vCenter
Otherwise, you can create a PS Module and place your functions there. A PowerShell module is like an army Swiss knife for your computer. Just as a Swiss knife packs multiple tools into one handy device, a PowerShell module bundles various commands and functions into a single, cohesive package. More info can be found here: Create a PowerShell Module
Besides that, the function for creating VI Properties can be added into the Connect-vCenter function. So, whenever you connect to the vCenters, the VI properties will be created
function Connect-vCenter {
# Define your vCenters
$ListOfvCenters = 'vcenter1.yourdomain.local','vcenter2.yourdomain.local'
# Request your vCenter credential
$vCenterCredentials = Get-Credential -Message "Provide your vCenter credential"
# Connect to your vCenters
Connect-VIServer -Server $ListOfvCenters -Credential $vCenterCredenials
# Create the necessary VI Properties
Create-VIProperties
}
A PowerShell module is like an army Swiss knife for your computer. Just as a Swiss knife packs multiple tools into one handy device, a PowerShell module bundles various commands and functions into a single, cohesive package.
Creating your own PowerShell module is beneficial because it:
Creating a PS Module is a straight forward process. The locations where you can place your PS module can be found by executing this command:
(ls env:\PSModulePath).Value -split ";"Within one of those folders, you have to create a folder with the name of the Module and inside create a psm1 file with the same name as the module. The path should look like this: C:\Users\<yourUser>\Documents\WindowsPowerShell\Modules\<moduleName>\<moduleName>.psm1
e.g. When the module is called psclimodule:
C:\Users\Admin\Documents\WindowsPowerShell\Modules\psclimodule\psclimodule.psm1 The functions you create can be stored within that file, and then they are imported automatically when you call a function from that module.
Gitea is an open-source, web-based platform designed for hosting and managing Git repositories. It serves as a lightweight and self-hosted alternative to popular Git repository hosting services like GitHub and GitLab.
Deploying it is an easy process. However, you have to maintain it by installing updates and backing it up.
New-Service -Name "Gitea" -BinaryPathName "C:\Program Files\gitea\gitea.exe" -StartupType "Automatic" -Description "Gitea"Gitea then can be accessed via your browser from the network. http://fqdn:3000 or http://ip:3000
PowerCLI, developed by VMware, is a command-line interface (CLI) tool that allows administrators and developers to manage and automate various tasks in VMware environments. It provides a powerful set of cmdlets for managing virtual infrastructure, making it an essential tool for anyone working with VMware technologies.
In this article, we will explore one method of installing PowerCLI to help you get started with managing your VMware infrastructure efficiently.
Installing PowerCLI via PowerShell Gallery
One of the most straightforward ways to install PowerCLI is by utilizing PowerShell’s built-in package management features and the PowerShell Gallery. Here’s how you can do it:
Install-Module -Name VMware.PowerCLIAfter the installation is completed, it can be verified by looking at which modules are installed by executing the following command:
Get-Module -ListAvailable -Name VMware*
© 2024 PowerCli scripting
Theme by Anders Noren — Up ↑