Konfigurera anpassade mått för löpande uppgraderingar på VM-skalningsuppsättningar (förhandsversion)

Kommentar

Anpassade mått för löpande uppgraderingar på VM-skalningsuppsättningar är för närvarande i förhandsversion. Förhandsversioner är tillgängliga för dig under förutsättning att du godkänner de kompletterande användningsvillkoren. Vissa aspekter av funktionerna kan ändras innan de är allmänt tillgängliga (GA).

Med anpassade mått för löpande uppgraderingar kan du använda programhälsotillägget för att generera anpassade mått till vm-skalningsuppsättningen. Dessa anpassade mått kan användas för att ange i vilken ordning de virtuella datorerna ska uppdateras när en löpande uppgradering utlöses. De anpassade måtten kan också informera din skalningsuppsättning när en uppgradering ska hoppas över på en specifik instans. På så sätt kan du ha mer kontroll över beställningen och själva uppdateringsprocessen.

Anpassade mått kan användas i kombination med andra funktioner för löpande uppgradering, till exempel automatiska OS-uppgraderingar, automatiska tilläggsuppgraderingar och löpande MaxSurge-uppgraderingar.

Krav

• När du använder anpassade mått för löpande uppgraderingar på VM-skalningsuppsättningar måste skalningsuppsättningen också använda programhälsotillägget med omfattande hälsotillstånd för att rapportera fasordning eller hoppa över uppgraderingsinformation. Uppgraderingar av anpassade mått stöds inte när du använder programhälsotillägget med binära tillstånd.
• Programmets hälsotillägg måste konfigureras för att använda HTTP eller HTTPS för att kunna ta emot information om anpassade mått. TCP stöds inte för integrering med anpassade mått för löpande uppgraderingar.

Begrepp

Fasordning

En fas är en grupperingskonstruktion för virtuella datorer. Varje fas bestäms genom att ange metadata som genereras från programmets hälsotillägg via customMetrics egenskapen . Vm-skalningsuppsättningen tar den information som hämtas från de anpassade måtten och använder den för att placera virtuella datorer i sina tilldelade faser. I varje fas tilldelar vm-skalningsuppsättningen även uppgraderingsbatch. Varje batch konfigureras med den löpande uppgraderingsprincipen som tar hänsyn till uppdateringsdomäner (UD), feldomäner (FD) och zoninformation för varje virtuell dator.

När en löpande uppgradering initieras placeras de virtuella datorerna i sina avsedda faser. De stegvisa uppgraderingarna utförs i numerisk sekvensordning. Virtuella datorer i alla batchar i en fas slutförs innan de går vidare till nästa fas. Om ingen fasordning tas emot för en virtuell dator placerar skalningsuppsättningen den i den sista fasen

Regional skalningsuppsättning

Zonindelad skalningsuppsättning

Om du vill ange fasnummer som den virtuella datorn ska associeras med använder du phaseOrderingNumber parametern .

{
     “applicationHealthState”: “Healthy”,
      “customMetrics”: "{ \"rollingUpgrade\": { \"PhaseOrderingNumber\": 0 } }"
}

Hoppa över uppgradering

Hoppa över uppgraderingsfunktioner gör att en enskild instans kan utelämnas från en uppgradering under den löpande uppgraderingen. Detta liknar användning av instansskydd, men kan integreras smidigare i arbetsflödet för löpande uppgradering och i program på instansnivå. Precis som i fasordning skickas informationen om hoppa över uppgradering till vm-skalningsuppsättningen via programmets hälsotillägg och anpassade måttinställningar. När den löpande uppgraderingen utlöses kontrollerar vm-skalningsuppsättningen svaret för anpassade mått för programhälsotillägg och om hoppa över uppgraderingen är inställd på true inkluderas inte instansen i den löpande uppgraderingen.

Om du vill hoppa över en uppgradering på en virtuell dator använder du SkipUpgrade parametern . Detta talar om för den löpande uppgraderingen att hoppa över den här virtuella datorn när du utför uppgraderingarna.

{
     “applicationHealthState”: “Healthy”,
      “customMetrics”: "{ \"rollingUpgrade\": { \"SkipUpgrade\": true} }"
}

Hoppa över uppgradering och fasordning kan också användas tillsammans:

{
     “applicationHealthState”: “Healthy”,
      “customMetrics”: "{ \"rollingUpgrade\": { \"SkipUpgrade\": false, \"PhaseOrderingNumber\": 0 } }"
}

Konfigurera programmets hälsotillägg

Programhälsotillägget kräver en HTTP- eller HTTPS-begäran med en associerad port eller sökväg för begäran. TCP-avsökningar stöds när du använder programmets hälsotillägg, men kan inte ange via avsökningssvarstexten ApplicationHealthState och kan inte användas med löpande uppgraderingar med anpassade mått.

{
  "extensionProfile" : {
     "extensions" : [
      {
        "name": "HealthExtension",
        "properties": {
          "publisher": "Microsoft.ManagedServices",
          "type": "<ApplicationHealthLinux or ApplicationHealthWindows>",
          "autoUpgradeMinorVersion": true,
          "typeHandlerVersion": "1.0",
          "settings": {
            "protocol": "<protocol>",
            "port": <port>,
            "requestPath": "</requestPath>",
            "intervalInSeconds": 5,
            "numberOfProbes": 1
          }
        }
      }
    ]
  }
}

Name	Värde/exempel	Datatyp
protokoll	http eller https	sträng
port	Valfritt när protokollet är http eller https	heltal
requestPath	Obligatoriskt när du använder http eller https	sträng
intervalInSeconds	Valfritt, standardvärdet är 5 sekunder. Den här inställningen är intervallet mellan varje hälsoavsökning. Om till exempel intervalInSeconds == 5, skickas en avsökning till den lokala programslutpunkten en gång var femte sekund.	heltal
numberOfProbes	Valfritt, standardvärdet är 1. Den här inställningen är antalet på varandra följande avsökningar som krävs för att hälsostatusen ska ändras. Om till exempel numberOfProbles == 3 behöver du tre på varandra följande "Felfria" signaler för att ändra hälsostatusen från "Inte felfri"/"Okänd" till tillståndet "Felfri". Samma krav gäller för att ändra hälsostatusen till tillståndet "Inte felfri" eller "Okänd".	heltal
gracePeriod	Valfritt, standard = intervalInSeconds * numberOfProbes; maximal respitperiod är 7 200 sekunder	heltal

Installera programmets hälsotillägg

CLI

Använd az vmss-tilläggsuppsättningen för att lägga till programhälsotillägget i skalningsuppsättningsmodelldefinitionen.

Skapa en json-fil med namnet extensions.json med önskade inställningar.

{
  "protocol": "<protocol>",
  "port": <port>,
  "requestPath": "</requestPath>",
  "gracePeriod": <healthExtensionGracePeriod>
}

Tillämpa programmets hälsotillägg.

az vmss extension set \
  --name ApplicationHealthLinux \
  --publisher Microsoft.ManagedServices \
  --version 2.0 \
  --resource-group myResourceGroup \
  --vmss-name myScaleSet \
  --settings ./extension.json

Uppgradera de virtuella datorerna i skalningsuppsättningen. Det här steget krävs bara om skalningsuppsättningen använder en manuell uppgraderingsprincip. Mer information om uppgraderingsprinciper finns i Uppgraderingsprinciper för VM-skalningsuppsättningar

az vmss update-instances \
  --resource-group myResourceGroup \
  --name myScaleSet \
  --instance-ids "*"

PowerShell

Använd cmdleten Add-AzVmssExtension för att lägga till programhälsotillägget i skalningsuppsättningsmodelldefinitionen.

# Define the scale set variables
$vmScaleSetName = "myScaleSet"
$vmScaleSetResourceGroup = "myResourceGroup"

# Define the application health extension properties
$publicConfig = @{"protocol" = "http"; "port" = 80; "requestPath" = "/healthEndpoint"; "gracePeriod" = 600};
$extensionName = "myHealthExtension"
$extensionType = "ApplicationHealthWindows"
$publisher = "Microsoft.ManagedServices"

# Get the scale set object
$vmScaleSet = Get-AzVmss `
  -ResourceGroupName $vmScaleSetResourceGroup `
  -VMScaleSetName $vmScaleSetName

# Add the application health extension to the scale set model
Add-AzVmssExtension -VirtualMachineScaleSet $vmScaleSet `
  -Name $extensionName `
  -Publisher $publisher `
  -Setting $publicConfig `
  -Type $extensionType `
  -TypeHandlerVersion "2.0" `
  -AutoUpgradeMinorVersion $True

# Update the scale set
Update-AzVmss -ResourceGroupName $vmScaleSetResourceGroup `
  -Name $vmScaleSetName `
  -VirtualMachineScaleSet $vmScaleSet
  
# Upgrade instances to install the extension.
Update-AzVmssInstance -ResourceGroupName $vmScaleSetResourceGroup `
  -VMScaleSetName $vmScaleSetName `
  -InstanceId '*'

REST

Använd programmets hälsotillägg med hjälp av skapa eller uppdatera.

PUT `/subscriptions/subscription_id/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachineScaleSets/myScaleSet/extensions/myHealthExtension?api-version=2018-10-01`

Request body
{
  "name": "myHealthExtension",
  "location": "<location>",
  "properties": {
    "publisher": "Microsoft.ManagedServices",
    "type": "ApplicationHealthWindows",
    "autoUpgradeMinorVersion": true,
    "typeHandlerVersion": "2.0",
    "settings": {
      "protocol": "<protocol>",
      "port": <port>,
      "requestPath": "</requestPath>",
      "intervalInSeconds": <intervalInSeconds>,
      "numberOfProbes": <numberOfProbes>,
      "gracePeriod": <gracePeriod>
    }
  }
}

Uppgradera de virtuella datorerna i skalningsuppsättningen. Det här steget krävs bara om skalningsuppsättningen använder en manuell uppgraderingsprincip. Mer information om uppgraderingsprinciper finns i Uppgraderingsprinciper för VM-skalningsuppsättningar

POST `/subscriptions/<subscriptionId>/resourceGroups/<myResourceGroup>/providers/Microsoft.Compute/virtualMachineScaleSets/< myScaleSet >/manualupgrade?api-version=2022-08-01`

Request body
{
  "instanceIds": ["*"]
}

Konfigurera svaret för programmets hälsotillägg

Du kan konfigurera svar på anpassade mått på många olika sätt. Den kan integreras i befintliga program, uppdateras dynamiskt och användas längs olika funktioner för att tillhandahålla utdata baserat på en specifik situation.

Dessa exempelprogram inkluderar fasordning och hoppar över uppgraderingsparametrar i svar på anpassade mått.

Våldsamt slag

#!/bin/bash

# Open firewall port (replace with your firewall rules as needed)
sudo iptables -A INPUT -p tcp --dport 8000 -j ACCEPT

# Create Python HTTP server for responding with JSON
cat <<EOF > server.py
import json
from http.server import BaseHTTPRequestHandler, HTTPServer

# Function to generate the JSON response
def generate_response_json():
    return json.dumps({
        "ApplicationHealthState": "Healthy",
        "CustomMetrics": json.dumps({
            "RollingUpgrade": {
                "PhaseOrderingNumber": 1,
                "SkipUpgrade": "false"
            }
        })
    })

class RequestHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        # Respond with HTTP 200 and JSON content
        self.send_response(200)
        self.send_header('Content-type', 'application/json')
        self.end_headers()
        response = generate_response_json()
        self.wfile.write(response.encode('utf-8'))

# Set up the HTTP server
def run(server_class=HTTPServer, handler_class=RequestHandler):
    server_address = ('localhost', 8000)
    httpd = server_class(server_address, handler_class)
    print('Starting server on port 8000...')
    httpd.serve_forever()

if __name__ == "__main__":
    run()
EOF

# Run the server in the background
python3 server.py &

# Store the process ID of the server
SERVER_PID=$!

# Wait a few seconds to ensure the server starts
sleep 2

# Confirm execution
echo "Server has been started on port 8000 with PID $SERVER_PID"

PowerShell

# Define the script path
$scriptPath = "$env:TEMP\server.ps1"

# Create the PowerShell HTTP Server Script
$serverScript = @"
`$Hso = New-Object Net.HttpListener
`$Hso.Prefixes.Add('http://localhost:8000/')
`$Hso.Start()

Write-Host 'Starting server on port 8000...'

# Function to Generate JSON Response (Matching Python Format)
function GenerateResponseJson {
    # Create JSON string for CustomMetrics
    `$customMetricsJson = (@{
        'RollingUpgrade' = @{
            'PhaseOrderingNumber' = 1
            'SkipUpgrade' = 'false'
        }
    } | ConvertTo-Json -Depth 10) -replace "`n", "" -replace "\s{2,}", ""  # Ensuring a single-line JSON string

    # Create main JSON response
    `$response = @{
        'ApplicationHealthState' = 'Healthy'
        'CustomMetrics' = `$customMetricsJson  # Embed JSON string inside JSON
    }

    return (`$response | ConvertTo-Json -Depth 10)
}

# Keep the server running
while (`$Hso.IsListening) {
    try {
        `$context = `$Hso.GetContext()
        `$response = `$context.Response
        `$response.StatusCode = 200
        `$response.ContentType = 'application/json'
        `$responseJson = GenerateResponseJson
        `$responseBytes = [System.Text.Encoding]::UTF8.GetBytes(`$responseJson)
        `$response.OutputStream.Write(`$responseBytes, 0, `$responseBytes.Length)
        `$response.Close()
        Write-Host "Responded to request at $(Get-Date)"
    }
    catch {
        Write-Host "Error occurred: $_"
    }
}
"@

# Write the script to a file
$serverScript | Out-File -FilePath $scriptPath -Encoding UTF8

# Verify if the file exists before starting the process
if (Test-Path $scriptPath) {
    Write-Host "Server script successfully created at $scriptPath"
    Start-Process -NoNewWindow -FilePath "powershell.exe" -ArgumentList "-ExecutionPolicy Bypass -File `"$scriptPath`"" -PassThru | ForEach-Object {
        # Store Process ID
        $SERVER_PID = $_.Id
        Write-Host "Server has been started on port 8000 with PID $SERVER_PID"
    }
} else {
    Write-Host "Error: Server script not found at $scriptPath"
}

Fler svarskonfigurationsexempel finns i exempel på programhälsa

Nästa steg

Lär dig hur du utför manuella uppgraderingar på VM-skalningsuppsättningar.