Introduktion till Azure Intelligent resursplacering i Kubernetes Fleet Manager

Gäller för ✔️ Fleet Manager med hubbkluster

Att hantera Kubernetes-resurser i flera kluster innebär stora utmaningar för både plattformsadministratörer och programutvecklare. När organisationer skalar sin Kubernetes-infrastruktur bortom ett enda kluster stöter de ofta på komplexiteter som rör resursdistribution, konsekvens och manuella hanteringskostnader. Den traditionella metoden att hantera varje kluster självständigt skapar operativa silor som blir allt svårare att underhålla när flottans storlek växer.

Plattformsadministratörer behöver ofta distribuera Kubernetes-resurser till flera kluster av olika skäl, bland annat:

  • Hantera åtkomstkontroll med hjälp av roller och rollbindningar i flera kluster.
  • Köra infrastrukturprogram, till exempel Prometheus eller Flux, som måste finnas i alla kluster.

Programutvecklare behöver ofta distribuera Kubernetes-resurser till flera kluster av olika skäl, bland annat:

  • Distribuera ett videotjänstprogram till flera kluster i olika regioner för en tittarupplevelse med låg fördröjning.
  • Distribuera ett kundvagnsprogram till två parkopplade regioner så att kunderna kan fortsätta att handla under ett avbrott i en enda region.
  • Distribuera ett batchbearbetningsprogram till kluster med tillgängliga och billiga spotnodpooler.

Det är omständligt och kan vara felbenäget att skapa, uppdatera och spåra Kubernetes-resurser i flera kluster manuellt.

I den här artikeln får du lära dig hur du använder Fleet Managers intelligenta resursplaceringsfunktion för att hantera fördelningen av kluster- och namnområdesomfångsbegränsade Kubernetes-resurser mellan medlemskluster i en flotta.

Fleet Managers resursplaceringsfunktion baseras på KubeFleet CNCF-projektet.

Översikt över resursplaceringsprocess

Följ dessa steg om du vill använda Fleet Managers intelligenta resursplacering:

  1. Mellanlagra resurser i hubbklustret: Använd kontinuerlig distribution, GitOps eller en liknande metod för att tillämpa manifesten för resursdistributioner i Fleet Manager-hubbklustret.
  2. Skapa en resursplacering: Skapa ett placeringsmanifest som väljer resursen och definierar en princip för att välja vilka medlemskluster som ska ta emot resursen.
  3. Tillämpa resursplacering på hubbklustret: Använd placeringsmanifestet på hubbklustret för att börja distribuera resursen.
  4. Fleet Manager schemalägger resurser: Fleet Manager observerar resursplaceringen och det valda omfånget och utför fördelningen av resurserna.
  5. Observera distribution via resursplacering: fråga resursplaceringen i hubbklustret för att kontrollera resursens status när den distribueras.

Fleet Manager har en Azure portalupplevelse för resursplacering som ger en mer visuell representation av distributionen.

Introduktion till resursplacering med klusteromfattning

Använd en ClusterResourcePlacement (CRP) för att distribuera en viss uppsättning klusteromfattningsresurser eller hela namnområden från Fleet Manager-hubbklustret till ett eller flera medlemskluster.

Viktiga egenskaper:

  • Klusteromfång: väljer klusteromfattande resurser eller namnområden.
  • Deklarativ: använder samma placeringsprinciper som ResourcePlacement för konsekvent beteende.

Genom att använda CRP kan du:

  • Välj vilka Kubernetes-resurser som ska distribueras. Dessa resurser kan vara Kubernetes-resurser med klusteromfattning som definierats med kubernetes GVK-referenser (Group Version Kind) eller ett namnområde som distribuerar namnområdet och alla dess resurser.
  • Ange placeringsprinciper för att välja medlemskluster. Dessa principer kan uttryckligen välja kluster efter namn eller dynamiskt välja kluster baserat på klusteretiketter och egenskaper.
  • Ange distributionsstrategier för att på ett säkert sätt distribuera alla uppdateringar av de valda Kubernetes-resurserna till flera målkluster.
  • Visa distributionsförloppet för varje målkluster.

Scenarier som kräver detaljerad kontroll över enskilda namnområdesomfångsresurser i ett namnområde finns i resursplacering med namnområdesomfång, som möjliggör distribution av specifika resurser i stället för hela namnområden.

Introduktion till namnområdesomfattande resursplacering

Använd en ResourcePlacement (RP) för att distribuera en viss uppsättning resurser inom ett specifikt namnområde från Fleet Manager-hubbklustret till ett eller flera medlemskluster. ResourcePlacement ger detaljerad kontroll över hur specifika resurser i ett namnområde distribueras mellan medlemskluster.

Viktiga egenskaper:

  • Namnområdesomfång: Både ResourcePlacement och de resurser som väljs finns inom samma namnområde.
  • Selektiv: Väljer specifika resurser i namnområdet efter typ, namn eller etiketter i stället för hela namnområden.
  • Deklarativ: Använder samma placeringsprinciper som ClusterResourcePlacement för konsekvent beteende.

När du ska använda ResourcePlacement

ResourcePlacement är perfekt för scenarier som kräver detaljerad kontroll över namnområdesomfångsresurser:

  • Selektiv resursdistribution: Distribuera specifika ConfigMaps, hemligheter eller tjänster utan att påverka hela namnområdet.
  • Miljöer med flera klienter: Tillåt att olika team hanterar sina resurser oberoende av varandra i delade namnområden.
  • Konfigurationshantering: Distribuera miljöspecifika konfigurationer i olika klustermiljöer.
  • Efterlevnad och styrning: Tillämpa olika principer på olika resurstyper inom samma namnområde.
  • Progressiva distributioner: Distribuera resursuppdateringar på ett säkert sätt mellan kluster med hjälp av strategier för noll stilleståndstid.

I miljöer med flera kluster består arbetsbelastningar ofta av både klusteromfattande och namnområdesomfångsbegränsade resurser som du behöver distribuera mellan olika kluster. Även om ClusterResourcePlacement (CRP) hanterar klusteromfångsresurser effektivt, hanterar det även hela namnområden och deras innehåll. Vissa scenarier kräver dock mer detaljerad kontroll över namnområdesomfångsresurser inom befintliga namnområden.

ResourcePlacement (RP) åtgärdar denna lucka genom att tillhandahålla:

  • Resurshantering med namnområdesomfång: Rikta in sig på specifika resurser i ett namnområde utan att påverka hela namnområdet.
  • Driftflexitet: Gör det möjligt för team att hantera olika resurser inom samma namnområde oberoende av varandra.
  • Kompletterande funktioner: Arbeta tillsammans med CRP för att tillhandahålla en komplett resurshanteringslösning för flera kluster.

Anmärkning

Du kan använda ResourcePlacement tillsammans med ClusterResourcePlacement i namnområdesläge. Du kan till exempel använda CRP för att distribuera namnområdet och använda RP för detaljerad hantering av specifika resurser som miljöspecifika ConfigMaps eller Hemligheter inom det namnområdet.

Resursplaceringskomponenter

En resursplacering, oavsett omfång (kluster eller namnområde), består av följande komponenter:

  • Resursväljare: välj de resurser som ska inkluderas via resourceSelectors.
  • Placeringsprincip: definiera hur du väljer kluster med placementType hjälp av någon av typerna PickAll, PickFixedeller PickN .
  • Distributionsstrategi: styr hur resurser distribueras i valda kluster genom att inkludera en valfri strategy.

Det här exemplet clusterResourcePlacement (CRP) placerar namnområdet my-app på alla kluster i flottan. Om du inte definierar en explicit strategi använder processen en RollingUpdate.

apiVersion: placement.kubernetes-fleet.io/v1
kind: ClusterResourcePlacement
metadata:
  name: namespace-only-crp
spec:
  resourceSelectors:
    - group: ""
      kind: Namespace
      name: my-app
      version: v1
  policy:
    placementType: PickAll   

Det här exemplet på ResourcePlacement (RP) placerar ConfigMap-etiketten app=my-application i namnområdet my-app i det matchande namnområdet i de två namngivna klustren. Om du inte definierar en explicit strategi använder processen en RollingUpdate.

apiVersion: placement.kubernetes-fleet.io/v1
kind: ResourcePlacement
metadata:
  name: app-configs-rp
  namespace: my-app
spec:
  resourceSelectors:
    - group: ""
      kind: ConfigMap
      version: v1
      labelSelector:
        matchLabels:
          app: my-application
  policy:
    placementType: PickFixed
    clusterNames:
    - cluster1
    - cluster2

Resursväljare

Välj resurser med hjälp av en eller flera resourceSelectors i en placering. Varje resursväljare kan ange:

  • Grupp, Version, Typ (GVK): Den typ av Kubernetes-resurs som ska väljas.
  • Namn: Namnet på en specifik resurs.
  • Etikettväljare: Etiketter som matchar flera resurser.

Namnområdesmarkeringsomfång

När du använder klusteromfattningsplacering för att välja ett helt namnområde använder du selectionScope fältet för att styra om alla underordnade resurser ska inkluderas i namnområdet eller bara placera ett tomt namnområde.

  • Standardbeteende (när selectionScope anges inte): distribuerar namnområdet och alla resurser i det.
  • NamespaceOnly: distribuerar endast namnområdesresursen utan några resurser i namnområdet. Det här alternativet är användbart när du vill upprätta namnområden mellan kluster samtidigt som du hanterar enskilda resurser separat med hjälp ResourcePlacementav .

Det här exemplet visar hur du endast distribuerar namnområdet utan dess innehåll.

apiVersion: placement.kubernetes-fleet.io/v1
kind: ClusterResourcePlacement
metadata:
  name: namespace-only-crp
spec:
  resourceSelectors:
    - group: ""
      kind: Namespace
      name: my-app
      version: v1
      selectionScope: NamespaceOnly
  policy:
    placementType: PickAll

Den här metoden möjliggör ett arbetsflöde där plattformsadministratörer använder ClusterResourcePlacement för att upprätta namnområden, medan programteam använder ResourcePlacement för detaljerad kontroll över specifika resurser inom dessa namnområden.

Placeringsprincip

Fleet Manager-resursplacering stöder följande typer av placeringsprinciper för att styra hur kluster väljs:

  • PickFixed placerar resurser på medlemskluster med hjälp av deras klusternamn.
  • PickAll placerar resurser på alla medlemskluster eller alla medlemskluster som uppfyller ett villkor. Den här principen är användbar för att placera infrastrukturarbetsbelastningar, till exempel klusterövervakning eller rapporteringsprogram.
  • PickN är det mest flexibla placeringsalternativet. Med den kan du välja kluster baserat på tillhörighets- eller topologispridningsbegränsningar. Använd den här principen när du sprider arbetsbelastningar över flera liknande kluster för att säkerställa att tillgängligheten bibehålls.

PickFixed-placeringstyp

Använd PickFixed för att välja kluster efter namn. Ange namn i matrisen clusterNames . En tom eller utelämnad array väljer inga kluster.

Det här exemplet visar hur du distribuerar test-deployment namnområdet till medlemskluster cluster1 och cluster2.

apiVersion: placement.kubernetes-fleet.io/v1
kind: ClusterResourcePlacement
metadata:
  name: crp-fixed
spec:
  resourceSelectors:
    - group: ""
      kind: Namespace
      name: test-deployment
      version: v1
  policy:
    placementType: PickFixed
    clusterNames:
    - cluster1
    - cluster2

Det här exemplet på ResourcePlacement (RP) placerar ConfigMap-etiketten app: my-application i namnområdet my-app i det matchande namnområdet i de två namngivna klustren.

apiVersion: placement.kubernetes-fleet.io/v1
kind: ResourcePlacement
metadata:
  name: app-configs-rp
  namespace: my-app
spec:
  resourceSelectors:
    - group: ""
      kind: ConfigMap
      version: v1
      labelSelector:
        matchLabels:
          app: my-application
  policy:
    placementType: PickFixed
    clusterNames:
    - cluster1
    - cluster2

Om du vill skapa en placering utan målkluster eller skala ned en befintlig placering till nollkluster använder du följande princip under spec:

policy:
  placementType: PickFixed
  clusterNames: []

När du rensar arrayen på en befintlig placering tar Fleet Manager bort de resurser som tidigare distribuerats av den placeringen från medlemskluster. Placeringsobjektet och de valda resurserna i hubbklustret finns kvar. Om du vill distribuera resurserna igen lägger du till målklusternamn tillbaka till clusterNames.

PickAll placeringstyp

Använd PickAll för att distribuera resurser mellan alla medlemskluster eller alla kluster som matchar ett villkor som du anger.

När du skapar den här typen av placering anger du följande klustertillhörighetstyper:

  • requiredDuringSchedulingIgnoredDuringExecution: eftersom den här principen krävs under schemaläggningen filtreras klustren baserat på de angivna kriterierna.

Det här exemplet visar hur du distribuerar prod-deployment namnområdet och alla dess underordnade resurser över alla medlemskluster märkta med environment: production.

apiVersion: placement.kubernetes-fleet.io/v1
kind: ClusterResourcePlacement
metadata:
  name: crp-pickall
spec:
  resourceSelectors:
    - group: ""
      kind: Namespace
      name: prod-deployment
      version: v1
  policy:
    placementType: PickAll
    affinity:
        clusterAffinity:
            requiredDuringSchedulingIgnoredDuringExecution:
                clusterSelectorTerms:
                - labelSelector:
                    matchLabels:
                        environment: production

Det här exemplet på ResourcePlacement (RP) placerar ConfigMap-etiketten app: my-application i namnområdet my-app i det matchande namnområdet på alla kluster som är märkta med environment: production:

apiVersion: placement.kubernetes-fleet.io/v1
kind: ResourcePlacement
metadata:
  name: app-configs-rp-pickall
  namespace: my-app
spec:
  resourceSelectors:
    - group: ""
      kind: ConfigMap
      version: v1
      labelSelector:
        matchLabels:
          app: my-application
  policy:
    placementType: PickAll
    affinity:
        clusterAffinity:
            requiredDuringSchedulingIgnoredDuringExecution:
                clusterSelectorTerms:
                - labelSelector:
                    matchLabels:
                        environment: production

PickN-placeringstyp

Använd PickN för att distribuera resurser till ett konfigurerbart antal kluster baserat på både tillhörighets- och topologispridningsbegränsningar.

När du skapar den här typen av placering anger du följande klustertillhörighetstyper:

  • requiredDuringSchedulingIgnoredDuringExecution: eftersom den här principen krävs under schemaläggningen filtreras klustren baserat på de angivna kriterierna.
  • preferredDuringSchedulingIgnoredDuringExecution: eftersom denna policy föredras men inte krävs under schemaläggningen, rangordnar den kluster baserat på angivna kriterier.

Du kan ange både obligatoriska och önskade affiniteter. Krävda anknytningar förhindrar placering i kluster som inte överensstämmer. Prioriterade tillhörigheter ger ordning på matchade kluster.

PickN med affiniteter

Att använda affinitet med en PickN placeringsprincip fungerar på samma sätt som att använda affinitet med schemaläggning av poddar i ett enskilt Kubernetes-kluster.

I följande exempel visas hur du distribuerar en resurs till tre kluster. Endast kluster med critical-allowed: "true"-etiketten är giltiga placeringsmål och företräde ges åt kluster med etiketten critical-level: 1:

apiVersion: placement.kubernetes-fleet.io/v1
kind: ClusterResourcePlacement
metadata:
  name: crp-pickn-critical-preferences
spec:
  resourceSelectors:
    - group: ""
      kind: Namespace
      name: prod-deployment
      version: v1
  policy:
    placementType: PickN
    numberOfClusters: 3
    affinity:
        clusterAffinity:
            preferredDuringSchedulingIgnoredDuringExecution:
              weight: 20
              preference:
              - labelSelector:
                  matchLabels:
                    critical-level: 1
            requiredDuringSchedulingIgnoredDuringExecution:
                clusterSelectorTerms:
                - labelSelector:
                    matchLabels:
                      critical-allowed: "true"
apiVersion: placement.kubernetes-fleet.io/v1
kind: ResourcePlacement
metadata:
  name: app-configs-rp-pickn-critical-preferences
  namespace: my-app
spec:
  resourceSelectors:
    - group: ""
      kind: ConfigMap
      version: v1
      labelSelector:
        matchLabels:
          app: my-application
  policy:
    placementType: PickN
    numberOfClusters: 3
    affinity:
        clusterAffinity:
            preferredDuringSchedulingIgnoredDuringExecution:
              weight: 20
              preference:
              - labelSelector:
                  matchLabels:
                    critical-level: 1
            requiredDuringSchedulingIgnoredDuringExecution:
                clusterSelectorTerms:
                - labelSelector:
                    matchLabels:
                      critical-allowed: "true"
PickN med topologispridningsbegränsningar

Använd topologispridningsbegränsningar för att tvinga placeringar över topologigränser för att uppfylla tillgänglighetskraven.

Du kan konfigurera beteendet för topologispridningsbegränsningar med hjälp whenUnsatisfiable av egenskapen:

  • DoNotSchedule: Om villkoret inte kan uppfyllas misslyckas placeringsbegäran.
  • ScheduleAnyway: Om villkoret inte kan uppfyllas placerar du resurser ändå.

I följande exempel visas hur du sprider resurser över flera Azure regioner och försöker schemalägga mellan medlemskluster med olika uppdateringsdagar med hjälp av en anpassad etikett updateDay.

När spridning mellan Azure-regioner inte kan uppfyllas misslyckas placeringen. Om villkoret updateDay inte uppfylls sker placeringen fortfarande.

apiVersion: placement.kubernetes-fleet.io/v1
kind: ClusterResourcePlacement
metadata:
  name: crp-pickn-locations-updates
spec:
  resourceSelectors:
    - group: ""
      kind: Namespace
      name: prod-deployment
      version: v1
  policy:
    placementType: PickN
    topologySpreadConstraints:
    - maxSkew: 2
      topologyKey: fleet.azure.com/location
      whenUnsatisfiable: DoNotSchedule
    - maxSkew: 2
      topologyKey: updateDay
      whenUnsatisfiable: ScheduleAnyway
apiVersion: placement.kubernetes-fleet.io/v1
kind: ResourcePlacement
metadata:
  name: app-configs-rp-pickn-locations-updates
  namespace: my-app
spec:
  resourceSelectors:
    - group: ""
      kind: ConfigMap
      version: v1
      labelSelector:
        matchLabels:
          app: my-application
  policy:
    placementType: PickN
    topologySpreadConstraints:
    - maxSkew: 2
      topologyKey: fleet.azure.com/location
      whenUnsatisfiable: DoNotSchedule
    - maxSkew: 2
      topologyKey: updateDay
      whenUnsatisfiable: ScheduleAnyway

Mer information finns i KubeFleet-dokumentationen om topologispridningsbegränsningar.

Välj kluster med hjälp av etiketter och egenskaper

Fleet Manager intelligent resursplacering innehåller en uppsättning kraftfulla kriterier som du kan använda när du bestämmer hur du väljer kluster när du använder typerna PickN och PickAll placering. I det här avsnittet får du lära dig hur du använder dessa alternativ för att skapa principer som passar dina behov.

Alternativ för placeringspolicy

I följande tabell visas tillgängliga schemaläggningsprincipfält för varje placeringstyp.

Politikområde PickFixed PickAll PickN
placementType ✅ ✅ ✅
affinity ❌ ✅ ✅
clusterNames ✅ ❌ ❌
numberOfClusters ❌ ❌ ✅
topologySpreadConstraints ❌ ❌ ✅

Medlemsklusteretiketter

Du kan märka resursen MemberCluster i hubbklustret som vilken Kubernetes-resurs som helst.

Dessutom lägger Fleet Manager automatiskt till följande skrivskyddade etiketter på alla medlemskluster.

Etikett Beskrivning
fleet.azure.com/location Azure-regionen för klustret (westus)
fleet.azure.com/resource-group Azure resursgrupp för klustret (rg_prodapps_01)
fleet.azure.com/subscription-id Azure abonnemangsidentifierare som klustret är inhyst i. Formaterad som UUID/GUID.
fleet.azure.com/cluster-name Namnet på klustret som är associerat med flottans medlemsklusterresurs.
fleet.azure.com/member-name Namnet på fleet manager-medlemsklusternamnet som motsvarar klustret.

Klusteregenskaper

Använd följande egenskaper som en del av placeringsprinciper.

Egenskapsnamn Beskrivning
kubernetes-fleet.io/node-count Tillgängliga noder i medlemsklustret.
resources.kubernetes-fleet.io/total-cpu Totalt antal cpu-resursenheter i klustret.
resources.kubernetes-fleet.io/tilldelningsbar-cpu Allokerbara CPU-resursenheter i klustret.
resources.kubernetes-fleet.io/tillgänglig-cpu Tillgängliga CPU-resursenheter i klustret.
resources.kubernetes-fleet.io/total-memory Total minnesresursenhet i klustret.
resources.kubernetes-fleet.io/tillgängligt-minne Allokerbara minnesresursenheter i klustret.
resources.kubernetes-fleet.io/available-memory Tillgängliga minnesresursenheter i klustret.
kubernetes.azure.com/per-cpu-core-cost Kostnaden per cpu-kärna för klustret.
kubernetes.azure.com/per-gb-minneskostnad Kostnaden per GiB-minne för klustret.
kubernetes.azure.com/vm-sizes/{vm-sku-name}/count Det tillgängliga antalet befintliga noder av typen vm-sku-name i klustret*.
Exempel på VM SKU-namn: NV16as_v4.
* I förhandsversion via v1beta1 API.
kubernetes.azure.com/vm-sizes/{vm-sku-name}/capacity Antalet potentiella nya noder av typen vm-sku-name i klustrets Azure-region*.
Exempel på VM SKU-namn: NV16as_v4.
* I förhandsversion via v1beta1 API.
  • Kubernetes-resursenheter representerar processor- och minnesegenskaper. Mer information finns i Resursenheter i Kubernetes.

  • Kostnadsegenskaper är decimaler som representerar en kostnad per timme i us-dollar för den Azure beräkning som noder i klustret använder. Kostnaden baseras på offentliga Azure-priser.

Urvalsmatchningsvillkor

När du använder klusteregenskaper i ett principvillkor anger du:

  • Namn: Namnet på egenskapen, som är en av egenskaperna som anges i egenskaperna i den här artikeln.

  • Operator: En operator som uttrycker villkoret mellan villkoret eller önskat värde och det observerade värdet i klustret. Följande operatorer stöds för närvarande:

    • Gt (Större än): ett klusters observerade värde för den angivna egenskapen måste vara större än värdet i villkoret innan det kan väljas för resursplacering.
    • Ge (Större än eller lika med): ett klusters observerade värde för den angivna egenskapen måste vara större än eller lika med värdet i villkoret innan det kan väljas för resursplacering.
    • Lt (Mindre än): ett klusters observerade värde för den angivna egenskapen måste vara mindre än värdet i villkoret innan det kan väljas för resursplacering.
    • Le (Mindre än eller lika med): ett klusters observerade värde för den angivna egenskapen måste vara mindre än eller lika med värdet i villkoret innan det kan plockas för resursplacering.
    • Eq (Lika med): ett klusters observerade värde för den angivna egenskapen måste vara lika med värdet i villkoret innan det kan väljas för resursplacering.
    • Ne (Inte lika med): ett klusters observerade värde för den angivna egenskapen får inte vara lika med värdet i villkoret innan det kan väljas för resursplacering.

    Om du använder operatorn Gt, Ge, Lt, Le, Eqeller Ne, bör listan med värden i villkoret ha exakt ett värde.

  • Värden: En lista med värden, som är möjliga värden för egenskapen.

Fleet utvärderar varje kluster baserat på de egenskaper som du anger i villkoret. Om ett kluster inte uppfyller de villkor som anges under requiredDuringSchedulingIgnoredDuringExecutionutesluter Fleet klustret från resursplacering.

Anmärkning

Om ett medlemskluster inte har egenskapen uttryckt i villkoret misslyckas villkoret automatiskt.

Här är ett exempel på en placeringsprincip för att endast välja kluster med fem eller fler noder.

apiVersion: placement.kubernetes-fleet.io/v1
kind: ClusterResourcePlacement
metadata:
  name: crp-pickall-five-nodes
spec:
  resourceSelectors:
    - group: ""
      kind: Namespace
      name: prod-deployment
      version: v1
  policy:
    placementType: PickAll
    affinity:
        clusterAffinity:
            requiredDuringSchedulingIgnoredDuringExecution:
                clusterSelectorTerms:
                - propertySelector:
                    matchExpressions:
                    - name: "kubernetes-fleet.io/node-count"
                      operator: Ge
                      values:
                      - "5"
apiVersion: placement.kubernetes-fleet.io/v1
kind: ResourcePlacement
metadata:
  name: app-configs-rp-pickall-five-nodes
  namespace: my-app
spec:
  resourceSelectors:
    - group: ""
      kind: ConfigMap
      version: v1
      labelSelector:
        matchLabels:
          app: my-application
  policy:
    placementType: PickAll
    affinity:
        clusterAffinity:
            requiredDuringSchedulingIgnoredDuringExecution:
                clusterSelectorTerms:
                - propertySelector:
                    matchExpressions:
                    - name: "kubernetes-fleet.io/node-count"
                      operator: Ge
                      values:
                      - "5"

Så här fungerar egenskapsrankning

När du använder preferredDuringSchedulingIgnoredDuringExecutionrangordnar en egenskapssorterare alla kluster i flottan baserat på deras värden i en stigande eller fallande ordning. De vikter som används för beställning beräknas baserat på det värde du anger.

En egenskapssorterare består av:

  • Namn: Namnet på klusteregenskapen.
  • Sorteringsordning: Sorteringsordning kan vara antingen Ascending eller Descending. När du använder Ascending ordning föredras medlemskluster med lägre observerade värden. När du använder Descending ordning föredras medlemskluster med högre observerat värde.

Mer information finns i KubeFleet-dokumentationen om egenskapsbaserad schemaläggning.

Konfigurera distributionsstrategi

Fleet Manager-resursplacering använder en standardstrategi RollingUpdate för att styra hur resurser distribueras till medlemskluster.

I följande exempel distribueras placeringen till varje medlemskluster sekventiellt och väntar minst unavailablePeriodSeconds mellan kluster.

apiVersion: placement.kubernetes-fleet.io/v1
kind: ClusterResourcePlacement
metadata:
  name: crp-pick-all-rolling
spec:
  resourceSelectors:
    - group: ""
      kind: Namespace
      name: prod-deployment
      version: v1
  policy:
    placementType: PickAll
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 25%
      maxSurge: 25%
      unavailablePeriodSeconds: 60
apiVersion: placement.kubernetes-fleet.io/v1
kind: ResourcePlacement
metadata:
  name: app-configs-rp-pickall-rolling
  namespace: my-app
spec:
  resourceSelectors:
    - group: ""
      kind: ConfigMap
      version: v1
      labelSelector:
        matchLabels:
          app: my-application
  policy:
    placementType: PickAll
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 25%
      maxSurge: 25%
      unavailablePeriodSeconds: 60

Utrullningsstatusen anses vara lyckad om alla resurser har applicerats korrekt på klustret. Den här statusen kaskaderar inte status för underordnade resurser, så den bekräftar inte att poddar som skapats i ett medlemskluster genom en driftsättning når statusen Ready.

Mer information finns i dokumentationen om distributionsstrategier.

Använda toleranser

Du kan smutsa ned medlemskluster på samma sätt som du smutsar ned noder i ett kluster.

Resursplaceringar stöder användning av toleranser där varje tolerans består av följande fält:

  • key: Tolerationens nyckel.
  • value: Värdet för toleransen.
  • effect: Effekten av toleransen, till exempel NoSchedule.
  • operator: Operatorn för toleransen, till exempel Exists eller Equal.

Varje tolerans används för att tolerera en eller flera specifika taints som tillämpas på en MemberCluster. När alla taints tolereras kan Fleet Manager distribuera resurser till ett medlemskluster.

apiVersion: placement.kubernetes-fleet.io/v1
kind: ClusterResourcePlacement
metadata:
  name: test-ns
spec:
  policy:
    placementType: PickAll
    tolerations:
      - key: app-team-a
        operator: Exists
  resourceSelectors:
    - group: ""
      kind: Namespace
      name: test-ns
      version: v1
  revisionHistoryLimit: 10
  strategy:
    type: RollingUpdate
apiVersion: placement.kubernetes-fleet.io/v1
kind: ResourcePlacement
metadata:
  name: app-configs-rp-pickall-rolling
  namespace: my-app
spec:
  resourceSelectors:
    - group: ""
      kind: ConfigMap
      version: v1
      labelSelector:
        matchLabels:
          app: my-application
  policy:
    placementType: PickAll
    tolerations:
      - key: app-team-a
        operator: Exists
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 25%
      maxSurge: 25%
      unavailablePeriodSeconds: 60

Mer information finns i dokumentationen om toleranser.

Använda kuvertresurser

Fleet Manager-hubbklustret är också ett Kubernetes-kluster. Använd först alla resurser som du vill distribuera till hubbklustret. Denna metod kan leda till:

  1. Oönskade biverkningar: ValidatingWebhookConfigurations, MutatingWebhookConfigurations eller Admission Controllers blir aktiva i hubbklustret, vilket kan fånga upp och påverka hubbklusteråtgärder.

  2. Säkerhetsrisker: RBAC-resurser (Roller, ClusterRoles, RoleBindings, ClusterRoleBindings) som är avsedda för medlemskluster kan ge eller begränsa behörigheter på hubbklustret.

  3. Resursbegränsningar: ResourceQuotas, FlowSchema eller LimitRanges som definierats för medlemskluster träder i kraft på hubbklustret.

För att undvika onödiga biverkningar tillhandahåller Fleet Manager anpassade kuvertresurser (ClusterResourceEnvelope och ResourceEnvelope) för att omsluta objekt och undvika dessa potentiella problem.

Du tillämpar kuvertresursen på hubbklustret, men de resurser som den innehåller extraheras och tillämpas när de når medlemskluster.

Mer information finns i dokumentationen om kuvertobjekt.

Fastställa placeringsstatus

Fleet Manager-resursplacering ger två sätt att visa status beroende på åtkomstnivå och krav för hubbkluster:

  • ClusterResourcePlacement-status: Visa placeringsstatus direkt på den klusteromfångsbegränsade ClusterResourcePlacement resursen. Använd när du har behörigheter på klusternivå och behöver visa status för alla placeringar i hela flottan.
  • ResourcePlacement-status: Visa placeringsstatus direkt på den namnområdesomfångsbegränsade ResourcePlacement resursen. Använd när du har behörigheter på namnområdesnivå och behöver visa status för en namnområdesomfångsplacering i hela flottan.

Visa Status för ClusterResourcePlacement

kubectl describe resourceplacement <rp-name> Använd kommandot för att visa den här informationen.

kubectl describe resourceplacement place-cmap-1
  • ClusterResourcePlacementStatus: Visa placeringsstatus via en resurs med namnområdesomfång ClusterResourcePlacementStatus. Använd den här resursen när namnområdesomfångsanvändare behöver visa placeringsstatus utan att bevilja behörigheter på klusternivå. Mer information finns i avsnittet ClusterResourcePlacementStatus.

Båda metoderna innehåller följande information:

  • De villkor som för närvarande gäller för placeringen, bland annat om placeringen har slutförts.
  • Ett avsnitt om placeringsstatus för varje medlemskluster som visar status för distributionen till klustret.

Använd ClusterResourcePlacement-statusen

Följande exempel visar status direkt från en ClusterResourcePlacement som har distribuerat namnområdet test och ConfigMap test-1 till två medlemskluster med hjälp av PickN. Placeringen slutfördes och resurserna placerades i klustren aks-member-1 och aks-member-2 .

kubectl describe clusterresourceplacement <crp-name> Använd kommandot för att visa den här informationen.

kubectl describe clusterresourceplacement crp-1
Name:         crp-1
Namespace:
Labels:       <none>
Annotations:  <none>
API Version:  placement.kubernetes-fleet.io/v1
Kind:         ClusterResourcePlacement
Metadata:
  ...
Spec:
  Policy:
    Number Of Clusters:  2
    Placement Type:      PickN
  Resource Selectors:
    Group:
    Kind:                  Namespace
    Name:                  test
    Version:               v1
  Revision History Limit:  10
Status:
  Conditions:
    Last Transition Time:  2023-11-10T08:14:52Z
    Message:               found all the clusters needed as specified by the scheduling policy
    Observed Generation:   5
    Reason:                SchedulingPolicyFulfilled
    Status:                True
    Type:                  ClusterResourcePlacementScheduled
    Last Transition Time:  2023-11-10T08:23:43Z
    Message:               All 2 cluster(s) are synchronized to the latest resources on the hub cluster
    Observed Generation:   5
    Reason:                SynchronizeSucceeded
    Status:                True
    Type:                  ClusterResourcePlacementSynchronized
    Last Transition Time:  2023-11-10T08:23:43Z
    Message:               Successfully applied resources to 2 member clusters
    Observed Generation:   5
    Reason:                ApplySucceeded
    Status:                True
    Type:                  ClusterResourcePlacementApplied
  Placement Statuses:
    Cluster Name:  aks-member-1
    Conditions:
      Last Transition Time:  2023-11-10T08:14:52Z
      Message:               Successfully scheduled resources for placement in aks-member-1 (affinity score: 0, topology spread score: 0): picked by scheduling policy
      Observed Generation:   5
      Reason:                ScheduleSucceeded
      Status:                True
      Type:                  ResourceScheduled
      Last Transition Time:  2023-11-10T08:23:43Z
      Message:               Successfully Synchronized work(s) for placement
      Observed Generation:   5
      Reason:                WorkSynchronizeSucceeded
      Status:                True
      Type:                  WorkSynchronized
      Last Transition Time:  2023-11-10T08:23:43Z
      Message:               Successfully applied resources
      Observed Generation:   5
      Reason:                ApplySucceeded
      Status:                True
      Type:                  ResourceApplied
    Cluster Name:            aks-member-2
    Conditions:
      Last Transition Time:  2023-11-10T08:14:52Z
      Message:               Successfully scheduled resources for placement in aks-member-2 (affinity score: 0, topology spread score: 0): picked by scheduling policy
      Observed Generation:   5
      Reason:                ScheduleSucceeded
      Status:                True
      Type:                  ResourceScheduled
      Last Transition Time:  2023-11-10T08:23:43Z
      Message:               Successfully Synchronized work(s) for placement
      Observed Generation:   5
      Reason:                WorkSynchronizeSucceeded
      Status:                True
      Type:                  WorkSynchronized
      Last Transition Time:  2023-11-10T08:23:43Z
      Message:               Successfully applied resources
      Observed Generation:   5
      Reason:                ApplySucceeded
      Status:                True
      Type:                  ResourceApplied
  Selected Resources:
    Kind:       Namespace
    Name:       test
    Version:    v1
    Kind:       ConfigMap
    Name:       test-1
    Namespace:  test
    Version:    v1
Events:
  Type    Reason                     Age                    From                                   Message
  ----    ------                     ----                   ----                                   -------
  Normal  PlacementScheduleSuccess   12m (x5 over 3d22h)    cluster-resource-placement-controller  Successfully scheduled the placement
  Normal  PlacementSyncSuccess       3m28s (x7 over 3d22h)  cluster-resource-placement-controller  Successfully synchronized the placement
  Normal  PlacementRolloutCompleted  3m28s (x7 over 3d22h)  cluster-resource-placement-controller  Resources have been applied to the selected clusters

Använd ClusterResourcePlacementStatus-resurs

Resursen ClusterResourcePlacementStatus är begränsad till namnområdet och ger en namnområdesspecifik vy över statusen för ett motsvarande objekt med klusteromfång ClusterResourcePlacement. Den här resursen gör det möjligt för namnområdesanvändare utan behörighet på klusternivå att läsa placeringsstatus utan att exponera information utanför namnområdet.

Viktigt!

Från och med den 31 januari 2027 innehåller den namnområdesspecifika vyn endast det valda namnområdet och resurserna och referenserna i det namnområdet. Fleet Manager utelämnar klusteromfattande resurser och resurser över namnrymdsgränser och referenser. Den ersätter också icke-tomma medlemskluster- och hubbvärden i drift- och skillnadsinformation med (redacted). Den klusteromfattande statusen ClusterResourcePlacement förblir oförändrad.

Om du vill använda den här metoden konfigurerar du ClusterResourcePlacement med statusReportingScope: NamespaceAccessible med hjälp av API:et v1 .

När du anger statusReportingScope till NamespaceAccessiblekan du bara ange en namnområdesresursväljare och du kan inte ändra den när du har skapat den.

Konfigurerar ClusterResourcePlacementStatus

Om du vill använda den här funktionen anger du API-versionen v1 i :ClusterResourcePlacement

apiVersion: placement.kubernetes-fleet.io/v1
kind: ClusterResourcePlacement
metadata:
  name: crp-with-status-reporting
spec:
  statusReportingScope: NamespaceAccessible
  resourceSelectors:
    - group: ""
      kind: Namespace
      name: my-app
      version: v1
  policy:
    placementType: PickAll

Visa ClusterResourcePlacementStatus

Du kan visa statusen kubectl describe med hjälp av kommandot:

kubectl describe clusterresourceplacementstatuses.v1.placement.kubernetes-fleet.io crp-with-status-reporting -n my-app

Utdata innehåller statusinformationen som visas i det valda namnområdet. Den innehåller det valda namnområdet, resurser i namnområdet och referenser till resursåsidosättningar och resurskuvert i samma namnområde. Den innehåller inte klusteromfattande resurser eller resurser mellan namnrymder, åsidosättningar av klusterresurser eller omslutande klusterresurser.

Detaljer om drift och skillnad behåller sina JSON-sökvägar. Fleet Manager ersätter varje nonempty valueInMember och valueInHub värde med (redacted). Ett tomt värde fortsätter att indikera att JSON-sökvägen inte finns på den sidan.

Om ett program läser ClusterResourcePlacementStatus, uppdatera det före den 31 januari 2027 för att tolerera utelämnade poster och behandla redigeringsmarkören som otillgängliga data. Om programmet kräver fullständiga resursidentiteter eller råa drift- och differensvärden, ska du läsa den klusteromfattande ClusterResourcePlacement statusen med hjälp av autentiseringsuppgifter med lämpliga behörigheter för rollbaserad åtkomstkontroll på klusternivå (RBAC).

Mer information finns i dokumentationen om hur du förstår placeringsresultatet.

Utlösare för placeringsändring

Fleet Manager-schemaläggaren prioriterar stabiliteten för befintliga resursplaceringar. Den här prioriteten begränsar antalet ändringar som tar bort och schemalägg om en resurs.

Följande scenarier kan utlösa placeringsändringar:

  • Ändringar i placeringsprincipen i resursplaceringen (ClusterResourcePlacement eller ResourcePlacement) kan utlösa borttagning och omläggning av en resurs.
    • Utskalningsåtgärder (ökar numberOfClusters utan andra ändringar) placerar arbetsbelastningar endast på nya kluster och påverkar inte befintliga placeringar.
  • Ändringar i medlemskluster, inklusive:
    • Ett nytt medlemskluster som blir kvalificerat och uppfyller placeringspolicyn, till exempel en PickAll-policy.
    • Borttagning av ett medlemskluster från flottan. Beroende på principen försöker schemaläggaren placera alla berörda resurser på återstående kluster utan att påverka befintliga placeringar.

Om du uppdaterar de valda resurserna (till exempel att ändra en Deployment) eller uppdatera resourceSelector i en resursplacering kan Fleet Manager gradvis distribuera befintliga placeringar men inte utlösa omplanering (det vill säga ändra valda kluster) för resursen.

Arbeta med ResourcePlacement och ClusterResourcePlacement tillsammans

Även om ClusterResourcePlacement det förutsätts att namnområden representerar programgränser, är verkliga användningsmönster ofta mer komplexa. Organisationer använder ofta namnområden som gruppgränser snarare än programgränser. Den här metoden leder till flera utmaningar som ResourcePlacement direkt åtgärdar:

Namnområden för flera program: I många organisationer innehåller ett enda namnområde flera oberoende program som ägs av samma team. Dessa program kan ha:

  • Olika livscykelkrav. Ett program kan till exempel behöva frekventa uppdateringar medan ett annat förblir stabilt.
  • Olika klusterplaceringsbehov. Till exempel utveckling kontra produktionsprogram.
  • Oberoende skalning och resurskrav.
  • Separata efterlevnads- eller styrningskrav.

Beslut om individuell schemaläggning: Många arbetsbelastningar, särskilt AI/ML-jobb, kräver individuella schemaläggningsbeslut:

  • AI-jobb: Maskininlärningsarbetsbelastningar består ofta av kortvariga, resursintensiva jobb som måste schemaläggas baserat på klusterresurstillgänglighet, GPU-tillgänglighet eller datalokalitet.
  • Batcharbetsbelastningar: Olika batchjobb inom samma namnområde kan rikta in sig på olika klustertyper baserat på beräkningskrav.

Fullständig kontroll över programteamet: ResourcePlacement Ger programteam direkt kontroll över sin resursplacering utan att behöva vidta åtgärder för plattformsteamet:

  • Självbetjäningsåtgärder: Teams kan hantera sina egna strategier för resursdistribution.
  • Oberoende distributionscykler: Olika program inom ett namnområde kan ha oberoende distributionsscheman.
  • Granulära åsidosättningsmöjligheter: Team kan skräddarsy resurskonfigurationer per kluster utan att påverka andra applikationer i namnrymden.

Den här detaljerade metoden säkerställer att den kan anpassas till olika organisationsstrukturer och arbetsbelastningsmönster samtidigt som ResourcePlacement enkelheten och kraften i fleet-schemaläggningsramverket bibehålls.

Viktiga skillnader mellan ResourcePlacement och ClusterResourcePlacement

I följande tabell visas de viktigaste skillnaderna mellan ResourcePlacement och ClusterResourcePlacement:

Aspekt ResourcePlacement (RP) ClusterResourcePlacement (CRP)
Scope Endast resurser med namnområdesscope Klusteromfångsresurser (särskilt namnområden och deras innehåll)
Resource API-objekt som är namnområdesspecifikt API-objekt med klusteromfattning
Markeringsgräns Begränsat till resurser inom samma namnområde som RP Kan välja valfri klusteromfattningsresurs
Vanliga användningsfall AI/ML-jobb, enskilda arbetsbelastningar, specifika ConfigMaps/Secrets som behöver separata beslut om placering Programpaket, hela namnområden, klusteromfattande principer
Teamägarskap Namnområdesägare och utvecklare Plattformsoperatorer

Både ResourcePlacement och ClusterResourcePlacement delar samma kärnfunktioner för alla andra aspekter som inte visas i tabellen med skillnader.

Exempelscenario med ResourcePlacement och ClusterResourcePlacement

ResourcePlacement fungerar med ClusterResourcePlacement (CRP) för att tillhandahålla en komplett resurshanteringslösning för flera kluster. Att förstå den här relationen är avgörande för effektiv hantering av flottan.

Viktigt!

ResourcePlacement kan bara placera namnområdesomfångsresurser till kluster som redan har målnamnområdet. Används ClusterResourcePlacement för namnområdesetablering.

Typiskt arbetsflöde:

  1. Plattformsadministratörer: Använd ClusterResourcePlacement för att distribuera namnområden i hela flottan.
  2. Programteam: Använd ResourcePlacement för att hantera specifika resurser inom de etablerade namnrymderna.

Följande exempel visar hur du samordnar CRP och RP.

Plattformsadministratör: Skapa namnområdet genom att använda ClusterResourcePlacement:

apiVersion: placement.kubernetes-fleet.io/v1
kind: ClusterResourcePlacement
metadata:
  name: app-namespace-crp
spec:
  resourceSelectors:
    - group: ""
      kind: Namespace
      name: my-app
      version: v1
      selectionScope: NamespaceOnly # only namespace itself is placed, no resources within the namespace
  policy:
    placementType: PickAll # If placement type is not PickAll, the application teams needs to know what are the clusters they can place their applications.

Programteam: Hantera specifika resurser inom namnområdet med hjälp ResourcePlacementav :

apiVersion: placement.kubernetes-fleet.io/v1
kind: ResourcePlacement
metadata:
  name: app-configs-rp
  namespace: my-app
spec:
  resourceSelectors:
    - group: ""
      kind: ConfigMap
      version: v1
      labelSelector:
        matchLabels:
          app: my-application
  policy:
    placementType: PickFixed
    clusterNames:
    - cluster1
    - cluster2

Metodtips för ResourcePlacement och ClusterResourcePlacement

När du använder ResourcePlacement med ClusterResourcePlacementföljer du dessa metodtips:

  • Etablera namnområden först: Distribuera alltid namnområden via CRP innan du skapar ResourcePlacement objekt.
  • Övervaka beroenden: Använd fleetövervakning för att säkerställa att CRP:er på namnområdesnivå är felfria innan du distribuerar beroende RP:er.
  • Koordinatprinciper: Justera CRP- och RP-placeringsprinciper för att undvika konflikter. Om CRP till exempel placerar namnområdet på kluster A, B och C kan RP rikta in sig på alla delmängder av dessa kluster.
  • Gruppgränser: Använd CRP för plattformshanterade resurser (namnområden, RBAC) och RP för programhanterade resurser (appkonfigurationer, hemligheter).

Den här samordnade metoden säkerställer att ger den flexibilitet som ResourcePlacement teamen behöver samtidigt som den grundläggande infrastrukturen som hanteras av plattformsoperatörer upprätthålls.

Resursval, placering och distribution

ResourcePlacement använder samma placeringsmönster som ClusterResourcePlacement:

  • Placeringsprincip: PickAll, PickFixedoch PickN principer fungerar identiskt för båda API:erna.
  • Distributionsstrategi: Kontrollera hur uppdateringar sprids mellan kluster med samma mekanismer för löpande uppdatering.
  • Status och observerbarhet: Övervaka distributionsförloppet med hjälp kubectl describe resourceplacement <name> -n <namespace>av .
  • Avancerade funktioner: Använd toleranser, resurs åsidosättningar, begränsningar för topologispridning och tillhörighetsregler.

Den viktigaste skillnaden är omfånget för resursval . Medan ClusterResourcePlacement vanligtvis väljer hela namnområden och deras innehåll, ger ResourcePlacement detaljerad kontroll över enskilda resurser som omfattas av namnområden.

Nästa steg