Automatizzare gli aggiornamenti di Kubernetes e immagini dei nodi in più cluster usando Azure Kubernetes Fleet Manager

• Impostare le variabili di ambiente seguenti da usare nei comandi dell'interfaccia della riga di comando di Azure:

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

• Installare la versione interfaccia della riga di comando di Azure più recente. Per eseguire l'installazione o l'aggiornamento, vedere Installare l'interfaccia della riga di comando di Azure.

• Installare l'estensione interfaccia della riga di comando di Azure più recente fleet . Usare il az extension add comando per installare l'estensione.

  az extension add --name fleet
  

  Usare il comando per eseguire l'aggiornamento az extension update alla versione più recente dell'estensione.

  az extension update --name fleet
  

• Installare e configurare Terraform.

• Installare la versione interfaccia della riga di comando di Azure più recente. Per eseguire l'installazione o l'aggiornamento, vedere Installare l'interfaccia della riga di comando di Azure. Usare il interfaccia della riga di comando di Azure per verificare il profilo di aggiornamento automatico creato da Terraform.

• Installare l'estensione interfaccia della riga di comando di Azure più recente fleet . Usare il az extension add comando per installare l'estensione.

  az extension add --name fleet
  

  Usare il comando per eseguire l'aggiornamento az extension update alla versione più recente dell'estensione.

  az extension update --name fleet
  

• L'esempio di Terraform usato in questo articolo crea il proprio gruppo di risorse e Gestione flotta Kubernetes di Azure e non aggiunge alcun cluster AKS come membro della flotta. Per testare il profilo di aggiornamento automatico risultante con esecuzioni di aggiornamento reali, aggiungere i cluster AKS esistenti alla Fleet come membri dopo aver applicato l'esempio. Per altre informazioni, vedere la guida introduttiva.

Creare profili di aggiornamento automatico

Creare profili di aggiornamento automatico usando il az fleet autoupgradeprofile create comando .

È possibile disabilitare un profilo di aggiornamento automatico includendo il --disabled flag con il az fleet autoupgradeprofile create comando . Per riabilitare un profilo di aggiornamento automatico disabilitato, eseguire di nuovo il az fleet autoupgradeprofile create comando senza il --disabled flag .

Aggiornamenti del canale stabile di Kubernetes

Eseguire l'aggiornamento alla versione più recente della patch di Kubernetes supportata nella versione secondaria N-1, dove N è la versione secondaria supportata più recente.

Aggiornare i cluster membri uno per uno

Aggiorna i cluster membri in sequenza utilizzando il comando az fleet autoupgradeprofile create.

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

Aggiornare i cluster membri usando una strategia di aggiornamento esistente

Aggiornare i cluster membri usando una strategia di aggiornamento esistente. Usare il az fleet autoupgradeprofile create comando con il --update-strategy-id parametro impostato sull'ID della strategia di aggiornamento esistente.

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

Aggiornare i cluster membri usando una strategia di aggiornamento esistente con un'immagine del nodo coerente

Aggiornare i cluster membri usando una strategia di aggiornamento esistente e assicurarsi che la stessa versione dell'immagine del nodo venga usata in ogni area Azure. Usare il az fleet autoupgradeprofile create comando con il --node-image-selection parametro impostato su Consistent. Tutti i cluster membri eseguono la stessa versione dell'immagine del nodo.

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

Aggiornare i cluster membri usando una strategia di aggiornamento esistente con l'immagine del nodo più recente

Aggiornare i cluster membri usando una strategia di aggiornamento esistente e assicurarsi che venga usata la versione più recente dell'immagine del nodo disponibile per ogni area Azure. Usare il az fleet autoupgradeprofile create comando con il --node-image-selection parametro impostato su Latest. I cluster membri possono eseguire più versioni dell'immagine del nodo.

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

Aggiornamenti del canale d'immagine del nodo

Aggiornare i nodi con una nuova immagine del computer con patch che include correzioni di sicurezza e correzioni di bug.

Aggiornare le immagini dei nodi una alla volta

Aggiorna in sequenza le immagini dei nodi dei cluster membri utilizzando il comando az fleet autoupgradeprofile create.

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

Aggiornare le immagini dei nodi usando una strategia di aggiornamento esistente

Aggiornare le immagini dei nodi per i cluster membri usando una strategia di aggiornamento esistente. Usare il az fleet autoupgradeprofile create comando e impostare il --update-strategy-id parametro sull'ID della strategia di aggiornamento esistente.

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

Aggiornamenti della versione secondaria di Kubernetes Target

Aggiornare a una versione secondaria di Kubernetes di destinazione definita usando il parametro --target-kubernetes-version. Specificare la versione nel formato {major version}.{minor version} (ad esempio, 1.33). L'aggiornamento automatico di Fleet Manager aggiorna automaticamente i cluster membri alla versione patch più recente della versione di destinazione specificata quando la patch è disponibile.

Aggiornare i cluster membri a una versione secondaria di Kubernetes specifica

Aggiornare i cluster membri a una versione minor specifica di Kubernetes usando il comando az fleet autoupgradeprofile create con il parametro --target-kubernetes-version impostato sul valore della versione desiderata. L'esempio seguente aggiorna i cluster membri a Kubernetes versione 1.33.

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

Aggiornare i cluster membri con LTS abilitato a una versione secondaria di Kubernetes specifica

Aggiornare i cluster dei membri con LTS abilitato a una versione secondaria di Kubernetes specifica usando il comando az fleet autoupgradeprofile create con il parametro --target-kubernetes-version impostato sulla versione desiderata e abilitando il flag --long-term-support. L'esempio seguente aggiorna i cluster membri a Kubernetes versione 1.29 con LTS abilitato.

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

Aggiornamenti del canale delle patch di sicurezza

Aggiornare i nodi Linux con correzioni di sicurezza. Applica gli aggiornamenti tramite patching live quando possibile. In caso contrario, distribuisci una nuova immagine macchina aggiornata con patch che contiene correzioni di sicurezza.

Aggiornare i nodi con patch di sicurezza uno alla volta

Aggiorna in sequenza le immagini dei nodi dei cluster membri utilizzando il comando az fleet autoupgradeprofile create.

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

Aggiornare i nodi con patch di sicurezza usando una strategia di aggiornamento esistente

Aggiornare le immagini dei nodi per i cluster membri usando una strategia di aggiornamento esistente. Usare il az fleet autoupgradeprofile create comando e impostare il --update-strategy-id parametro sull'ID della strategia di aggiornamento esistente.

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

Visualizzare i profili di aggiornamento automatico

I profili di aggiornamento automatico sono risorse a livello di flotta. Non sono collegati direttamente a singoli cluster del servizio Azure Kubernetes. Per determinare quali profili possono aggiornare i cluster AKS, elencare prima i membri della Fleet e verificare che i cluster siano membri della Fleet.

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

Elencare tutti i profili di aggiornamento automatico per la flotta usando il az fleet autoupgradeprofile list comando .

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

Visualizzare un profilo di aggiornamento automatico specifico per la Flotta usando il az fleet autoupgradeprofile show comando . Esaminare il canale, lo stato e updateStrategyId nell'output.

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

Se updateStrategyId è vuoto, il profilo utilizza la sequenza di aggiornamento Uno per uno e include i cluster membri della Fleet in modo sequenziale. Se updateStrategyId contiene un ID della risorsa, mostra la strategia di riferimento per esaminare le fasi, i gruppi o i selettori dei membri che determinano quali membri della flotta sono inclusi nelle esecuzioni di aggiornamento generate.

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

Eliminare un profilo di aggiornamento automatico

Usare il az fleet autoupgradeprofile delete comando per eliminare un profilo di aggiornamento automatico esistente. Dopo aver eseguito questo comando, viene richiesto di confermare l'eliminazione. Per ignorare la conferma ed eliminare immediatamente il profilo, includere --yes nel comando .

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

Creare profili di aggiornamento automatico

L'esempio Terraform in questa sezione crea un gruppo di risorse, un Azure Kubernetes Fleet Manager (senza un cluster hub) e un profilo di aggiornamento automatico fleet. Per impostazione predefinita, il profilo usa il canale Stable con la selezione dell'immagine del nodo Latest ed è abilitato. Impostare le auto_upgrade_channelvariabili , auto_upgrade_disablednode_image_selection, target_kubernetes_version, e long_term_support in modo che corrispondano al canale e alle opzioni descritte nelle sezioni precedenti. L'esempio non imposta una strategia di aggiornamento, quindi il profilo risultante usa sempre la sequenza di aggiornamento One by one.

Esaminare il codice Terraform

1. Creare una directory per testare il codice Terraform di esempio e impostarla come directory corrente.

2. Creare un file denominato providers.tfe inserire il codice seguente:

   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. Creare un file denominato variables.tfe inserire il codice seguente:

   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. Creare un file denominato main.tfe inserire il codice seguente:

   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. Creare un file denominato outputs.tfe inserire il codice seguente:

   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. Copiare il file di esempio terraform.tfvars in terraform.tfvars.example nella stessa directory, quindi modificare i valori in modo che corrispondano al canale di aggiornamento automatico, alla selezione dell'immagine del nodo e alle altre opzioni desiderate.

   cp terraform.tfvars.example terraform.tfvars
   

Inizializzare, convalidare e applicare la configurazione

Per inizializzare la distribuzione di Terraform, eseguire terraform init. Questo comando scarica i provider di Azure necessari per gestire le risorse Azure.

terraform init

Eseguire terraform fmt per formattare i file di configurazione in modo coerente.

terraform fmt

Eseguire terraform validate per verificare che i file di configurazione siano sintatticamente validi.

terraform validate

Eseguire terraform plan per creare un piano di esecuzione.

terraform plan -out main.tfplan

Esegui terraform apply per applicare il piano di esecuzione all'infrastruttura cloud.

terraform apply main.tfplan

Visualizzare i profili di aggiornamento automatico

Recupera il gruppo di risorse, Fleet Manager e i nomi dei profili di aggiornamento automatico dagli output di 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)

Visualizzare il canale, lo stato e la sequenza di aggiornamento del profilo di aggiornamento automatico usando il az fleet autoupgradeprofile show comando .

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

L'esempio non imposta una strategia di aggiornamento, quindi updateStrategyId nell'output è vuoto e il profilo aggiorna i cluster membri della Fleet in sequenza, utilizzando la sequenza di aggiornamento Uno per uno. Elenca gli attuali membri di Fleet con il comando seguente.

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

Eliminare un profilo di aggiornamento automatico

Esegui terraform plan con il flag -destroy per creare un piano di esecuzione per la distruzione.

terraform plan -destroy -out main.destroy.tfplan

Esegui terraform apply per applicare il piano di distruzione.

terraform apply main.destroy.tfplan

Creare profili di aggiornamento automatico

Visualizzare i profili di aggiornamento automatico

I profili di aggiornamento automatico sono risorse a livello di flotta. Non sono collegati direttamente a singoli cluster del servizio Azure Kubernetes. Per determinare quali profili possono aggiornare i cluster AKS, verificare che i cluster siano membri della Fleet, quindi esaminarne i profili e le relative sequenze di aggiornamento.

1. Nel portale di Azure, naviga alla risorsa Azure Kubernetes Fleet Manager.
2. Nel menu del servizio, seleziona Fleet members e verifica che i cluster AKS siano presenti nell'elenco dei membri.
3. In Impostazioni, seleziona Aggiornamento multicluster>Profili di aggiornamento automatico.
4. Selezionare un profilo di aggiornamento automatico per visualizzare il canale, lo stato e la sequenza di aggiornamento.
5. Se la sequenza di aggiornamento è one-by-one, il profilo include i cluster membri della Flotta in sequenza. Se la sequenza di aggiornamento usa Fasi, rivedi le fasi, i gruppi e i selettori dei membri della strategia associata per determinare quali membri della fleet sono inclusi nelle esecuzioni di aggiornamento generate.

Eliminare un profilo di aggiornamento automatico

1. Nel portale di Azure, naviga alla risorsa Azure Kubernetes Fleet Manager.
2. Dal menu del servizio, in Impostazioni, selezionare Aggiornamento multicluster>Profili di aggiornamento automatico.
3. Selezionare il profilo da eliminare e quindi selezionare Elimina>sì per confermare.