Definir estratégias de atualização reutilizáveis usando o Azure Kubernetes Fleet Manager

• Instale e configure o Terraform.

• Instale a versão mais recente da CLI do Azure. Para instalar ou atualizar, confira Instalar a CLI do Azure. Use o CLI do Azure para verificar a estratégia de atualização criada pelo Terraform.

• Você também precisa da fleet extensão CLI do Azure. Para instalá-lo, execute o seguinte comando:

  az extension add --name fleet
  

  Execute o az extension update comando para atualizar para a versão mais recente da extensão.

  az extension update --name fleet
  

• O exemplo do Terraform usado neste artigo cria o próprio grupo de recursos e um Azure Kubernetes Fleet Manager sem um cluster de hub. Não se junta a nenhum cluster AKS como membro da Frota. A estratégia de atualização da amostra faz referência aos nomes dos grupos de atualização group-1, group-2 e group-3. Para que a estratégia se aplique a execuções reais de atualização, atribua clusters de membros da Frota existentes a esses nomes de grupo de atualização ou edite os blocos do group exemplo para corresponder aos seus próprios nomes de grupo de atualização.

1. No portal do Azure, navegue até o recurso do Gerenciador de Frota de Kubernetes do Azure.

2. No menu de serviço, em Configurações, selecione Cluster membros>Adicionar.

   

3. Selecione o cluster que você deseja adicionar e selecione Avançar: Examinar + adicionar.

4. Insira o nome do grupo de atualização ao qual deseja atribuir o cluster e selecione Adicionar.

   

Atribua um cluster membro a um grupo de atualização ao adicionar o cluster membro à frota usando o comando az fleet member create com o parâmetro --update-group definido como o nome do grupo de atualização.

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

1. No portal do Azure, navegue até o recurso do Gerenciador de Frota de Kubernetes do Azure.

2. No menu de serviço, em Configurações, selecione Cluster membros.

3. Selecione os clusters que você deseja atribuir a um grupo de atualização e selecione Atribuir grupo de atualização

   

4. Insira o nome do grupo de atualização ao qual deseja atribuir o cluster e selecione Atribuir.

   

Atribua um membro de frota existente a um grupo de atualização usando o comando az fleet member update com o sinalizador --update-group definido com o nome do grupo de atualização.

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

1. No portal do Azure, navegue até o recurso do Gerenciador de Frota de Kubernetes do Azure.

2. No menu de serviço, em Configurações, selecione Atualização de múltiplos clusters>Estratégias e, em seguida, Criar.

3. Insira um nome para a estratégia.

4. Na primeira vez que você exibir a página, um diagrama de explicação de estratégia de atualização é exibido, o que pode ajudar a visualizar como as estratégias funcionam.

   

5. Selecione Criar Estágio e insira:

   • Nome do estágio - nome do estágio - deve ser único entre todos os nomes de estágio na estratégia.
   • (Opcional) Aprovações de estágio – selecione essa opção se você quiser aguardar uma aprovação antes que essa fase seja iniciada ou depois que ela for concluída. Para obter mais informações, confira Adicionar aprovações a grupos e etapas de atualização.
   • (Opcional) Pausar após o estágio – selecione essa opção se quiser definir uma pausa antes de passar para o próximo estágio.
   • (Opcional) Duração da pausa – selecione uma duração predefinida ou insira um valor personalizado em segundos.

   

6. Atribua um ou mais Grupos de Atualização ao estágio e selecione Criar.

   Observação

   O número máximo de Grupos de Atualização em cada Estágio de Atualização é 50.

   

Para esse cenário, criamos estágios e grupos para corresponder aos detalhes usados para o processo do portal do Azure.

1. Crie um arquivo JSON para definir os estágios e grupos para a execução da atualização. Os estágios são executados sequencialmente na ordem em que aparecem no arquivo JSON. Os grupos são executados em paralelo em cada estágio, portanto, a ordenação não é importante. O seguinte arquivo de exemplo (example-stages.json) define uma estratégia com dois estágios e inclui opcionais maxConcurrency e maxAllowedFailures configurações:

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

   O maxConcurrency campo é opcional e controla quantos clusters podem ser atualizados simultaneamente no nível do estágio ou do grupo. Use um valor maior para atualizar clusters mais rapidamente em sua frota ou um valor menor para uma distribuição mais controlada que limita o raio de explosão se surgirem problemas.

   Neste exemplo, stage-1 define maxConcurrency como "7", o que permite que até "7" clusters nesta fase atualizem simultaneamente. Dentro de stage-1, group-1 limita a simultaneidade aos clusters "3", o que significa que até "3" nesse grupo pode ser atualizado simultaneamente. group-2 permite que até "50%" seus clusters atualizem simultaneamente (por exemplo, se o grupo contiver 4 clusters, até 2 poderão ser atualizados simultaneamente).

   Os valores podem ser um inteiro fixo (por exemplo, "3") ou um percentual (por exemplo, "100%"). Se omitido, o sistema aplicará valores padrão. Para obter detalhes sobre como esses valores são resolvidos e seus limites superiores, consulte Máxima simultaneidade (versão prévia).

   maxAllowedFailures

   O campo maxAllowedFailures é opcional e controla quantas falhas na atualização dos clusters membros são toleradas antes que o grupo ou estágio seja marcado como falho. Por padrão (quando não definido ou "0"), uma única falha interrompe toda a execução da atualização.

   Essa configuração avalia apenas a contagem de falhas. Ele não impõe uma taxa mínima de sucesso. Um grupo ou estágio pode, portanto, terminar em Completed mesmo que alguns ou todos os membros tenham falhado, desde que o limite de falhas não tenha sido excedido quando a Fleet tomou as decisões de agendamento.

   Neste exemplo, stage-1 define maxAllowedFailures como "2", tolerando até duas falhas de membro no estágio. Dentro de stage-1, group-1 tolera "1" falhas, e group-2 tolera a falha de "25%" de seus membros (por exemplo, se o grupo contiver 4 clusters, até 1 falha será tolerada). stage-2 define maxAllowedFailures como "0", o que significa que qualquer falha interrompe imediatamente a execução e geralmente é útil para estágios de produção.

   Para a maioria das implantações, prefira valores baseados em percentuais, pois eles se adaptam melhor a diferentes tamanhos de grupo. Evite definir o valor igual ao número total de membros, a menos que você queira, intencionalmente, um comportamento de “nunca falhar” para esse segmento.

   Os valores podem ser um inteiro fixo (por exemplo, "3") ou um percentual (por exemplo, "25%"). Para obter detalhes sobre como esses valores são resolvidos, consulte Máximo de falhas permitidas (versão prévia).

2. Crie uma nova estratégia de atualização usando o comando az fleet updatestrategy create com o sinalizador --stages definido como o nome do seu arquivo JSON.

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

O exemplo do Terraform nesta seção cria a mesma estrutura de estratégia de dois estágios mostrada no exemplo anterior da CLI do Azure: group-1 contém group-2 e stage-2, que são atualizados em paralelo e seguidos por uma espera de 300 segundos, e então group-3 atualiza stage-1. Ao contrário do exemplo JSON da CLI, o exemplo não é definido maxConcurrency ou maxAllowedFailures em nenhum estágio ou grupo, portanto, o Fleet aplica seus valores padrão. Para adicionar essas configurações, estenda os blocos stage e group em main.tf com os argumentos azurerm_kubernetes_fleet_update_strategy correspondentes.

Revisar o código Terraform

1. Crie um diretório para testar o código de exemplo do Terraform e defina-o como diretório atual.

2. Crie um arquivo chamado providers.tf, depois insira o código a seguir:

   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. Crie um arquivo chamado variables.tf, depois insira o código a seguir:

   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. Crie um arquivo chamado main.tf, depois insira o código a seguir:

   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. Crie um arquivo chamado outputs.tf, depois insira o código a seguir:

   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. Copie o arquivo do exemplo no terraform.tfvars mesmo diretório e edite os valores para a região Azure, o nome do terraform.tfvars.example grupo de recursos, o nome da frota, o nome da estratégia de atualização e as marcas que você deseja usar.

   cp terraform.tfvars.example terraform.tfvars
   

Inicializar, validar e aplicar a configuração

Execute terraform init para inicializar a implantação do Terraform. Esse comando baixa os provedores de Azure necessários para gerenciar seus recursos de Azure.

terraform init

Execute o terraform fmt para formatar os arquivos de configuração de forma consistente.

terraform fmt

Execute terraform validate para confirmar que os arquivos de configuração são sintaticamente válidos.

terraform validate

Execute o comando terraform plan para criar um plano de execução.

terraform plan -out main.tfplan

Execute o comando terraform apply para aplicar o plano de execução à sua infraestrutura de nuvem.

terraform apply main.tfplan

Verificar a estratégia de atualização

Obtenha os nomes do grupo de recursos e do Fleet Manager nas saídas do Terraform e extraia o nome da estratégia da saída update_strategy_id.

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

Mostre os estágios e grupos da estratégia usando o az fleet updatestrategy show comando.

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

A matriz stages da saída do comando mostra stage-1 com group-1 e group-2 e um valor afterStageWaitInSeconds de 300, seguido por stage-2 com group-3, correspondendo à estratégia definida em main.tf.

Limpar os recursos

Execute terraform plan com a sinalização -destroy para criar um plano de execução de destruição.

terraform plan -destroy -out main.destroy.tfplan

Execute terraform apply para aplicar o plano de destruição.

terraform apply main.destroy.tfplan