Aangepaste metrische gegevens configureren voor rolling upgrades op virtuele-machineschaalsets (preview)

Notitie

Aangepaste metrische gegevens voor rolling upgrades op virtuele-machineschaalsets zijn momenteel beschikbaar als preview-versie. Previews worden voor u beschikbaar gesteld op voorwaarde dat u akkoord gaat met de aanvullende gebruiksvoorwaarden. Sommige aspecten van deze functie worden mogelijk nog gewijzigd voordat de functie algemeen beschikbaar wordt.

Met aangepaste metrische gegevens voor rolling upgrades kunt u de toepassingsstatusextensie gebruiken om aangepaste metrische gegevens naar uw virtuele-machineschaalset te verzenden. Deze aangepaste metrische gegevens kunnen worden gebruikt om de schaalset te laten weten in welke volgorde virtuele machines moeten worden bijgewerkt wanneer een rolling upgrade wordt geactiveerd. De aangepaste metrische gegevens kunnen uw schaalset ook informeren wanneer een upgrade moet worden overgeslagen op een specifiek exemplaar. Hierdoor hebt u meer controle over de volgorde en het updateproces zelf.

Aangepaste metrische gegevens kunnen worden gebruikt in combinatie met andere functies voor rolling upgrades, zoals automatische upgrades van het besturingssysteem, automatische uitbreidingsupgrades en Rolling MaxSurge-upgrades.

Vereisten

• Wanneer u aangepaste metrische gegevens gebruikt voor rolling upgrades op virtuele-machineschaalsets, moet de schaalset ook de toepassingsstatusextensie met uitgebreide statussen gebruiken om fasevolgorde te rapporteren of upgradegegevens over te slaan. Aangepaste upgrades voor metrische gegevens worden niet ondersteund bij het gebruik van de toepassingsstatusextensie met binaire statussen.
• De toepassingsstatusextensie moet worden ingesteld om HTTP of HTTPS te gebruiken om de aangepaste metrische gegevens te kunnen ontvangen. TCP wordt niet ondersteund voor integratie met aangepaste metrische gegevens voor rolling upgrades.

Concepten

Fasevolgorde

Een fase is een groeperingsconstructie voor virtuele machines. Elke fase wordt bepaald door het instellen van metagegevens die worden verzonden vanuit de toepassingsstatusextensie via de customMetrics eigenschap. De virtuele-machineschaalset gebruikt de gegevens die zijn opgehaald uit de aangepaste metrische gegevens en gebruikt deze om virtuele machines in hun toegewezen fasen te plaatsen. Binnen elke fase wijst de virtuele-machineschaalset ook upgradebatches toe. Elke batch wordt geconfigureerd met behulp van het rolling upgradebeleid dat rekening houdt met de updatedomeinen (UD), foutdomeinen (FD) en zone-informatie van elke virtuele machine.

Wanneer een rolling upgrade wordt gestart, worden de virtuele machines in hun aangewezen fasen geplaatst. De gefaseerde upgrades worden uitgevoerd in numerieke volgordevolgorde. Virtuele machines in alle batches binnen een fase worden voltooid voordat ze naar de volgende fase gaan. Als er geen fasevolgorde wordt ontvangen voor een virtuele machine, plaatst de schaalset deze in de laatste fase

Regionale schaalset

Zonegebonden schaalset

Als u fasenummer wilt opgeven waaraan de virtuele machine moet worden gekoppeld, gebruikt u phaseOrderingNumber de parameter.

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

Upgrade overslaan

Met de functionaliteit voor het overslaan van een upgrade kan een afzonderlijk exemplaar tijdens de rolling upgrade worden weggelaten. Dit is vergelijkbaar met het gebruik van exemplaarbeveiliging, maar kan naadlooser worden geïntegreerd in de werkstroom voor rolling upgrades en in toepassingen op exemplaarniveau. Net als bij fasevolgorde wordt de informatie over het overslaan van de upgrade doorgegeven aan de virtuele-machineschaalset via de toepassingsstatusextensie en aangepaste instellingen voor metrische gegevens. Wanneer de rolling upgrade wordt geactiveerd, controleert de virtuele-machineschaalset het antwoord van de aangepaste metrische gegevens van de toepassingsstatusextensies en als de upgrade overslaan is ingesteld op waar, wordt het exemplaar niet opgenomen in de rolling upgrade.

Gebruik SkipUpgrade de parameter voor het overslaan van een upgrade op een virtuele machine. Dit vertelt de rolling upgrade om deze virtuele machine over te slaan bij het uitvoeren van de upgrades.

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

Upgrade- en fasevolgorde overslaan kan ook samen worden gebruikt:

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

De toepassingsstatusextensie configureren

De statusextensie van de toepassing vereist een HTTP- of HTTPS-aanvraagaanvraag met een gekoppeld poort- of aanvraagpad. TCP-tests worden ondersteund bij het gebruik van de toepassingsstatusextensie, maar kunnen de ApplicationHealthState testantwoordtekst niet instellen en kunnen niet worden gebruikt met rolling upgrades met aangepaste metrische gegevens.

{
  "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
          }
        }
      }
    ]
  }
}

Naam	Waarde/voorbeeld	Gegevenstype
protocol	http of https	tekenreeks
poort	Optioneel wanneer protocol is http of https	int
requestPath	Verplicht bij gebruik of httphttps	tekenreeks
intervalInSeconds	Optioneel, de standaardwaarde is 5 seconden. Deze instelling is het interval tussen elke statustest. Als intervalInSeconds == 5 bijvoorbeeld, wordt een test één keer per 5 seconden naar het eindpunt van de lokale toepassing verzonden.	int
numberOfProbes	Optioneel, de standaardwaarde is 1. Deze instelling is het aantal opeenvolgende tests dat nodig is om de status te wijzigen. Als bijvoorbeeld numberOfProbles == 3, hebt u drie opeenvolgende "Gezonde" signalen nodig om de status te wijzigen van "Niet in orde"/"Onbekend" in de status "In orde". Dezelfde vereiste geldt voor het wijzigen van de status 'Niet in orde' of 'Onbekend'.	int
gracePeriod	Optioneel, standaard = intervalInSeconds * numberOfProbes; maximale respijtperiode is 7200 seconden	int

De toepassingsstatusextensie installeren

CLI

Gebruik az vmss extension set om de toepassingsstatusextensie toe te voegen aan de definitie van het schaalsetmodel.

Maak een json-bestand extensions.json met de gewenste instellingen.

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

Pas de toepassingsstatusextensie toe.

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

Werk de virtuele machines in de schaalset bij. Deze stap is alleen vereist als uw schaalset gebruikmaakt van een handmatig upgradebeleid. Zie upgradebeleidsregels voor virtuele-machineschaalsets voor meer informatie over upgradebeleid

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

Powershell

Gebruik de cmdlet Add-AzVmssExtension om de toepassingsstatusextensie toe te voegen aan de definitie van het schaalsetmodel.

# 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

Pas de toepassingsstatusextensie toe met behulp van maken of bijwerken.

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>
    }
  }
}

Werk de virtuele machines in de schaalset bij. Deze stap is alleen vereist als uw schaalset gebruikmaakt van een handmatig upgradebeleid. Zie upgradebeleidsregels voor virtuele-machineschaalsets voor meer informatie over upgradebeleid

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

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

Het antwoord van de toepassingsstatusextensie configureren

Het configureren van het aangepaste antwoord voor metrische gegevens kan op veel verschillende manieren worden uitgevoerd. Het kan worden geïntegreerd in bestaande toepassingen, dynamisch bijgewerkt en naast verschillende functies worden gebruikt om een uitvoer te bieden op basis van een specifieke situatie.

Voorbeeld 1: Fasevolgorde

Deze voorbeeldtoepassing kan worden geïnstalleerd op een virtuele machine in een schaalset om de fase te verzenden.

Bash

#!/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": {
            "RollingUpgrade": {
                "PhaseOrderingNumber": 0
            }
        }
    })

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
python3 server.py

Powershell

 New-NetFirewallRule -DisplayName 'HTTP(S) Inbound' -Direction Inbound -Action Allow -Protocol TCP -LocalPort @('8000')
                $Hso = New-Object Net.HttpListener
                $Hso.Prefixes.Add('http://localhost:8000/')
                $Hso.Start()
                function GenerateResponseJson()
                {
                    $appHealthState = "Healthy"
                    $phaseOrderingNumber = 0
                    $hashTable = @{
                        'ApplicationHealthState' = $appHealthState
                        'CustomMetrics' = @{
                            'RollingUpgrade' = @{
                                'PhaseOrderingNumber' = $phaseOrderingNumber
                            }
                        }
                    } 
                    $hashTable.CustomMetrics = ($hashTable.CustomMetrics | ConvertTo-Json)
                    return ($hashTable | ConvertTo-Json)
                }
                While($Hso.IsListening)
                {
                    $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()
                }
                $Hso.Stop()

Voorbeeld 2: Upgrade overslaan

Deze voorbeeldtoepassing kan worden geïnstalleerd op een virtuele machine in een schaalset om te verzenden dat het exemplaar moet worden weggelaten uit de aanstaande rolling upgrade.

Bash

#!/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": {
            "RollingUpgrade": {
                "SkipUpgrade": "true"
            }
        }
    })

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
python3 server.py

Powershell

 New-NetFirewallRule -DisplayName 'HTTP(S) Inbound' -Direction Inbound -Action Allow -Protocol TCP -LocalPort @('8000')
                $Hso = New-Object Net.HttpListener
                $Hso.Prefixes.Add('http://localhost:8000/')
                $Hso.Start()
                function GenerateResponseJson()
                {
                    $appHealthState = "Healthy"
                    $hashTable = @{
                        'ApplicationHealthState' = $appHealthState
                        'CustomMetrics' = @{
                            'RollingUpgrade' = @{
                                'SkipUpgrade' = "true"
                            }
                        }
                    } 
                    $hashTable.CustomMetrics = ($hashTable.CustomMetrics | ConvertTo-Json)
                    return ($hashTable | ConvertTo-Json)
                }
                While($Hso.IsListening)
                {
                    $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()
                }
                $Hso.Stop()

Voorbeeld 3: Gecombineerde fasevolgorde en upgrade overslaan

Deze voorbeeldtoepassing bevat fasevolgorde en slaat upgradeparameters over naar het aangepaste antwoord voor metrische gegevens.

Bash

#!/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": {
            "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
python3 server.py

Powershell

 New-NetFirewallRule -DisplayName 'HTTP(S) Inbound' -Direction Inbound -Action Allow -Protocol TCP -LocalPort @('8000')
                $Hso = New-Object Net.HttpListener
                $Hso.Prefixes.Add('http://localhost:8000/')
                $Hso.Start()
                function GenerateResponseJson()
                {
                    $appHealthState = "Healthy"
                    $hashTable = @{
                        'ApplicationHealthState' = $appHealthState
                        'CustomMetrics' = @{
                            'RollingUpgrade' = @{
                                'PhaseOrderingNumber' = 1
                                'SkipUpgrade' = "false"
                            }
                        }
                    } 
                    $hashTable.CustomMetrics = ($hashTable.CustomMetrics | ConvertTo-Json)
                    return ($hashTable | ConvertTo-Json)
                }
                While($Hso.IsListening)
                {
                    $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()
                }
                $Hso.Stop()

Zie voorbeelden van toepassingsstatus voor meer voorbeelden van antwoordconfiguraties

Volgende stappen

Meer informatie over het uitvoeren van handmatige upgrades op virtuele-machineschaalsets.