Définir des stratégies de mise à jour réutilisables à l’aide d’Azure Kubernetes Fleet Manager

• Installez et configurez Terraform.

• Installez la dernière version d’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 la stratégie de mise à jour créée par Terraform.

• Vous avez également besoin de l’extension fleet Azure CLI. Pour l’installer, exécutez la commande suivante :

  az extension add --name fleet
  

  Exécutez la commande pour effectuer la 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 et un Azure Kubernetes Fleet Manager sans cluster hub. Elle ne rejoint aucun cluster AKS en tant que membres de la flotte. La stratégie de mise à jour de l’exemple fait référence aux noms des groupes de mises à jour group-1, group-2 et group-3. Pour que la stratégie s’applique aux exécutions de mises à jour réelles, affectez des clusters membres de flotte existants à ces noms de groupes de mise à jour, ou modifiez les blocs de group l’exemple pour qu’ils correspondent à vos propres noms de groupe de mise à jour.

1. Dans le portail Azure, accédez à votre ressource Azure Kubernetes Fleet Manager.

2. Dans le menu du service, sous Paramètres, sélectionnez Clusters membres>Ajouter.

   

3. Sélectionnez le cluster que vous souhaitez ajouter, puis sélectionnez Suivant : Vérifier + ajouter.

4. Entrez le nom du groupe de mises à jour auquel vous souhaitez affecter le cluster, puis sélectionnez Ajouter.

   

Affectez un cluster membre à un groupe de mises à jour lors de l’ajout du cluster membre à la flotte à l’aide de la commande az fleet member create avec le paramètre --update-group défini sur le nom du groupe de mises à jour.

az fleet member create \
    --resource-group $GROUP \
    --fleet-name $FLEET \
    --name member1 \
    --member-cluster-id $CLUSTERID \
    --update-group group-1a

1. Dans le portail Azure, accédez à votre ressource Azure Kubernetes Fleet Manager.

2. Dans le menu du service, sous Paramètres, sélectionnez Clusters membres.

3. Sélectionnez les clusters que vous souhaitez affecter à un groupe de mises à jour, puis sélectionnez Affecter un groupe de mises à jour

   

4. Entrez le nom du groupe de mises à jour auquel vous souhaitez affecter le cluster, puis sélectionnez Affecter.

   

Affectez un membre de flotte existant à un groupe de mises à jour à l’aide de la commande az fleet member update avec l’indicateur --update-group défini sur le nom du groupe de mises à jour.

az fleet member update \
 --resource-group $GROUP \
 --fleet-name $FLEET \
 --name member1 \
 --update-group group-1

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 multi-cluster>Stratégies, puis Créer.

3. Entrez un nom pour la stratégie.

4. La première fois que vous affichez la page, un diagramme d’explication de stratégie de mise à jour s’affiche pour vous aider à visualiser la façon dont les stratégies fonctionnent.

   

5. Sélectionnez Créer une étape et entrez :

   • Nom de l'étape - nommez l'étape - il doit être unique parmi tous les noms d’étape de la stratégie.
   • (Facultatif) Approbations intermédiaires : sélectionnez cette option si vous souhaitez attendre une approbation avant que cette étape commence ou une fois terminée. Pour plus d’informations, consultez Ajouter des approbations pour mettre à jour des groupes et des phases.
   • (Facultatif) Suspendre après l’étape : sélectionnez cette option si vous souhaitez définir une pause avant de passer à l’étape suivante.
   • (Facultatif) Durée de pause : sélectionnez une durée prédéfinie ou entrez une valeur personnalisée en secondes.

   

6. Affectez un ou plusieurs groupes de mises à jour à l’étape, puis sélectionnez Créer.

   Remarque

   Le nombre maximal de groupes de mises à jour dans chaque phase de mise à jour est de 50.

   

Pour ce scénario, nous créons des phases et des groupes pour qu’ils correspondent aux détails utilisés pour le processus du portail Azure.

1. Créez un fichier JSON pour définir les phases et les groupes pour l’exécution de mises à jour. Les étapes s’exécutent de manière séquentielle dans l’ordre dans lequel elles apparaissent dans le fichier JSON. Les groupes s’exécutent en parallèle à chaque étape, de sorte que l’ordre n’est pas important. Le fichier d’exemple suivant (example-stages.json) définit une stratégie avec deux étapes et inclut des paramètres maxConcurrency et maxAllowedFailures facultatifs :

   {
       "stages": [
           {
               "name": "stage-1",
               "maxConcurrency": "7",
               "maxAllowedFailures": "2",
               "groups": [
                   {
                       "name": "group-1",
                       "maxConcurrency": "3",
                       "maxAllowedFailures": "1"
                   },
                   {
                       "name": "group-2",
                       "maxConcurrency": "50%",
                       "maxAllowedFailures": "25%"
                   }
               ],
               "afterStageWaitInSeconds": 300
           },
           {
               "name": "stage-2",
               "maxConcurrency": "100%",
               "maxAllowedFailures": "0",
               "groups": [
                   {
                       "name": "group-3",
                       "maxConcurrency": "2",
                       "maxAllowedFailures": "0"
                   }
               ]
           }
       ]
   }
   

   maxConcurrency

   Le maxConcurrency champ est facultatif et contrôle le nombre de clusters pouvant être mis à niveau simultanément à l’étape ou au niveau du groupe. Utilisez une plus grande valeur pour mettre à niveau les clusters plus rapidement sur votre flotte, ou une valeur plus petite pour un déploiement plus contrôlé qui limite le rayon d’explosion si des problèmes se produisent.

   Dans cet exemple, stage-1 définit maxConcurrency à "7", ce qui permet à un maximum de "7" clusters de cette étape à être mis à niveau simultanément. Dans stage-1, group-1 limite la concurrence aux "3" clusters, ce qui signifie que jusqu'à "3" dans ce groupe peuvent être mis à niveau en même temps. group-2 autorise la mise à "50%" niveau simultanée de ses clusters (par exemple, si le groupe contient 4 clusters, jusqu’à 2 peuvent être mis à niveau en même temps).

   Les valeurs peuvent être un entier fixe (par exemple, "3") ou un pourcentage (par exemple). "100%" S’il est omis, le système applique les valeurs par défaut. Pour plus d’informations sur la façon dont ces valeurs sont résolues et leurs limites supérieures, consultez Concurrence maximale (préversion).

   maxAllowedFailures

   Le champ maxAllowedFailures est facultatif et détermine le nombre d’échecs de mise à niveau des clusters membres tolérés avant que le groupe ou l’étape ne soit marqué comme ayant échoué. Par défaut (lorsqu’il n’est pas défini ou "0"), une seule défaillance arrête l’exécution de la mise à jour entière.

   Ce paramètre évalue uniquement le nombre d’échecs. Elle n’applique pas un taux de réussite minimal. Un groupe ou une étape peut donc se terminer Completed même si certains ou tous les membres ont échoué, tant que le seuil d’échec n’a pas été dépassé lorsque la flotte a pris ses décisions de planification.

   Dans cet exemple, stage-1 définit maxAllowedFailures sur "2", en tolérant jusqu’à deux défaillances de membres sur l’ensemble de l’étape. Dans stage-1, group-1 tolère l’échec "1" et group-2 tolère l’échec "25%" de ses membres (par exemple, si le groupe contient 4 clusters, jusqu’à 1 échec est toléré). stage-2 définit maxAllowedFailures sur "0", ce qui signifie que toute défaillance arrête immédiatement l’exécution et est souvent utile pour les phases de production.

   Pour la plupart des déploiements, préférez les valeurs basées sur des pourcentages, car elles s’étendent mieux sur différentes tailles de groupe. Évitez de définir la valeur sur le nombre total de membres, sauf si vous souhaitez intentionnellement obtenir, pour ce segment, un comportement équivalant en pratique à « ne jamais échouer ».

   Les valeurs peuvent être un entier fixe (par exemple, "3") ou un pourcentage (par exemple). "25%" Pour plus d’informations sur la façon dont ces valeurs sont résolues, consultez Nombre maximal d’échecs autorisés (préversion).

2. Créez une stratégie de mise à jour à l’aide de la commande az fleet updatestrategy create avec l’indicateur --stages défini sur le nom de votre fichier JSON.

   az fleet updatestrategy create \
    --resource-group $GROUP \
    --fleet-name $FLEET \
    --name $STRATEGY \
    --stages example-stages.json
   

L’exemple Terraform de cette section crée la même forme de stratégie en deux étapes illustrée dans l’exemple Azure CLI précédent : stage-1 contient group-1 et group-2, qui se met à jour en parallèle et qui est suivie d’une attente de 300 secondes, puis stage-2 de mises à jour group-3. Contrairement à l’exemple JSON en CLI, l’exemple ne définit ni maxAllowedFailures ni maxConcurrency sur aucune étape ou aucun groupe, donc Fleet applique ses valeurs par défaut. Pour ajouter ces paramètres, étendez les blocs stage et group dans main.tf avec les arguments azurerm_kubernetes_fleet_update_strategy correspondants.

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.77"
       }
       random = {
         source  = "hashicorp/random"
         version = "~> 3.0"
       }
     }
   }
   
   provider "azurerm" {
     features {}
   }
   

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 "update_strategy_name" {
     type        = string
     description = "Name of the Fleet update strategy."
     default     = "example-update-strategy"
   }
   
   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  = 6
     lower   = true
     numeric = true
     special = false
     upper   = false
   }
   
   locals {
     resource_group_name = coalesce(var.resource_group_name, "rg-fleet-update-strategy-${random_string.suffix.result}")
     fleet_name          = coalesce(var.fleet_name, "fleet-update-strategy-${random_string.suffix.result}")
   }
   
   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
   }
   
   resource "azurerm_kubernetes_fleet_update_strategy" "example" {
     name                        = var.update_strategy_name
     kubernetes_fleet_manager_id = azurerm_kubernetes_fleet_manager.example.id
   
     stage {
       name = "stage-1"
   
       group {
         name = "group-1"
       }
   
       group {
         name = "group-2"
       }
   
       after_stage_wait_in_seconds = 300
     }
   
     stage {
       name = "stage-2"
   
       group {
         name = "group-3"
       }
     }
   }
   

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_id" {
     description = "Resource ID of the Azure Kubernetes Fleet Manager."
     value       = azurerm_kubernetes_fleet_manager.example.id
   }
   
   output "fleet_manager_name" {
     description = "Name of the Azure Kubernetes Fleet Manager."
     value       = azurerm_kubernetes_fleet_manager.example.name
   }
   
   output "update_strategy_id" {
     description = "Resource ID of the Fleet update strategy."
     value       = azurerm_kubernetes_fleet_update_strategy.example.id
   }
   

6. Copiez le fichier de l’exemple terraform.tfvars vers terraform.tfvars.example dans le même répertoire, puis modifiez les valeurs de la région Azure, du nom du groupe de ressources, du nom de la flotte, du nom de la stratégie de mise à jour et des balises que vous souhaitez utiliser.

   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

Vérifier la stratégie de mise à jour

Obtenez les noms du groupe de ressources et de Fleet Manager à partir des sorties Terraform, puis extrayez le nom de la stratégie à partir de la update_strategy_id sortie.

resource_group_name=$(terraform output -raw resource_group_name)
fleet_manager_name=$(terraform output -raw fleet_manager_name)
update_strategy_name=$(terraform output -raw update_strategy_id | awk -F'/' '{print $NF}')

Affichez les étapes et les groupes de la stratégie à l’aide de la az fleet updatestrategy show commande.

az fleet updatestrategy show \
  --resource-group $resource_group_name \
  --fleet-name $fleet_manager_name \
  --name $update_strategy_name

Le tableau stages de la sortie de la commande montre stage-1 avec group-1 et group-2 et une valeur afterStageWaitInSeconds de 300, suivi de group-3 avec stage-2, correspondant à la stratégie définie dans main.tf.

Nettoyer les ressources

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