Udostępnij za pośrednictwem

Konfigurowanie metryk niestandardowych na potrzeby uaktualnień stopniowego w zestawach skalowania maszyn wirtualnych (wersja zapoznawcza)

  • Artykuł

Uwaga

Metryki niestandardowe dotyczące uaktualnień stopniowego w zestawach skalowania maszyn wirtualnych są obecnie dostępne w wersji zapoznawczej. Wersje zapoznawcze są udostępniane pod warunkiem udzielenia zgody na dodatkowe warunki użytkowania. Niektóre cechy tych funkcji mogą ulec zmianie, zanim stanie się ona ogólnie dostępna.

Metryki niestandardowe dla uaktualnień stopniowego umożliwiają korzystanie z rozszerzenia kondycji aplikacji w celu emitowania niestandardowych metryk do zestawu skalowania maszyn wirtualnych. Te metryki niestandardowe mogą służyć do określania kolejności aktualizacji maszyn wirtualnych po wyzwoleniu uaktualnienia stopniowego. Metryki niestandardowe mogą również informować zestaw skalowania, gdy uaktualnienie powinno zostać pominięte w konkretnym wystąpieniu. Dzięki temu możesz mieć większą kontrolę nad kolejnością i samym procesem aktualizacji.

Metryki niestandardowe mogą być używane w połączeniu z innymi funkcjami uaktualniania stopniowego, takimi jak automatyczne uaktualnienia systemu operacyjnego, automatyczne uaktualnienia rozszerzeń i uaktualnienia stopniowe MaxSurge.

Wymagania

  • W przypadku używania metryk niestandardowych do uaktualniania stopniowego w zestawach skalowania maszyn wirtualnych zestaw skalowania musi również używać rozszerzenia kondycji aplikacji z zaawansowanymi stanami kondycji, aby zgłaszać kolejność faz lub pomijać informacje o uaktualnianiu. Uaktualnienia metryk niestandardowych nie są obsługiwane w przypadku używania rozszerzenia kondycji aplikacji ze stanami binarnymi.
  • Aby otrzymywać informacje o metrykach niestandardowych, należy skonfigurować rozszerzenie kondycji aplikacji do używania protokołu HTTP lub HTTPS. Protokół TCP nie jest obsługiwany w przypadku integracji z niestandardowymi metrykami w przypadku uaktualnień stopniowego.

Pojęcia

Porządkowanie faz

Faza to konstrukcja grupowania maszyn wirtualnych. Każda faza jest określana przez ustawienie metadanych emitowanych z rozszerzenia kondycji aplikacji za pośrednictwem customMetrics właściwości . Zestaw skalowania maszyn wirtualnych pobiera informacje z metryk niestandardowych i używa ich do umieszczania maszyn wirtualnych w przypisanych fazach. W każdej fazie zestaw skalowania maszyn wirtualnych przypisze również partie uaktualniania. Każda partia jest konfigurowana przy użyciu zasad uaktualniania stopniowego, które uwzględniają domeny aktualizacji (UD), domeny błędów (FD) i informacje o strefie każdej maszyny wirtualnej.

Po zainicjowaniu uaktualnienia stopniowego maszyny wirtualne są umieszczane w wyznaczonych fazach. Uaktualnienia fazowe są wykonywane w kolejności sekwencji liczbowej. Maszyny wirtualne we wszystkich partiach w fazie zostaną ukończone przed przejściem do następnej fazy. Jeśli dla maszyny wirtualnej nie zostanie odebrane żadne kolejność faz, zestaw skalowania umieści go w ostatniej fazie

Regionalny zestaw skalowaniaDiagram przedstawiający ogólny diagram tego, co się dzieje w przypadku korzystania z uaktualnień n-fazowych w regionalnym zestawie skalowania.

Zestaw skalowania strefowegoDiagram przedstawiający ogólny diagram tego, co się dzieje w przypadku korzystania z uaktualnień n-fazowych w zestawie skalowania strefowego.

Aby określić numer fazy, z jaką maszyna wirtualna powinna być skojarzona, użyj phaseOrderingNumber parametru .

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

Pomiń uaktualnianie

Pomijanie funkcji uaktualniania umożliwia pominięcie pojedynczego wystąpienia z uaktualnienia podczas uaktualniania stopniowego. Jest to podobne do korzystania z ochrony wystąpienia, ale może bardziej bezproblemowo zintegrować się z przepływem pracy uaktualniania stopniowego i aplikacjami na poziomie wystąpienia. Podobnie jak w przypadku porządkowania faz, informacje o pomiń uaktualniania są przekazywane do zestawu skalowania maszyn wirtualnych za pośrednictwem rozszerzenia kondycji aplikacji i ustawień metryk niestandardowych. Po wyzwoleniu uaktualnienia stopniowego zestaw skalowania maszyn wirtualnych sprawdza odpowiedź niestandardowych metryk rozszerzeń kondycji aplikacji, a jeśli pomiń uaktualnienie ma wartość true, wystąpienie nie jest uwzględniane w uaktualnieniu stopniowego.

Diagram przedstawiający ogólny diagram tego, co się stanie w przypadku pominięcia uaktualniania w zestawie skalowania strefowego.

Aby pominąć uaktualnienie na maszynie wirtualnej, użyj SkipUpgrade parametru . Informuje to uaktualnienie stopniowe, aby pominąć tę maszynę wirtualną podczas przeprowadzania uaktualnień.

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

Pomiń kolejność uaktualniania i fazy można również używać razem:

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

Konfigurowanie rozszerzenia kondycji aplikacji

Rozszerzenie kondycji aplikacji wymaga żądania HTTP lub HTTPS ze skojarzonym portem lub ścieżką żądania. Sondy TCP są obsługiwane w przypadku korzystania z rozszerzenia kondycji aplikacji, ale nie można ustawić ApplicationHealthState wartości za pośrednictwem treści odpowiedzi sondy i nie można ich używać z uaktualnieniami kroczącymi z metrykami niestandardowymi.

{
  "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
          }
        }
      }
    ]
  }
}
Nazwisko Wartość / przykład Typ danych
protokół http lub https string
port Opcjonalne, gdy protokół jest http lub https int
requestPath Obowiązkowe w przypadku używania http lub https string
intervalInSeconds Opcjonalnie wartość domyślna to 5 sekund. To ustawienie to interwał między poszczególnymi sondami kondycji. Jeśli na przykład intervalInSeconds == 5, sonda jest wysyłana do lokalnego punktu końcowego aplikacji co 5 sekund. int
numberOfProbes Opcjonalnie wartość domyślna to 1. To ustawienie jest liczbą kolejnych sond wymaganych do zmiany stanu kondycji. Jeśli na przykład numberOfProbles == 3, potrzebujesz 3 kolejnych sygnałów "W dobrej kondycji", aby zmienić stan kondycji z "W złej kondycji"/"Nieznany" na stan "W dobrej kondycji". To samo wymaganie dotyczy zmiany stanu kondycji na stan "W złej kondycji" lub "Nieznany". int
gracePeriod Opcjonalne, domyślne = intervalInSeconds * numberOfProbes; maksymalny okres prolongaty wynosi 7200 sekund int

Instalowanie rozszerzenia kondycji aplikacji

Użyj polecenia az vmss extension set , aby dodać rozszerzenie kondycji aplikacji do definicji modelu zestawu skalowania.

Utwórz plik JSON o nazwie extensions.json z żądanymi ustawieniami.

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

Zastosuj rozszerzenie kondycji aplikacji.

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

Uaktualnij maszyny wirtualne w zestawie skalowania. Ten krok jest wymagany tylko wtedy, gdy zestaw skalowania korzysta z zasad ręcznego uaktualniania. Aby uzyskać więcej informacji na temat zasad uaktualniania, zobacz temat Upgrade policies for Virtual Machine Scale Sets (Zasady uaktualniania dla zestawów skalowania maszyn wirtualnych)

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

Konfigurowanie odpowiedzi rozszerzenia kondycji aplikacji

Konfigurowanie odpowiedzi metryk niestandardowych można wykonać na wiele różnych sposobów. Można ją zintegrować z istniejącymi aplikacjami, dynamicznie aktualizować i używać razem z różnymi funkcjami, aby zapewnić dane wyjściowe na podstawie określonej sytuacji.

Przykład 1. Kolejność faz

Tę przykładową aplikację można zainstalować na maszynie wirtualnej w zestawie skalowania w celu emitowania fazy.

#!/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

Przykład 2. Pomiń uaktualnianie

Tę przykładową aplikację można zainstalować na maszynie wirtualnej w zestawie skalowania, aby emitować, że wystąpienie powinno zostać pominięte podczas nadchodzącego uaktualnienia stopniowego.

#!/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

Przykład 3. Łączna kolejność faz i pomijanie uaktualniania

Ta przykładowa aplikacja zawiera kolejność faz i pomijanie parametrów uaktualniania do odpowiedzi metryk niestandardowych.

#!/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

Aby uzyskać więcej przykładów konfiguracji odpowiedzi, zobacz przykłady kondycji aplikacji

Następne kroki

Dowiedz się, jak przeprowadzić ręczne uaktualnienia w zestawach skalowania maszyn wirtualnych .