Definiera återanvändbara uppdateringsstrategier med Azure Kubernetes Fleet Manager

• Installera och konfigurera Terraform.

• Installera den senaste versionen av Azure CLI. Information om hur du installerar eller uppgraderar finns i Installera Azure CLI. Du använder Azure CLI för att verifiera den uppdateringsstrategi som Terraform skapar.

• Du behöver fleet också tillägget Azure CLI. Installera det genom att köra följande kommando:

  az extension add --name fleet
  

  az extension update Kör kommandot för att uppdatera till den senaste versionen av tillägget.

  az extension update --name fleet
  

• Terraform-exemplet som används i den här artikeln skapar en egen resursgrupp och en Azure Kubernetes Fleet Manager utan ett hubbkluster. Den ansluter inte till några AKS-kluster som medlemmar i flottan. Exemplets uppdateringsstrategi refererar till uppdateringsgruppens namn group-1, group-2och group-3. För att strategin ska gälla för verkliga uppdateringskörningar, tilldela befintliga Fleet-medlemskluster dessa namn på uppdateringsgrupper, eller redigera exemplets group-block så att de stämmer överens med dina egna namn på uppdateringsgrupper.

1. I Azure Portal går du till din Azure Kubernetes Fleet Manager-resurs.

2. På tjänstmenyn går du till Inställningar och väljer Medlemskluster>Lägg till.

   

3. Välj det kluster som du vill lägga till och välj sedan Nästa: Granska + lägg till.

4. Ange namnet på den uppdateringsgrupp som du vill tilldela klustret till och välj sedan Lägg till.

   

Tilldela ett medlemskluster till en uppdateringsgrupp när du lägger till medlemsklustret i flottan med kommandot az fleet member create med parametern --update-group inställd på namnet på uppdateringsgruppen.

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

1. I Azure Portal går du till din Azure Kubernetes Fleet Manager-resurs.

2. På tjänstmenyn går du till Inställningar och väljer Medlemskluster.

3. Välj de kluster som du vill tilldela till en uppdateringsgrupp och välj sedan Tilldela uppdateringsgrupp

   

4. Ange namnet på den uppdateringsgrupp som du vill tilldela klustret till och välj sedan Tilldela.

   

Tilldela en befintlig medlem i flottan till en uppdateringsgrupp med kommandot az fleet member update med --update-group flaggan inställd på namnet på uppdateringsgruppen.

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

1. I Azure Portal går du till din Azure Kubernetes Fleet Manager-resurs.

2. På tjänstmenyn går du till Inställningar och väljer >av flera kluster och sedan Skapa.

3. Ange ett namn för strategin.

4. Första gången du visar sidan visas ett förklaringsdiagram för uppdateringsstrategi som kan hjälpa dig att visualisera hur strategier fungerar.

   

5. Välj Skapa fas och ange:

   • Fasnamn – namnge fasen – det måste vara unikt för alla scennamn i strategin.
   • (Valfritt) Steggodkännanden – välj det här alternativet om du vill vänta på ett godkännande innan det här steget startar eller när det har slutförts. Mer information finns i Lägga till godkännanden för att uppdatera grupper och faser.
   • (Valfritt) Pausa efter fas – välj det här alternativet om du vill definiera en paus innan du går vidare till nästa steg.
   • (Valfritt) Pausa varaktighet – välj en fördefinierad varaktighet eller ange ett anpassat värde i sekunder.

   

6. Tilldela en eller flera uppdateringsgrupper till fasen och välj sedan Skapa.

   Kommentar

   Det maximala antalet uppdateringsgrupper i varje uppdateringssteg är 50.

   

I det här scenariot skapar vi faser och grupper som matchar den information som används för Azure Portal-processen.

1. Skapa en JSON-fil för att definiera faser och grupper för uppdateringskörningen. Faserna körs sekventiellt i den ordning de visas i JSON-formatet. Grupper körs parallellt inom varje steg, så ordningen har ingen betydelse. Följande exempelfil (example-stages.json) definierar en strategi med två steg och innehåller valfria maxConcurrency och maxAllowedFailures inställningar:

   {
       "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

   Fältet maxConcurrency är valfritt och styr hur många kluster som kan uppgraderas samtidigt på fas- eller gruppnivå. Använd ett större värde för att uppgradera kluster snabbare i din flotta, eller ett mindre värde för en mer kontrollerad distribution som begränsar explosionsradien om problem uppstår.

   I det här exemplet stage-1 anger du maxConcurrency till "7", vilket gör att upp till "7" kluster i den här fasen kan uppgraderas samtidigt. Inom stage-1begränsar group-1 samtidighet till "3" kluster, vilket innebär att upp till "3" i den här gruppen kan uppgraderas samtidigt. group-2 tillåter upp till "50%" av sina kluster att uppgradera samtidigt (till exempel om gruppen innehåller 4 kluster kan upp till 2 uppgradera samtidigt).

   Värden kan vara ett fast heltal (till exempel "3") eller en procentandel (till exempel "100%"). Om det utelämnas tillämpar systemet standardvärden. Mer information om hur dessa värden matchas och deras övre gränser finns i Maximal samtidighet (förhandsversion).

   maxAllowedFailures

   Fältet maxAllowedFailures är valfritt och styr hur många uppgraderingsfel för medlemskluster som tolereras innan gruppen eller fasen markeras som misslyckad. Som standard (när det tas bort eller "0") stoppas hela uppdateringskörningen av ett enskilt fel.

   Den här inställningen utvärderar endast antalet fel. Den kräver ingen lägsta framgångsgrad. En grupp eller ett stadium kan därför sluta Completed även om vissa eller alla medlemmar misslyckades, så länge tröskelvärdet för fel inte överskreds när Fleet fattade sina schemaläggningsbeslut.

   I det här exemplet anger stage-1maxAllowedFailures till "2", vilket tolererar upp till två medlemsfel i steget. stage-1 Inom group-1tolererar "1" fel och group-2 tolererar "25%" att dess medlemmar misslyckas (till exempel om gruppen innehåller 4 kluster tolereras upp till 1 fel). stage-2 anger maxAllowedFailures till "0", vilket innebär att eventuella fel omedelbart stoppar körningen och ofta är användbart för produktionsfaser.

   För de flesta distributioner föredrar du procentbaserade värden eftersom de skalas bättre mellan olika gruppstorlekar. Undvik att ange värdet lika med det totala antalet medlemmar såvida du inte avsiktligt vill ha ett effektivt beteende för segmentet "misslyckas aldrig".

   Värden kan vara ett fast heltal (till exempel "3") eller en procentandel (till exempel "25%"). Mer information om hur dessa värden löses finns i Maximalt antal tillåtna fel (förhandsversion).

2. Skapa en ny uppdateringsstrategi med az fleet updatestrategy create kommandot med --stages flaggan inställd på namnet på din JSON-fil.

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

Terraform-exemplet i det här avsnittet skapar samma strategiform i två steg som visas i föregående Azure CLI exempel: stage-1 innehåller group-1 och group-2, som uppdateras parallellt och följs av en väntetid på 300 sekunder och uppdaterar group-3sedan stage-2 . Till skillnad från CLI JSON-exemplet anger exemplet inte maxConcurrency eller maxAllowedFailures för någon fas eller grupp, så Fleet använder sina standardvärden. Om du vill lägga till de här inställningarna utökar du blocken stage och group i main.tf med motsvarande azurerm_kubernetes_fleet_update_strategy-argument.

Granska Terraform-koden

1. Skapa en katalog för att testa Terraform-exempelkoden och gör den till den aktuella katalogen.

2. Skapa en fil med namnet providers.tfoch infoga följande kod:

   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. Skapa en fil med namnet variables.tfoch infoga följande kod:

   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. Skapa en fil med namnet main.tfoch infoga följande kod:

   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. Skapa en fil med namnet outputs.tfoch infoga följande kod:

   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. Kopiera exemplets terraform.tfvars.example fil till terraform.tfvars i samma katalog och redigera sedan värdena för den Azure regionen, resursgruppsnamnet, namnet på flottan, namnet på uppdateringsstrategin och taggarna som du vill använda.

   cp terraform.tfvars.example terraform.tfvars
   

Initiera, verifiera och tillämpa konfigurationen

Kör terraform init för att initiera Terraform-distributionen. Det här kommandot laddar ned de Azure providers som krävs för att hantera dina Azure resurser.

terraform init

Kör terraform fmt för att formatera konfigurationsfilerna konsekvent.

terraform fmt

Kör terraform-verifiering för att bekräfta att konfigurationsfilerna är syntaktiskt giltiga.

terraform validate

Kör terraform plan för att skapa en utförandeplan.

terraform plan -out main.tfplan

Kör terraform apply för att applicera genomförandeplanen på din molninfrastruktur.

terraform apply main.tfplan

Verifiera uppdateringsstrategin

Hämta resursgruppen och Fleet Manager-namnen från Terraform-utdata och extrahera strateginamnet från update_strategy_id utdata.

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}')

Visa strategins faser och grupper med hjälp az fleet updatestrategy show av kommandot .

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

Kommandoutdatans stage-1-matris visar group-1 med group-2 och afterStageWaitInSeconds samt ett 300-värde på stage-2, följt av group-3 med stages, i enlighet med den strategi som definieras i main.tf.

Rensa resurser

Kör terraform plan med flaggan -destroy för att skapa en exekveringsplan för destruktion.

terraform plan -destroy -out main.destroy.tfplan

Kör terraform apply för att verkställa destroy-planen.

terraform apply main.destroy.tfplan