VCF Operations Dashboard | ESXi Tiered Memory

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# Update the System:
sudo dnf update -y

# Install Python:
sudo dnf install python3 -y

# Install Pip (Python Package Manager):
sudo dnf install python3-pip -y

# Install FastAPI and Uvicorn:
pip3 install fastapi uvicorn

# Create a Sample FastAPI Application:
nano app.py

# Add the following content to app.py:
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "World"}


# You can run your app using uvicorn:
uvicorn app:app --host 0.0.0.0 --port 8000

# Your FastAPI app should now be accessible at:
http://<your_server_ip>:8000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

import subprocess
from fastapi import FastAPI
from fastapi.responses import PlainTextResponse

app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "Welcome to the FastAPI Server by vCROCS!"}

@app.get("/tieredVM")
async def run_powershell_script():
    try:
        # Run the PowerShell script and capture the output
        result = subprocess.run(["pwsh", "-File", "/root/tieredVM.ps1"], capture_output=True, text=True)
        
        # Check if there's an error in the execution
        if result.returncode != 0:
            return PlainTextResponse(content=result.stderr, status_code=500)

        # Return the raw output from the PowerShell script without modification
        return PlainTextResponse(content=result.stdout.strip())
    
    except Exception as e:
        return PlainTextResponse(content=str(e), status_code=500)

 
@app.get("/tieredHost")
async def run_powershell_script():
    try:
        # Run the PowerShell script and capture the output
        result = subprocess.run(["pwsh", "-File", "/root/tieredHost.ps1"], capture_output=True, text=True)
        
        # Check if there's an error in the execution
        if result.returncode != 0:
            return PlainTextResponse(content=result.stderr, status_code=500)

        # Return the raw output from the PowerShell script without modification
        return PlainTextResponse(content=result.stdout.strip())
    
    except Exception as e:
        return PlainTextResponse(content=str(e), status_code=500)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

# The Posh-SSH and VMware PowerCLI modules are required to run this script
# Import the Posh-SSH and VMware PowerCLI modules
#Import-Module Posh-SSH
#Import-Module VMware.PowerCLI

# Define parameters for the Connect-VIServer cmdlet using splatting. Use a more secure method for passwords.
$ConnectionParams = @{
    Server   = "192.168.6.100"
    User     = "administrator@vcrocs.local"
    Password = "VMware1!"
    Force    = $true
}

# Connect to the vCenter Server
$vCenter = Connect-VIServer @ConnectionParams

# Get all ESXi hosts in the vCenter
$esxiHosts = Get-VMHost

# Create an empty array to store combined results
$combinedResults = @()

# Loop through each host
foreach ($esxiHost in $esxiHosts) {
    # Define ESXi SSH connection details
    $server = $esxiHost.Name
    $username = "root"
    $password = "VMware1!"  # Use a more secure method for passwords

    # Convert the password to a SecureString and create a PSCredential object
    $securePassword = ConvertTo-SecureString -String $password -AsPlainText -Force
    $credential = New-Object System.Management.Automation.PSCredential($username, $securePassword)

    # Try to establish an SSH session, skip host if connection fails
    Try {
        #Write-Host "Attempting to connect to $server..."
        $sshSession = New-SSHSession -ComputerName $server -Credential $credential -AcceptKey -ErrorAction Stop
        #Write-Host "Connected to $server."
    }
    Catch {
        #Write-Host "Failed to connect to $server. Skipping host..." -ForegroundColor Yellow
        Continue
    }

    # If SSH session is successful, execute the commands
    if ($sshSession) {
        # Define and execute the first SSH command to get the VMX Cartel IDs and Display Names
        $vmCommand = "esxcli --formatter csv vm process list | cut -d ',' -f 2,5"
        $vmResult = Invoke-SSHCommand -SessionId $sshSession.SessionId -Command $vmCommand
        $VMXCartelID = $vmResult.Output | ConvertFrom-Csv

        # Define and execute the second SSH command to get memory statistics
        $memCommand = 'memstats -r vmtier-stats -u mb -s name:memSize:active:tier0Consumed:tier1Consumed'
        $memResult = Invoke-SSHCommand -SessionId $sshSession.SessionId -Command $memCommand

        # Process the memory statistics output
        $lines = $memResult.Output -split "`n" | ForEach-Object { $_.Trim() } | Where-Object {
            $_ -notmatch '^-{2,}|Total|Start|No.|VIRTUAL|Unit|Selected'
        }

        # Regex pattern for memory statistics
        $pattern = '^(?<name>\S+)\s+(?<memSize>\d+)\s+(?<active>\d+)\s+(?<tier0Consumed>\d+)\s+(?<tier1Consumed>\d+)$'

        # Array to store parsed memory stats
        $tieredMEM = @()

        # Parse the memory stats
        foreach ($line in $lines) {
            if ($line -match $pattern) {
                $tieredMEM += [pscustomobject]@{
                    Name               = $matches['name']
                    vm_MemSize_MB      = [int]$matches['memSize']
                    vm_Active_Mem_MB   = [int]$matches['active']
                    "vm_Tier0_RAM_MB"  = [int]$matches['tier0Consumed']
                    "vm_Tier1_NVMe_MB" = [int]$matches['tier1Consumed']
                }
            }
        }

        # Remove 'vm.' prefix from each VM Name
        $tieredMEM | ForEach-Object { $_.Name = $_.Name -replace '^vm\.', '' }

        # Create a hashtable for easy mapping of VMX Cartel IDs to Display Names
        $vmNameMap = @{}
        foreach ($entry in $VMXCartelID) {
            $vmNameMap[$entry.VMXCartelID] = $entry.DisplayName
        }

        # Replace the Name field in $tieredMEM with the corresponding DisplayName
        foreach ($vm in $tieredMEM) {
            if ($vmNameMap.ContainsKey($vm.Name)) {
                $vm.Name = $vmNameMap[$vm.Name]
            }
        }

        # Filter out rows where the Name starts with "vCLS-"
        $tieredMEM = $tieredMEM | Where-Object { $_.Name -notlike "vCLS-*" }

        # Append the results from this host to the combined results array
        $combinedResults += $tieredMEM

        # Close the SSH session for this host
        $removeSession = Remove-SSHSession -SessionId $sshSession.SessionId
    }
}

# Convert the combined result to json
$returnData = $combinedResults | ConvertTo-Json -Compress

return $returnData

# Disconnect from vCenter
Disconnect-VIServer -Confirm:$false

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

# Most of this Code from William Lam Blog Post
# https://williamlam.com/2024/10/useful-nvme-tiering-reporting-using-vsphere-8-0-update-3-apis.html
# I changed the code to test in my Lab. Select all hosts 8.0.3 or greater. Convert results to json to work with MPB.

# Define parameters for the Connect-VIServer cmdlet using splatting
$ConnectionParams = @{
    Server   = "192.168.6.100"
    User     = "administrator@vcrocs.local"
    Password = "VMware1!"
    Force    = $true
}

# Connect to the vCenter Server
$vCenter = Connect-VIServer @ConnectionParams

$vmHosts = Get-VMhost | Where-Object {$_.Version -ge "8.0.3"} | Sort-Object Name

$results = @()
foreach ($vmhost in $vmHosts) {
    $hostID = $vmhost.Id
    $hostID = $hostID.Replace("HostSystem-", "")
    
    $tieringType = $vmhost.ExtensionData.Hardware.memoryTieringType

    $totalMemory = [math]::round($vmhost.ExtensionData.Hardware.MemorySize /1GB,2).ToString() + " GB"
    $tieringRatio = ($vmhost | Get-AdvancedSetting Mem.TierNvmePct).Value.toString() + "%"
    
    $tieringEnabled = $false
    if($tieringType -eq "softwareTiering") {
        $tieringEnabled = $true

        $dramTotal = [math]::round(($vmhost.ExtensionData.Hardware.MemoryTierInfo | Where-Object {$_.Name -eq "DRAM"}).Size /1GB,2).ToString() + " GB"
        $nvmeTotal = [math]::round(($vmhost.ExtensionData.Hardware.MemoryTierInfo | Where-Object {$_.Name -eq "NVMe"}).Size /1GB,2).ToString() + " GB"

        $storageSystem = Get-View $vmhost.ExtensionData.ConfigManager.StorageSystem
        $nvmeDevice = ($storageSystem.StorageDeviceInfo.ScsiLun | where {$_.UsedByMemoryTiering -eq $true}).CanonicalName

    } else {
        $dramTotal = $totalMemory
        $nvmeTotal = 0
        $nvmeDevice = "N/A"
    }

    $tmp = [pscustomobject] @{
        Id = $hostID
        VMHost = $vmhost.Name
        TieringEnabled = $tieringEnabled
        TieringRatio = $tieringRatio
        DRAMMemory = $dramTotal
        NVMeMemory = $nvmeTotal
        TotalSystemMemory = $totalMemory
        NVMeDevice = $nvmeDevice
    }
    $results+=$tmp
}

$results | ConvertTo-Json -Compress

# Disconnect from vCenter
Disconnect-VIServer -Confirm:$false