Freigeben über

Intelligente clusterübergreifende Kubernetes-Ressourcenplatzierung mit Azure Kubernetes Fleet Manager (Vorschau)

  • Artikel

Anwendungsentwickler müssen Kubernetes-Ressourcen häufig in mehreren Clustern bereitstellen. Flottenoperatoren müssen die besten Cluster für die Platzierung der Workloads häufig basierend auf Heuristiken wie Computekosten in den Clustern oder verfügbaren Ressourcen wie Arbeitsspeicher und CPU auswählen. Es ist mühsam, diese Kubernetes-Ressourcen manuell in mehreren Clustern zu erstellen, zu aktualisieren und nachzuverfolgen. In diesem Artikel wird erläutert, wie Sie mithilfe des intelligenten Kubernetes-Ressourcenplatzierungsfeatures von Azure Kubernetes Fleet Manager (Fleet) in diesen Szenarios vorgehen können.

Übersicht

Fleet bietet ein Feature für die Ressourcenplatzierung, mit deren Hilfe Sie Planungsentscheidungen basierend auf den folgenden Eigenschaften treffen können:

  • Anzahl der Knoten
  • Computekosten in Zielmitgliedsclustern
  • Ressourcenverfügbarkeit (CPU/Arbeitsspeicher) in Zielmitgliedsclustern

Wichtig

Previewfunktionen von Azure Kubernetes Fleet Manager sind auf Self-Service-Basis per Aktivierung verfügbar. Vorschauversionen werden „wie besehen“ und „wie verfügbar“ bereitgestellt und sind von den Vereinbarungen zum Service Level und der eingeschränkten Garantie ausgeschlossen. Vorschauversionen von Azure Kubernetes Fleet Manager sind auf Best-Effort-Basis teilweise durch den Kundensupport abgedeckt. Daher sind diese Funktionen nicht für die Verwendung in der Produktion vorgesehen.

In diesem Artikel wird die Erstellung von Clusterressourcenplatzierungen erläutert, die über die Azure CLI oder das Azure-Portal erfolgen kann. Weitere Informationen finden Sie unter Verteilen von Ressourcen aus einem Flotten-Hub-Cluster an Mitgliedscluster.

Voraussetzungen

Filtern von Clustern zum Zeitpunkt der Planung basierend auf den Eigenschaften des Mitgliedsclusters

Der Affinitätstyp requiredDuringSchedulingIgnoredDuringExecution ermöglicht das Filtern von Mitgliedsclustern, die für die Platzierung mithilfe von Eigenschaftsauswahlen berechtigt sind. Eine Eigenschaftsauswahl ist ein Array von Ausdrucksbedingungen für Clustereigenschaften.

Sie geben in jeder Bedingung Folgendes an:

  • Name: Name der Eigenschaft, der das folgende Format haben muss:

    resources.kubernetes-fleet.io/<CAPACITY-TYPE>-<RESOURCE-NAME>

    <CAPACITY-TYPE> ist entweder total, allocatable oder available, je nachdem, welche Kapazität (Nutzungsinformationen) Sie überprüfen möchten, und <RESOURCE-NAME> ist der Name der Ressource (CPU/Arbeitsspeicher).

    Wenn Sie Cluster beispielsweise basierend auf der verfügbaren CPU-Kapazität eines Clusters auswählen möchten, sollte der in der Eigenschaftsauswahl verwendete Name resources.kubernetes-fleet.io/available-cpu lauten. Für zuordnungsfähige Arbeitsspeicherkapazität können Sie resources.kubernetes-fleet.io/allocatable-memory verwenden.

  • Eine Liste der möglichen Werte der Eigenschaft

  • Ein Operator, mit dem die Bedingung zwischen dem eingeschränkten/gewünschten Wert und dem beobachteten Wert im Cluster ausgedrückt wird Die folgenden Operatoren werden derzeit unterstützt:

    • Gt (Größer als): Der beobachtete Wert eines Clusters der angegebenen Eigenschaft muss größer als der Wert in der Bedingung sein, damit er für die Ressourcenplatzierung ausgewählt werden kann.
    • Ge (Größer als oder gleich): Der beobachtete Wert eines Clusters der angegebenen Eigenschaft muss größer als der Wert in der Bedingung oder gleich diesem Wert sein, damit er für die Ressourcenplatzierung ausgewählt werden kann.
    • Lt (Kleiner als): Der beobachtete Wert eines Clusters der angegebenen Eigenschaft muss kleiner als der Wert in der Bedingung sein, damit er für die Ressourcenplatzierung ausgewählt werden kann.
    • Le (Kleiner als oder gleich): Der beobachtete Wert eines Clusters der angegebenen Eigenschaft muss kleiner als der Wert in der Bedingung oder gleich diesem Wert sein, damit er für die Ressourcenplatzierung ausgewählt werden kann.
    • Eq (Gleich): Der beobachtete Wert eines Clusters der angegebenen Eigenschaft muss gleich dem Wert in der Bedingung sein, damit er für die Ressourcenplatzierung ausgewählt werden kann.
    • Ne (Ungleich): Der beobachtete Wert eines Clusters der angegebenen Eigenschaft muss ungleich dem Wert in der Bedingung sein, damit er für die Ressourcenplatzierung ausgewählt werden kann.

    Wenn Sie den Operator Gt, Ge, Lt, Le, Eq oder Ne verwenden, muss die Liste der Werte in der Bedingung genau einen Wert aufweisen.

Fleet wertet jeden Cluster basierend auf den in der Bedingung angegebenen Eigenschaften aus. Wenn die unter requiredDuringSchedulingIgnoredDuringExecution aufgeführten Bedingungen nicht erfüllt werden, wird dieser Mitgliedscluster von der Ressourcenplatzierung ausgeschlossen.

Hinweis

Wenn ein Mitgliedscluster nicht über die in der Bedingung ausgedrückte Eigenschaft verfügt, wird die Bedingung automatisch als nicht erfüllt angesehen.

Beispiel für eine Platzierungsrichtlinie, damit nur Cluster mit mehr als oder genau fünf Knoten für die Ressourcenplatzierung ausgewählt werden:

apiVersion: placement.kubernetes-fleet.io/v1beta1
kind: ClusterResourcePlacement
metadata:
  name: crp
spec:
  resourceSelectors:
    - ...
  policy:
    placementType: PickAll
    affinity:
        clusterAffinity:
            requiredDuringSchedulingIgnoredDuringExecution:
                clusterSelectorTerms:
                - propertySelector:
                    matchExpressions:
                    - name: "kubernetes.azure.com/node-count"
                      operator: Ge
                      values:
                      - "5"

Sie können sowohl Bezeichnungs- als auch Eigenschaftsauswahlen unter dem requiredDuringSchedulingIgnoredDuringExecution-Affinitätsausdruck verwenden, um die geeigneten Mitgliedscluster nach diesen beiden Einschränkungen zu filtern.

apiVersion: placement.kubernetes-fleet.io/v1beta1
kind: ClusterResourcePlacement
metadata:
  name: crp
spec:
  resourceSelectors:
    - ...
  policy:
    placementType: PickAll
    affinity:
        clusterAffinity:
            requiredDuringSchedulingIgnoredDuringExecution:
                clusterSelectorTerms:
                - labelSelector:
                    matchLabels:
                      region: east
                  propertySelector:
                    matchExpressions:
                    - name: "kubernetes.azure.com/node-count"
                      operator: Ge
                      values:
                      - "5"

In diesem Beispiel berücksichtigt Kubernetes Fleet einen Cluster für die Ressourcenplatzierung nur dann, wenn dieser über die region=east-Bezeichnung und mindestens fünf Knoten verfügt.

Priorisieren der Clusterreihenfolge zum Zeitpunkt der Planung basierend auf den Eigenschaften des Mitgliedsclusters

Wenn preferredDuringSchedulingIgnoredDuringExecution verwendet wird, priorisiert ein Eigenschaftensortierer alle Cluster in der Flotte basierend auf ihren Werten in aufsteigender oder absteigender Reihenfolge. Die Gewichtungen werden basierend auf dem unter preferredDuringSchedulingIgnoredDuringExecution angegebenen Gewichtungswert berechnet.

Ein Eigenschaftensortierer besteht aus:

  • Name: Name der Eigenschaft mit weiteren Informationen zur Formatierung der im vorherigen Abschnitt behandelten Eigenschaft.
  • Sortierreihenfolge: Die Sortierreihenfolge kann entweder Ascending oder Descending sein. Wenn eine Ascending-Reihenfolge verwendet wird, bevorzugt Kubernetes Fleet Mitgliedscluster mit niedrigeren beobachteten Werten. Wenn eine Descending-Reihenfolge verwendet wird, werden Mitgliedscluster mit höheren beobachteten Werten bevorzugt.

Für die Descending-Sortierreihenfolge wird die proportionale Gewichtung mithilfe der folgenden Formel berechnet:

((Observed Value - Minimum observed value) / (Maximum observed value - Minimum observed value)) * Weight

Beispiel: Sie möchten Cluster basierend auf der Eigenschaft der verfügbaren CPU-Kapazität in absteigender Reihenfolge priorisieren und verfügen über eine Flotte von drei Clustern mit der folgenden verfügbaren CPU:

Cluster Verfügbare CPU-Kapazität
bravelion 100
smartfish 20
jumpingcat 10

In diesem Fall berechnet der Sortierer die folgenden Gewichtungen:

Cluster Verfügbare CPU-Kapazität Weight
bravelion 100 (100 – 10) / (100 – 10) = 100 % der Gewichtung
smartfish 20 (20 – 10) / (100 – 10) = 11,11 % der Gewichtung
jumpingcat 10 (10 – 10) / (100 – 10) = 0 % der Gewichtung

Für die Ascending-Sortierreihenfolge wird die proportionale Gewichtung mithilfe der folgenden Formel berechnet:

(1 - ((Observed Value - Minimum observed value) / (Maximum observed value - Minimum observed value))) * Weight

Beispiel: Sie möchten Cluster basierend auf den Kosten pro CPU-Kern in aufsteigender Reihenfolge priorisieren und verfügen über eine Flotte von drei Clustern mit den folgenden Kosten pro CPU-Kern:

Cluster Kosten pro CPU-Kern
bravelion 1
smartfish 0.2
jumpingcat 0.1

In diesem Fall berechnet der Sortierer die folgenden Gewichtungen:

Cluster Kosten pro CPU-Kern Weight
bravelion 1 1 – ((1 –  0,1) / (1 – 0,1)) = 0 % der Gewichtung
smartfish 0.2 1 – ((0.2 –  0,1) / (1 – 0,1)) = 88,89 % der Gewichtung
jumpingcat 0.1 1 – ((0.1 –  0,1) / (1 – 0,1)) = 100 % der Gewichtung

Im folgenden Beispiel wird ein Eigenschaftensortierer dargestellt, der die Descending-Reihenfolge verwendet:

apiVersion: placement.kubernetes-fleet.io/v1beta1
kind: ClusterResourcePlacement
metadata:
  name: crp
spec:
  resourceSelectors:
    - ...
  policy:
    placementType: PickN
    numberOfClusters: 10
    affinity:
        clusterAffinity:
            preferredDuringSchedulingIgnoredDuringExecution:
            - weight: 20
              preference:
                metricSorter:
                  name: kubernetes.azure.com/node-count
                  sortOrder: Descending

In diesem Beispiel bevorzugt Fleet Cluster mit höherer Knotenanzahl. Der Cluster mit der höchsten Knotenanzahl erhält eine Gewichtung von 20, der Cluster mit der niedrigsten Anzahl eine Gewichtung von 0. Andere Cluster erhalten proportionale Gewichtungen, die mithilfe der Berechnungsformel für Gewichtungen berechnet werden.

Sie können sowohl die Bezeichnungsauswahl als auch den Eigenschaftensortierer unter der preferredDuringSchedulingIgnoredDuringExecution-Affinität verwenden. Ein Mitgliedscluster, der die Bezeichnungsauswahl nicht erfüllt, erhält keine Gewichtung. Mitgliedscluster, die die Bezeichnungsauswahl erfüllen, erhalten proportionale Gewichtungen, wie unter dem Eigenschaftensortierer angegeben.

apiVersion: placement.kubernetes-fleet.io/v1beta1
kind: ClusterResourcePlacement
metadata:
  name: crp
spec:
  resourceSelectors:
    - ...
  policy:
    placementType: PickN
    numberOfClusters: 10
    affinity:
        clusterAffinity:
            preferredDuringSchedulingIgnoredDuringExecution:
            - weight: 20
              preference:
                labelSelector:
                  matchLabels:
                    env: prod
                metricSorter:
                  name: resources.kubernetes-fleet.io/total-cpu
                  sortOrder: Descending

In diesem Beispiel erhält ein Cluster nur dann eine zusätzliche Gewichtung, wenn er die env=prod-Bezeichnung hat. Wenn der Cluster diese bezeichnungsbasierte Einschränkung erfüllt, erhält er eine proportionale Gewichtung basierend auf der Gesamtmenge der CPU in diesem Mitgliedscluster.

Bereinigen von Ressourcen

Wenn Sie das ClusterResourcePlacement-Objekt nicht mehr verwenden möchten, können Sie es mit dem kubectl delete-Befehl löschen. Im folgenden Beispiel wird das ClusterResourcePlacement-Objekt namens crp gelöscht:

kubectl delete clusterresourceplacement crp

Nächste Schritte

Weitere Informationen zur Ressourcenverteilung finden Sie in den folgenden Artikeln: