Automatiser les mises à niveau des images de nœud et de Kubernetes dans plusieurs clusters en utilisant Azure Kubernetes Fleet Manager

• Définissez les variables d’environnement suivantes à utiliser dans les commandes Azure CLI :

  export GROUP=<resource-group>
  export FLEET=<fleet-name>
  export AUTOUPGRADEPROFILE=<upgrade-profile-name>
  # Optional
  export STRATEGYID=<strategy-id>
  export CLUSTER=<aks-cluster-name>
  

• Installez la dernière version Azure CLI. Pour installer ou mettre à niveau Azure CLI, consultez Installer l’interface de ligne de commande Microsoft Azure.

• Installez la dernière fleet extension Azure CLI. Utilisez la az extension add commande pour installer l’extension.

  az extension add --name fleet
  

  Utilisez la commande pour effectuer une az extension update mise à jour vers la dernière version de l’extension.

  az extension update --name fleet
  

• Installez et configurez Terraform.

• Installez la dernière version Azure CLI. Pour installer ou mettre à niveau Azure CLI, consultez Installer l’interface de ligne de commande Microsoft Azure. Vous utilisez le Azure CLI pour vérifier le profil de mise à niveau automatique créé par Terraform.

• Installez la dernière fleet extension Azure CLI. Utilisez la az extension add commande pour installer l’extension.

  az extension add --name fleet
  

  Utilisez la commande pour effectuer une az extension update mise à jour vers la dernière version de l’extension.

  az extension update --name fleet
  

• L’exemple Terraform utilisé dans cet article crée son propre groupe de ressources ainsi qu’un gestionnaire Azure Kubernetes Fleet Manager, et n’ajoute aucun cluster AKS comme membre de flotte. Pour exercer le profil de mise à niveau automatique résultant par rapport aux exécutions de mises à jour réelles, joignez des clusters AKS existants en tant que membres de la flotte après avoir appliqué l’exemple. Pour plus d’informations, consultez le guide de démarrage rapide.

Créer des profils de mise à niveau automatique

Créez des profils de mise à niveau automatique à l’aide de la az fleet autoupgradeprofile create commande.

Vous pouvez désactiver un profil de mise à niveau automatique en incluant l’indicateur --disabled avec la az fleet autoupgradeprofile create commande. Pour réactiver un profil de mise à niveau automatique désactivé, réexécutez la az fleet autoupgradeprofile create commande sans l’indicateur --disabled .

Mises à jour Kubernetes du canal stable

Effectuez une mise à jour vers la dernière version de correctif Kubernetes prise en charge sur la version mineure N-1, où N est la dernière version mineure prise en charge.

Mettre à jour les clusters membres un par un

Mettez à jour les clusters membres de manière séquentielle à l’aide de la az fleet autoupgradeprofile create commande.

az fleet autoupgradeprofile create \
  --resource-group $GROUP \
  --fleet-name $FLEET \
  --name $AUTOUPGRADEPROFILE \
  --channel Stable

Mettre à jour des clusters membres à l’aide d’une stratégie de mise à jour existante

Mettez à jour les clusters membres à l’aide d’une stratégie de mise à jour existante. Utilisez la commande az fleet autoupgradeprofile create avec le paramètre --update-strategy-id défini sur l’ID de la stratégie de mise à jour existante.

az fleet autoupgradeprofile create \
  --resource-group $GROUP \
  --fleet-name $FLEET \
  --name $AUTOUPGRADEPROFILE \
  --update-strategy-id $STRATEGYID \
  --channel Stable

Mettre à jour des clusters membres à l’aide d’une stratégie de mise à jour existante avec une image de nœud cohérente

Mettez à jour les clusters membres à l’aide d’une stratégie de mise à jour existante et assurez-vous que la même version d’image de nœud est utilisée dans chaque région Azure. Utilisez la az fleet autoupgradeprofile create commande avec le --node-image-selection paramètre défini sur Consistent. Tous les clusters membres exécutent la même version d’image de nœud.

az fleet autoupgradeprofile create \
  --resource-group $GROUP \
  --fleet-name $FLEET \
  --name $AUTOUPGRADEPROFILE \
  --update-strategy-id $STRATEGYID \
  --channel Stable \
  --node-image-selection Consistent

Mettre à jour des clusters membres à l’aide d’une stratégie de mise à jour existante avec la dernière image de nœud

Mettez à jour les clusters membres à l’aide d’une stratégie de mise à jour existante et assurez-vous que la dernière version d’image de nœud disponible est utilisée pour chaque région Azure. Utilisez la az fleet autoupgradeprofile create commande avec le --node-image-selection paramètre défini sur Latest. Les clusters membres peuvent exécuter plusieurs versions d’image de nœud.

az fleet autoupgradeprofile create \
  --resource-group $GROUP \
  --fleet-name $FLEET \
  --name $AUTOUPGRADEPROFILE \
  --update-strategy-id $STRATEGYID \
  --channel Stable \
  --node-image-selection Latest

Mises à jour du canal d'image du nœud

Mettez à jour les nœuds avec une image de machine nouvellement corrigée qui inclut des correctifs de sécurité et des correctifs de bogues.

Mettre à jour les images de nœud un par un

Mettez à jour les images de nœud pour les clusters membres de manière séquentielle à l’aide de la az fleet autoupgradeprofile create commande.

az fleet autoupgradeprofile create \
  --resource-group $GROUP \
  --fleet-name $FLEET \
  --name $AUTOUPGRADEPROFILE \
  --channel NodeImage

Mettre à jour des images de nœud à l’aide d’une stratégie de mise à jour existante

Mettez à jour les images de nœud pour les clusters membres à l’aide d’une stratégie de mise à jour existante. Utilisez la az fleet autoupgradeprofile create commande et définissez le --update-strategy-id paramètre sur l’ID de la stratégie de mise à jour existante.

az fleet autoupgradeprofile create \
  --resource-group $GROUP \
  --fleet-name $FLEET \
  --name $AUTOUPGRADEPROFILE \
  --update-strategy-id $STRATEGYID \
  --channel NodeImage 

Mises à jour des versions mineures cibles de Kubernetes

Mettez à jour vers une version mineure Kubernetes cible définie à l’aide du --target-kubernetes-version paramètre. Fournissez la version au format {version majeure}.{version mineure} (par exemple, 1.33). La mise à niveau automatique de Fleet Manager met automatiquement à niveau les clusters membres vers la dernière version corrective de la version cible spécifiée lorsque le correctif est disponible.

Mettre à jour des clusters membres vers une version mineure Kubernetes spécifique

Mettez à jour les clusters membres vers une version mineure spécifique de Kubernetes à l’aide de la commande az fleet autoupgradeprofile create avec le paramètre --target-kubernetes-version défini sur la version cible. L’exemple suivant met à jour les clusters membres vers Kubernetes version 1.33.

az fleet autoupgradeprofile create \
  --resource-group $GROUP \
  --fleet-name $FLEET \
  --name $AUTOUPGRADEPROFILE \
  --channel TargetKubernetesVersion \
  --target-kubernetes-version "1.33"

Mettre à jour des clusters membres avec LTS activé pour une version mineure Kubernetes spécifique

Mettez à jour les clusters membres pour lesquels LTS est activé vers une version mineure spécifique de Kubernetes à l’aide de la commande az fleet autoupgradeprofile create, avec le paramètre --target-kubernetes-version défini sur la version souhaitée et l’indicateur --long-term-support activé. L’exemple suivant met à jour les clusters membres vers Kubernetes version 1.29 avec LTS activé.

az fleet autoupgradeprofile create \
  --resource-group $GROUP \
  --fleet-name $FLEET \
  --name $AUTOUPGRADEPROFILE \
  --channel TargetKubernetesVersion \
  --target-kubernetes-version "1.29" \
  --long-term-support

Mises à jour du canal de correctif de sécurité

Mettez à jour les nœuds Linux avec des correctifs de sécurité. Appliquez des mises à jour à l’aide de la mise à jour corrective dynamique si possible. Sinon, déployez une image de machine nouvellement corrigée qui contient des correctifs de sécurité.

Mettre à jour les nœuds avec des correctifs de sécurité un par un

Mettez à jour les images de nœud pour les clusters membres de manière séquentielle à l’aide de la az fleet autoupgradeprofile create commande.

az fleet autoupgradeprofile create \
  --resource-group $GROUP \
  --fleet-name $FLEET \
  --name $AUTOUPGRADEPROFILE \
  --channel SecurityPatch

Mettre à jour des nœuds avec des correctifs de sécurité à l’aide d’une stratégie de mise à jour existante

Mettez à jour les images de nœud pour les clusters membres à l’aide d’une stratégie de mise à jour existante. Utilisez la az fleet autoupgradeprofile create commande et définissez le --update-strategy-id paramètre sur l’ID de la stratégie de mise à jour existante.

az fleet autoupgradeprofile create \
  --resource-group $GROUP \
  --fleet-name $FLEET \
  --name $AUTOUPGRADEPROFILE \
  --update-strategy-id $STRATEGYID \
  --channel SecurityPatch 

Afficher les profils de mise à niveau automatique

Les profils de mise à niveau automatique sont des ressources de niveau flotte. Ils ne sont pas attachés directement à des clusters AKS individuels. Pour déterminer quels profils peuvent mettre à jour vos clusters AKS, commencez par répertorier les membres de la flotte et vérifiez que les clusters sont membres de la flotte.

az fleet member list \
  --resource-group $GROUP \
  --fleet-name $FLEET \
  --query "[].{memberName:name,clusterResourceId:clusterResourceId}" \
  --output table

Répertoriez tous les profils de mise à niveau automatique de la flotte à l’aide de la az fleet autoupgradeprofile list commande.

az fleet autoupgradeprofile list \
  --resource-group $GROUP \
  --fleet-name $FLEET \
  --output table

Affichez un profil de mise à niveau automatique spécifique pour la flotte à l’aide de la az fleet autoupgradeprofile show commande. Passez en revue le canal, l’état et updateStrategyId dans la sortie.

az fleet autoupgradeprofile show \
  --resource-group $GROUP \
  --fleet-name $FLEET \
  --name $AUTOUPGRADEPROFILE

Si updateStrategyId est vide, le profil utilise la séquence de mise à jour Une par une et inclut les clusters membres du parc de façon séquentielle. Si updateStrategyId contient un ID de ressource, affichez la stratégie référencée pour examiner les étapes, les groupes ou les sélecteurs de membres qui déterminent quels membres de la flotte sont inclus dans les exécutions de mise à jour générées.

PROFILE_STRATEGY_ID=$(az fleet autoupgradeprofile show \
  --resource-group $GROUP \
  --fleet-name $FLEET \
  --name $AUTOUPGRADEPROFILE \
  --query updateStrategyId \
  --output tsv)

if [[ -n "$PROFILE_STRATEGY_ID" ]]; then
  az fleet updatestrategy show \
    --resource-group $GROUP \
    --fleet-name $FLEET \
    --name "${PROFILE_STRATEGY_ID##*/}"
fi

Supprimer un profil de mise à niveau automatique

Utilisez la commande az fleet autoupgradeprofile delete pour supprimer un profil de mise à niveau automatique existant. Après avoir exécuté cette commande, vous êtes invité à confirmer la suppression. Pour contourner la confirmation et supprimer immédiatement le profil, incluez-le --yes dans la commande.

az fleet autoupgradeprofile delete \
  --resource-group $GROUP \
  --fleet-name $FLEET \
  --name $AUTOUPGRADEPROFILE

Créer des profils de mise à niveau automatique

L’exemple Terraform de cette section crée un groupe de ressources, un Azure Kubernetes Fleet Manager (sans cluster hub) et un profil de mise à niveau automatique de flotte. Par défaut, le profil utilise le canal Stable avec la sélection de l’image du nœud Latest et est activé. Définissez les variables target_kubernetes_version, node_image_selection, auto_upgrade_disabled, long_term_support et auto_upgrade_channel pour qu’elles correspondent au canal et aux options décrits dans les sections précédentes. L’exemple ne définit pas de stratégie de mise à jour, de sorte que le profil résultant utilise toujours la séquence de mise à jour Une par une.

Passer en revue le code Terraform

1. Créez un répertoire pour tester l’exemple de code Terraform et le rendre le répertoire actif.

2. Créez un fichier nommé providers.tf et insérez le code suivant :

   terraform {
     required_version = ">= 1.9.0"
   
     required_providers {
       azurerm = {
         source  = "hashicorp/azurerm"
         version = "~> 4.0"
       }
       azapi = {
         source  = "Azure/azapi"
         version = "~> 2.0"
       }
       random = {
         source  = "hashicorp/random"
         version = "~> 3.0"
       }
     }
   }
   
   provider "azurerm" {
     features {}
   }
   
   provider "azapi" {
   }
   

3. Créez un fichier nommé variables.tf et insérez le code suivant :

   variable "location" {
     type        = string
     description = "Azure region where the resource group and Fleet Manager are created."
     default     = "eastus"
   }
   
   variable "resource_group_name" {
     type        = string
     description = "Name of the resource group. If null, a unique name is generated."
     default     = null
   }
   
   variable "fleet_name" {
     type        = string
     description = "Name of the Azure Kubernetes Fleet Manager. If null, a unique name is generated."
     default     = null
   }
   
   variable "auto_upgrade_profile_name" {
     type        = string
     description = "Name of the Fleet auto-upgrade profile. If null, a unique name is generated."
     default     = null
   }
   
   variable "auto_upgrade_channel" {
     type        = string
     description = "Auto-upgrade channel used by the profile."
     default     = "Stable"
   
     validation {
       condition     = contains(["Rapid", "Stable", "NodeImage", "TargetKubernetesVersion"], var.auto_upgrade_channel)
       error_message = "Auto-upgrade channel must be one of: Rapid, Stable, NodeImage, TargetKubernetesVersion."
     }
   }
   
   variable "target_kubernetes_version" {
     type        = string
     description = "Target Kubernetes version in major.minor format, for example 1.31. Required when auto_upgrade_channel is TargetKubernetesVersion; otherwise leave null."
     default     = null
   
     validation {
       condition     = var.target_kubernetes_version == null || can(regex("^[0-9]+\\.[0-9]+$", var.target_kubernetes_version))
       error_message = "Target Kubernetes version must be in major.minor format, for example 1.31."
     }
   
     validation {
       condition     = var.auto_upgrade_channel != "TargetKubernetesVersion" || var.target_kubernetes_version != null
       error_message = "Target Kubernetes version is required when auto_upgrade_channel is TargetKubernetesVersion."
     }
   }
   
   variable "node_image_selection" {
     type        = string
     description = "Node image selection type. Latest uses the newest image per region; Consistent waits for the same image version across all member regions."
     default     = "Latest"
   
     validation {
       condition     = contains(["Latest", "Consistent"], var.node_image_selection)
       error_message = "Node image selection must be either Latest or Consistent."
     }
   }
   
   variable "auto_upgrade_disabled" {
     type        = bool
     description = "Set to true to stop the profile from creating new automatic update runs. In-progress update runs aren't cancelled."
     default     = false
   }
   
   variable "long_term_support" {
     type        = bool
     description = "Whether the profile targets long-term support Kubernetes versions. Only supported on the TargetKubernetesVersion channel."
     default     = false
   
     validation {
       condition     = !var.long_term_support || var.auto_upgrade_channel == "TargetKubernetesVersion"
       error_message = "Long-term support can only be enabled when auto_upgrade_channel is TargetKubernetesVersion."
     }
   }
   
   variable "tags" {
     type        = map(string)
     description = "Tags to apply to created resources."
     default = {
       environment = "demo"
       managed_by  = "terraform"
     }
   }
   

4. Créez un fichier nommé main.tf et insérez le code suivant :

   resource "random_string" "suffix" {
     length  = 5
     lower   = true
     numeric = true
     special = false
     upper   = false
   }
   
   locals {
     resource_group_name       = coalesce(var.resource_group_name, "rg-fleet-update-${random_string.suffix.result}")
     fleet_name                = coalesce(var.fleet_name, "fleet-update-${random_string.suffix.result}")
     auto_upgrade_profile_name = coalesce(var.auto_upgrade_profile_name, "stable-profile-${random_string.suffix.result}")
   
     # targetKubernetesVersion is only valid on the TargetKubernetesVersion channel.
     auto_upgrade_properties = merge(
       {
         channel         = var.auto_upgrade_channel
         disabled        = var.auto_upgrade_disabled
         longTermSupport = var.long_term_support
         nodeImageSelection = {
           type = var.node_image_selection
         }
       },
       var.auto_upgrade_channel == "TargetKubernetesVersion" ? {
         targetKubernetesVersion = var.target_kubernetes_version
       } : {}
     )
   }
   
   resource "azurerm_resource_group" "example" {
     name     = local.resource_group_name
     location = var.location
     tags     = var.tags
   }
   
   resource "azurerm_kubernetes_fleet_manager" "example" {
     name                = local.fleet_name
     location            = azurerm_resource_group.example.location
     resource_group_name = azurerm_resource_group.example.name
     tags                = var.tags
   }
   
   # autoUpgradeProfiles is only available on the preview API version, which requires schema validation to be disabled.
   resource "azapi_resource" "auto_upgrade_profile" {
     type                      = "Microsoft.ContainerService/fleets/autoUpgradeProfiles@2025-04-01-preview"
     name                      = local.auto_upgrade_profile_name
     parent_id                 = azurerm_kubernetes_fleet_manager.example.id
     schema_validation_enabled = false
   
     body = {
       properties = local.auto_upgrade_properties
     }
   }
   

5. Créez un fichier nommé outputs.tf et insérez le code suivant :

   output "resource_group_name" {
     description = "Name of the created resource group."
     value       = azurerm_resource_group.example.name
   }
   
   output "fleet_manager_name" {
     description = "Name of the Azure Kubernetes Fleet Manager."
     value       = azurerm_kubernetes_fleet_manager.example.name
   }
   
   output "fleet_manager_id" {
     description = "Resource ID of the Azure Kubernetes Fleet Manager."
     value       = azurerm_kubernetes_fleet_manager.example.id
   }
   
   output "auto_upgrade_profile_name" {
     description = "Name of the Fleet auto-upgrade profile."
     value       = azapi_resource.auto_upgrade_profile.name
   }
   
   output "auto_upgrade_profile_id" {
     description = "Resource ID of the Fleet auto-upgrade profile."
     value       = azapi_resource.auto_upgrade_profile.id
   }
   

6. Copiez le fichier d’exemple terraform.tfvars vers terraform.tfvars.example dans le même répertoire, puis modifiez les valeurs afin qu’elles correspondent au canal de mise à niveau automatique, à la sélection de l’image de nœud et aux autres options souhaitées.

   cp terraform.tfvars.example terraform.tfvars
   

Initialiser, valider et appliquer la configuration

Exécutez terraform init pour initialiser le déploiement Terraform. Cette commande télécharge les fournisseurs Azure requis pour gérer vos ressources Azure.

terraform init

Exécutez terraform fmt pour mettre en forme les fichiers de configuration de manière cohérente.

terraform fmt

Exécutez terraform validate pour vérifier que les fichiers de configuration sont valides de manière syntactique.

terraform validate

Exécutez terraform plan pour créer un plan d’exécution.

terraform plan -out main.tfplan

Exécutez terraform apply pour appliquer le plan d’exécution à votre infrastructure cloud.

terraform apply main.tfplan

Afficher les profils de mise à niveau automatique

Obtenez le nom du groupe de ressources, celui de Fleet Manager et celui du profil de mise à niveau automatique à partir des sorties Terraform.

resource_group_name=$(terraform output -raw resource_group_name)
fleet_manager_name=$(terraform output -raw fleet_manager_name)
auto_upgrade_profile_name=$(terraform output -raw auto_upgrade_profile_name)

Affichez le canal, l’état et la séquence de mise à jour du profil de mise à niveau automatique à l’aide de la az fleet autoupgradeprofile show commande.

az fleet autoupgradeprofile show \
  --resource-group $resource_group_name \
  --fleet-name $fleet_manager_name \
  --name $auto_upgrade_profile_name

L’exemple ne définit pas de stratégie de mise à jour, donc updateStrategyId dans la sortie est vide et le profil met à jour séquentiellement les clusters membres de Fleet à l’aide de la séquence de mise à jour Un par un. Répertoriez les membres de la flotte actuels avec la commande suivante.

az fleet member list \
  --resource-group $resource_group_name \
  --fleet-name $fleet_manager_name \
  --output table

Supprimer un profil de mise à niveau automatique

Exécutez terraform plan avec l’option -destroy pour créer un plan d’exécution de destruction.

terraform plan -destroy -out main.destroy.tfplan

Exécutez terraform apply pour appliquer le plan de destruction.

terraform apply main.destroy.tfplan

Créer des profils de mise à niveau automatique

Afficher les profils de mise à niveau automatique

Les profils de mise à niveau automatique sont des ressources de niveau flotte. Ils ne sont pas attachés directement à des clusters AKS individuels. Pour déterminer quels profils peuvent mettre à jour vos clusters AKS, vérifiez que les clusters sont membres de la flotte, puis passez en revue les profils de la flotte et leurs séquences de mise à jour.

1. Dans le portail Azure, accédez à votre ressource Azure Kubernetes Fleet Manager.
2. Dans le menu du service, sélectionnez Membres de la flotte et vérifiez que vos clusters AKS apparaissent dans la liste des membres.
3. Sous Paramètres, sélectionnez Mise à jour multicluster>Profils de mise à niveau automatique.
4. Sélectionnez un profil de mise à niveau automatique pour afficher son canal, son état et sa séquence de mise à jour.
5. Si la séquence de mise à jour est Un par un, le profil inclut les clusters membres de la flotte l’un après l’autre. Si la séquence de mise à jour utilise Stages, examinez les stages, les groupes et les sélecteurs de membres de la stratégie associée afin de déterminer quels membres de la flotte sont inclus dans les exécutions de mise à jour générées.

Supprimer un profil de mise à niveau automatique

1. Dans le portail Azure, accédez à votre ressource Azure Kubernetes Fleet Manager.
2. Dans le menu du service, sous Paramètres, sélectionnez Mise à jour multicluster>Profils de mise à niveau automatique.
3. Sélectionnez le profil que vous souhaitez supprimer, puis sélectionnez Supprimer>oui pour confirmer.