Utilisez Resource Overrides pour personnaliser les ressources déployées par le placement de ressources du Azure Kubernetes Fleet Manager.

S’applique à : ✔️ Fleet Manager avec cluster hub

Le placement intelligent des ressources Azure Kubernetes Fleet Manager peut être utilisé pour déployer la même ressource sur plusieurs clusters dans une flotte. Il est souvent nécessaire de modifier la configuration des ressources pour appliquer des règles relatives au comportement dans différents environnements (développement, test, prod). À cet effet, Fleet Manager offre des surcharges de ressources, qui offrent une fonctionnalité conceptuellement similaire à la façon dont les modèles Helm et les patches Kustomize sont utilisés.

Voici quelques exemples de situations où la modification d’une configuration de ressource est utile :

  • Je souhaite utiliser un ClusterRole nommé secret-reader sur tous les clusters, mais avec un plus petit jeu d’actions autorisées pour ce rôle dans mes clusters de production.
  • Je veux utiliser le même Deployment sur tous les clusters, mais des images de conteneur ou des ports différents sur mes clusters de production.

Cet article explique comment créer des remplacements pour les ressources déployées via le placement de ressources de Fleet Manager.

Azure Kubernetes Fleet Manager prend en charge deux niveaux pour les substitutions :

  • Étendue limitée au cluster : utilisez ClusterResourceOverride avec ClusterResourcePlacement pour les administrateurs de flotte qui gèrent les modifications au niveau de l’infrastructure.
  • Étendue limitée à l’espace de noms: utilisez ResourceOverride avec ResourcePlacement pour les équipes d’application qui gèrent les déploiements au sein de leurs espaces de noms spécifiques.

Vous pouvez sélectionner l’étendue la plus applicable à vous dans les choix de type d’étendue en haut de l’article.

Remplacements de ressources dans l’étendue du cluster

Un ClusterResourceOverride possède les propriétés suivantes :

  • clusterResourceSelectors: spécifie l'ensemble des ressources de cluster sélectionnées pour le remplacement.
  • policy: spécifie l’ensemble de règles à appliquer aux ressources de cluster sélectionnées.

Note

Policy les définitions sont identiques pour les ressources de cluster et celles délimitées par l'espace de noms.

Utilisons l’exemple ClusterRole suivant nommé secret-reader pour illustrer le ClusterResourceOverride fonctionnement.

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: secret-reader
rules:
- apiGroups: [""]
  resources: ["secrets"]
  verbs: ["get", "watch", "list"]

Sélection des ressources de cluster

Un ClusterResourceOverride peut inclure un ou plusieurs clusterResourceSelector afin de déterminer quelles ressources doivent être remplacées. Chacun clusterResourceSelector prend en charge les champs suivants.

  • group: groupe d’API de la ressource.
  • version: version d’API de la ressource.
  • kind: type de ressource.
  • name: nom de la ressource.

Note

Si vous sélectionnez un espace de noms dans le ClusterResourceSelector, celui-ci s’applique à toutes les ressources de cet espace de noms.

À l’aide de notre exemple ClusterRole, voyons comment nous le sélectionnons dans un ClusterResourceOverride.

apiVersion: placement.kubernetes-fleet.io/v1
kind: ClusterResourceOverride
metadata:
  name: example-cro
spec:
  clusterResourceSelectors:
    - group: rbac.authorization.k8s.io
      kind: ClusterRole
      version: v1
      name: secret-reader

Remplacements de ressources à portée d’espace de noms (version préliminaire)

Un ResourceOverride possède les propriétés suivantes :

  • resourceSelectors: spécifie l’ensemble de ressources sélectionnées pour le remplacement.
  • policy: spécifie l’ensemble de règles à appliquer aux ressources sélectionnées.

Note

Policy les définitions sont identiques pour les ressources de cluster et celles à l'échelle du namespace.

Utilisons l’exemple Deployment suivant nommé nginx-sample pour illustrer le ResourceOverride fonctionnement.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-sample
  namespace: nginx-demo
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:1.25
          ports:
            - containerPort: 80

Sélection des ressources d’espace de noms

Un ResourceOverride peut inclure un ou plusieurs resourceSelector pour choisir les ressources à remplacer. Chacun resourceSelector prend en charge les champs suivants.

  • group: groupe d’API de la ressource.
  • version: version d’API de la ressource.
  • kind: type de ressource.
  • name: nom de la ressource.

L’espace de noms de la ressource à remplacer est déterminé en spécifiant le namespace dans la metadata du ResourceOverride.

À l’aide de notre exemple Deployment, voyons comment nous le sélectionnons dans un ResourceOverride.

apiVersion: placement.kubernetes-fleet.io/v1
kind: ResourceOverride
metadata:
  name: example-resource-override
  namespace: nginx-demo
spec:
  resourceSelectors:
    -  group: apps
       kind: Deployment
       version: v1
       name: nginx-sample

Important

  • Si vous sélectionnez un espace de noms dans le resourceSelector (kind: Namespace), celui-ci s’applique à toutes les ressources de cet espace de noms.
  • Le ResourceOverride doit se trouver dans le même espace de noms que la ressource à remplacer.

Nous avons maintenant la ressource sélectionnée. Voyons comment configurer le remplacement à l’aide d’un policy.

Policy

Un policy comprend un ensemble de overrideRules qui spécifient les modifications à appliquer aux ressources sélectionnées. Chacun overrideRules prend en charge les champs suivants :

  • clusterSelector: spécifie l’ensemble de clusters auxquels la règle de remplacement s’applique.
  • jsonPatchOverrides: spécifie les modifications à appliquer aux ressources sélectionnées.

Sélecteur de cluster

Vous pouvez utiliser le clusterSelector champ dans le overrideRules pour spécifier les clusters auxquels la règle s’applique. Le clusterSelector prend en charge le champ suivant :

  • clusterSelectorTerms: liste de termes qui spécifient les critères de sélection de clusters. Chaque terme inclut un labelSelector champ qui définit un ensemble d’étiquettes à mettre en correspondance.

Important

Seul labelSelector est pris en charge dans le champ clusterSelectorTerms.

Remplacements via correctif JSON

Vous pouvez utiliser jsonPatchOverrides dans overrideRules pour spécifier les modifications à appliquer aux ressources sélectionnées. La JsonPatch propriété prend en charge les champs suivants :

  • op: opération à effectuer. Les opérations prises en charge sont les suivantes :

    • add: ajoute une nouvelle valeur au chemin d’accès spécifié.
    • remove: supprime la valeur au niveau du chemin spécifié.
    • replace: remplace la valeur au chemin spécifié.

  • path: chemin d’accès au champ à modifier. Des conseils sur la spécification des chemins d’accès incluent :

    • Doit commencer par un caractère de barre oblique (/).
    • Ne peut pas être vide ou contenir une chaîne vide.
    • Il ne peut pas s’agir d’un TypeMeta champ (/kind ou /apiVersion).
    • Ne peut pas être un Metadata champ (/metadata/name ou /metadata/namespace), à l’exception des champs /metadata/labels et /metadata/annotations.
    • Le correctif ne peut pas cibler un champ de la section status de la ressource.

    Voici quelques exemples de chemins valides :

    • /metadata/labels/new-label
    • /metadata/annotations/new-annotation
    • /spec/template/spec/containers/0/resources/limits/cpu
    • /spec/template/spec/containers/0/resources/requests/memory

  • value: valeur à ajouter, supprimer ou remplacer. Si op est remove, vous ne pouvez pas spécifier value.

Les jsonPatchOverrides champs appliquent un correctif JSON sur les ressources sélectionnées en suivant RFC 6902.

En prolongeant notre exemple, nous configurons un policy pour supprimer le verbe list du ClusterRole nommé secret-reader sur les clusters étiquetés avec env:prod.

apiVersion: placement.kubernetes-fleet.io/v1
kind: ClusterResourceOverride
metadata:
  name: example-cro
spec:
  clusterResourceSelectors:
    - group: rbac.authorization.k8s.io
      kind: ClusterRole
      version: v1
      name: secret-reader
  policy:
    overrideRules:
      - clusterSelector:
          clusterSelectorTerms:
            - labelSelector:
                matchLabels:
                  env: prod
        jsonPatchOverrides:
          - op: remove
            path: /rules/0/verbs/2

En étendant notre exemple, nous configurons un policy pour remplacer l’image du conteneur dans Deployment par celle de nginx:1.30.0 pour les clusters avec le label env: prod.

apiVersion: placement.kubernetes-fleet.io/v1
kind: ResourceOverride
metadata:
  name: example-resource-override
  namespace: test-namespace
spec:
  resourceSelectors:
    -  group: apps
       kind: Deployment
       version: v1
       name: test-nginx
  policy:
    overrideRules:
      - clusterSelector:
          clusterSelectorTerms:
            - labelSelector:
                matchLabels:
                  env: prod
        jsonPatchOverrides:
          - op: replace
            path: /spec/template/spec/containers/0/image
            value: "nginx:1.30.0"

Définir plusieurs remplacements.

Vous pouvez ajouter plusieurs jsonPatchOverrides éléments à overrideRules pour appliquer plusieurs modifications aux ressources de cluster sélectionnées. Voici un exemple :

Cet exemple supprime les verbes « list » et « watch » dans notre exemple ClusterRole nommé secret-reader sur des clusters avec l’étiquette env: prod.

apiVersion: placement.kubernetes-fleet.io/v1
kind: ClusterResourceOverride
metadata:
  name: cro-1
spec:
  clusterResourceSelectors:
    - group: rbac.authorization.k8s.io
      kind: ClusterRole
      version: v1
      name: secret-reader
  policy:
    overrideRules:
      - clusterSelector:
          clusterSelectorTerms:
            - labelSelector:
                matchLabels:
                  env: prod
        jsonPatchOverrides:
          - op: remove
            path: /rules/0/verbs/2
          - op: remove
            path: /rules/0/verbs/1

Cet exemple remplace à la fois l’image conteneur et le port dans Deployment par 443 pour les clusters portant l’étiquette env: prod.

apiVersion: placement.kubernetes-fleet.io/v1
kind: ResourceOverride
metadata:
  name: example-resource-override
  namespace: test-namespace
spec:
  resourceSelectors:
    -  group: apps
       kind: Deployment
       version: v1
       name: test-nginx
  policy:
    overrideRules:
      - clusterSelector:
          clusterSelectorTerms:
            - labelSelector:
                matchLabels:
                  env: prod
        jsonPatchOverrides:
          - op: replace
            path: /spec/template/spec/containers/0/image
            value: "nginx:1.30.0"
          - op: replace
            path: /spec/template/spec/containers/0/ports/0/containerPort
            value: "443"

Variables réservées dans la valeur du correctif JSON

Les variables réservées sont remplacées au moment du placement par la value dans la règle de correctif JSON. Variables réservées actuellement prises en charge :

  • ${MEMBER-CLUSTER-NAME}: remplacé par le nom du memberCluster.

Par exemple, pour créer un nom d’hôte DNS Azure qui contient le nom du cluster, l’exemple ResourceOverride, ajoute une valeur fleet-clustername-eastus aux clusters de la région Azure eastus.

apiVersion: placement.kubernetes-fleet.io/v1
kind: ResourceOverride
metadata:
  name: ro-kuard-demo-eastus
  namespace: kuard-demo
spec:
  placement:
    name: crp-kuard-demo
  resourceSelectors:
    -  group: ""
        kind: Service
        version: v1
        name: kuard-svc
  policy:
    overrideRules:
      - clusterSelector:
          clusterSelectorTerms:
            - labelSelector:
                matchLabels:
                  fleet.azure.com/location: eastus
        jsonPatchOverrides:
          - op: add
            path: /metadata/annotations
            value:
              {"service.beta.kubernetes.io/azure-dns-label-name":"fleet-${MEMBER-CLUSTER-NAME}-eastus"}

Règles de remplacement multiples

Vous pouvez ajouter plusieurs overrideRules à un policy champ pour appliquer plusieurs modifications aux ressources sélectionnées. Voici un exemple pour ResourceOverride.

Cet exemple remplace l’image conteneur dans le Deployment par :

  • L'image nginx:1.20.0 pour les clusters avec l'étiquette env: prod.
  • Image nginx:latest des clusters avec l’étiquette env: test .
apiVersion: placement.kubernetes-fleet.io/v1
kind: ResourceOverride
metadata:
  name: ro-1
  namespace: test
spec:
  resourceSelectors:
    -  group: apps
       kind: Deployment
       version: v1
       name: test-nginx
  policy:
    overrideRules:
      - clusterSelector:
          clusterSelectorTerms:
            - labelSelector:
                matchLabels:
                  env: prod
        jsonPatchOverrides:
          - op: replace
            path: /spec/template/spec/containers/0/image
            value: "nginx:1.20.0"
      - clusterSelector:
          clusterSelectorTerms:
            - labelSelector:
                matchLabels:
                  env: test
        jsonPatchOverrides:
          - op: replace
            path: /spec/template/spec/containers/0/image
            value: "nginx:latest"

Utilisation avec le placement de ressources de cluster

  1. Créez une ClusterResourcePlacement afin de définir les règles de placement pour distribuer les remplacements de ressources de cluster dans l’infrastructure des clusters. Voici un exemple de code. Veillez à sélectionner la ressource appropriée.

    apiVersion: placement.kubernetes-fleet.io/v1
kind: ClusterResourcePlacement
metadata:
  name: crp
spec:
  resourceSelectors:
    - group: rbac.authorization.k8s.io
      kind: ClusterRole
      version: v1
      name: secret-reader
  policy:
    placementType: PickAll
    affinity:
      clusterAffinity:
        requiredDuringSchedulingIgnoredDuringExecution:
          clusterSelectorTerms:
            - labelSelector:
                matchLabels:
                  env: prod

    Cet exemple distribue des ressources sur tous les clusters étiquetés avec env: prod. À mesure que les modifications sont implémentées, les configurations correspondantes ClusterResourceOverride sont appliquées aux clusters désignés. La sélection d’une ressource de rôle de cluster correspondante, secret-readerdéclenche l’application des configurations aux clusters.

  2. Appliquez le ClusterResourcePlacement à l’aide de la commande kubectl apply :

    kubectl apply -f cluster-resource-placement.yaml

  3. Vérifiez que l’application ClusterResourceOverride a été appliquée aux ressources sélectionnées en vérifiant l’état de la ClusterResourcePlacement ressource via la kubectl describe commande :

    kubectl describe clusterresourceplacement crp

    Votre sortie doit ressembler à l’exemple suivant :

    Status:
  Conditions:
    ...
    Last Transition Time:   2024-04-27T04:18:00Z
    Message:                The selected resources are successfully overridden in the 10 clusters
    Observed Generation:    1
    Reason:                 OverriddenSucceeded
    Status:                 True
    Type:                   ClusterResourcePlacementOverridden
    ...
  Observed Resource Index:  0
  Placement Statuses:
    Applicable Cluster Resource Overrides:
      example-cro-0
    Cluster Name:  member-50
    Conditions:
      ...
      Message:               Successfully applied the override rules on the resources
      Observed Generation:   1
      Reason:                OverriddenSucceeded
      Status:                True
      Type:                  Overridden
     ...

    La ClusterResourcePlacementOverridden condition indique si le remplacement de ressource a été correctement appliqué aux ressources sélectionnées dans les clusters. Chaque cluster conserve sa propre Applicable Cluster Resource Overrides liste. Cette liste contient l’instantané du remplacement de ressource de cluster, le cas échéant. Les messages d’état individuels pour chaque cluster indiquent si les règles de remplacement ont été correctement appliquées.

Utiliser en conjonction avec le placement des ressources

  1. Créez une ressource ClusterResourcePlacement afin de définir les règles de placement pour distribuer les remplacements de ressources dans l’infrastructure des clusters. Voici un exemple de code. Veillez à sélectionner les espaces de noms appropriés.

    apiVersion: placement.kubernetes-fleet.io/v1
kind: ClusterResourcePlacement
metadata:
  name: crp-example
spec:
  resourceSelectors:
    - group: ""
      kind: Namespace
      name: test-namespace
      version: v1
  policy:
    placementType: PickAll
    affinity:
      clusterAffinity:
        requiredDuringSchedulingIgnoredDuringExecution:
          clusterSelectorTerms:
            - labelSelector:
                matchLabels:
                  env: prod
            - labelSelector:
                matchLabels:
                  env: test

    Cet exemple distribue les ressources au sein test-namespace de tous les clusters étiquetés avec env:prod et env:test. À mesure que les modifications sont implémentées, les configurations correspondantes ResourceOverride sont appliquées aux ressources désignées. La sélection d’une ressource de déploiement correspondante déclenche my-deploymentl’application des configurations aux ressources désignées.

  2. Appliquez la ClusterResourcePlacement ressource à l’aide de la kubectl apply commande :

    kubectl apply -f cluster-resource-placement.yaml

  3. Vérifiez que l’application ResourceOverride a été appliquée aux ressources sélectionnées en vérifiant l’état de la ClusterResourcePlacement ressource via la kubectl describe commande :

    kubectl describe clusterresourceplacement crp-example

    Votre sortie doit ressembler à l’exemple suivant :

    Status:
  Conditions:
    ...
    Message:                The selected resources are successfully overridden in the 10 clusters
    Observed Generation:    1
    Reason:                 OverriddenSucceeded
    Status:                 True
    Type:                   ClusterResourcePlacementOverridden
    ...
  Observed Resource Index:  0
  Placement Statuses:
    Applicable Resource Overrides:
      Name:        ro-1-0
      Namespace:   test-namespace
    Cluster Name:  member-50
    Conditions:
      ...
      Last Transition Time:  2024-04-26T22:57:14Z
      Message:               Successfully applied the override rules on the resources
      Observed Generation:   1
      Reason:                OverriddenSucceeded
      Status:                True
      Type:                  Overridden
     ...

    La ClusterResourcePlacementOverridden condition indique si le remplacement de ressource a été correctement appliqué aux ressources sélectionnées. Chaque cluster conserve sa propre Applicable Resource Overrides liste. Cette liste contient l’instantané du remplacement de ressource, le cas échéant. Les messages d’état individuels pour chaque cluster indiquent si les règles de remplacement ont été correctement appliquées.

Contenu connexe

  • Last updated on