Compartilhar via

Posicionamento inteligente de recursos do Kubernetes entre clusters usando o Gerenciador de Frota de Kubernetes do Azure

  • Artigo

Os desenvolvedores de aplicativos costumam precisar implantar recursos do Kubernetes em diversos clusters. Os operadores de frotas geralmente precisam escolher os melhores clusters para cargas de trabalho com base em heurísticas (como custo de computação) ou recursos disponíveis (como memória e CPU). É um trabalho desgastante criar, atualizar e rastrear manualmente esses recursos do Kubernetes em vários clusters. Este artigo aborda como você pode lidar com esses cenários usando a funcionalidade inteligente de posicionamento de recursos do Kubernetes no Gerenciador de Frota de Kubernetes do Azure (Frota de Kubernetes).

A funcionalidade de posicionamento de recursos da Frota de Kubernetes pode tomar decisões de agendamento com base nas seguintes propriedades do cluster:

  • Contagem de nós
  • Custo de computação/memória em clusters de membros de destino
  • Disponibilidade de recursos (CPU/memória) nos clusters membros de destino

Para obter mais informações sobre os conceitos neste artigo, confira Posicionamento de recursos do Kubernetes do cluster do hub para os clusters membros.

Pré-requisitos

  • Você precisa de uma conta do Azure com uma assinatura ativa. Crie uma conta gratuitamente.

  • Você deve ter um recurso da Frota de Kubernetes com um ou mais clusters membros. Se você não tiver um, siga o início rápido para criar um recurso da Frota de Kubernetes com um cluster de hub. Em seguida, ingresse em clusters do AKS (Serviço de Kubernetes do Azure) como membros.

    Dica

    Certifique-se de que se os clusters membros do AKS estão configurados para que você possa testar o posicionamento usando as propriedades de cluster que interessam a você (localização, contagem de nós, recursos ou custo).

  • Defina as seguintes variáveis de ambiente:

    export GROUP=<resource-group>
export FLEET=<fleet-name>
export MEMBERCLUSTER01=<cluster01>
export MEMBERCLUSTER02=<cluster02>

  • Você precisa da CLI do Azure versão 2.58.0 ou posterior instalada para concluir este artigo. Para instalar ou atualizar, confira Instalar a CLI do Azure.

  • Se você ainda não tiver a CLI do Kubernetes (kubectl), poderá instalá-la usando este comando:

    az aks install-cli

  • Você precisa da extensão da CLI do Azure fleet. Instale-o executando o seguinte comando:

    az extension add --name fleet

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

    az extension update --name fleet

  • Autorize o kubectl a se conectar ao cluster do hub da Frota de Kubernetes:

    az fleet get-credentials --resource-group $GROUP --name $FLEET

Inspecionar propriedades do cluster de membros

Recupere os rótulos, propriedades e recursos do seu cluster de membros consultando o cluster do hub. Saída como YAML para que você possa ler os resultados.

kubectl get membercluster $MEMBERCLUSTER01 –o yaml

O arquivo YAML resultante contém detalhes (rótulos e propriedades) que você pode usar para criar políticas de posicionamento. Veja um exemplo:

apiVersion: cluster.kubernetes-fleet.io/v1
kind: MemberCluster
metadata:
  annotations:
    ...
  labels:
    fleet.azure.com/location: eastus2
    fleet.azure.com/resource-group: resource-group
    fleet.azure.com/subscription-id: 8xxxxxxx-dxxx-4xxx-bxxx-xxxxxxxxxxx8
  name: cluster01
  resourceVersion: "123456"
  uid: 7xxxxxxx-5xxx-4xxx-bxxx-xxxxxxxxxxx4
spec:
  ...
status:
  ...
  properties:
    kubernetes-fleet.io/node-count:
      observationTime: "2024-09-19T01:33:54Z"
      value: "2"
    kubernetes.azure.com/per-cpu-core-cost:
      observationTime: "2024-09-19T01:33:54Z"
      value: "0.073"
    kubernetes.azure.com/per-gb-memory-cost:
      observationTime: "2024-09-19T01:33:54Z"
      value: "0.022"
  resourceUsage:
    allocatable:
      cpu: 3800m
      memory: 10320392Ki
    available:
      cpu: 2740m
      memory: 8821256Ki
    capacity:
      cpu: "4"
      memory: 14195208Ki

Repita esta etapa para cada cluster membro que você adicionar, para identificar os rótulos e as propriedades que você pode usar em sua política.

Preparar uma carga de trabalho para colocação

Em seguida, publique uma carga de trabalho no cluster do hub para que ela possa ser posicionada em clusters membros:

  1. Crie um namespace para a carga de trabalho no cluster do hub:

    kubectl create namespace test-app

  2. A carga de trabalho de amostra pode ser implantada no novo namespace no cluster do hub. Como esses tipos de recursos do Kubernetes não exigem encapsulamento, você pode implantá-los sem alterações.

    1. Salve o YAML a seguir em um arquivo chamado sample-workload.yaml:

      apiVersion: v1
kind: Service
metadata:
  name: nginx-service
  namespace: test-app
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: LoadBalancer
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  namespace: test-app
spec:
  selector:
    matchLabels:
      app: nginx
  replicas: 2
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.16.1 
        ports:
        - containerPort: 80

    2. Implante a definição de carga de trabalho no cluster do hub:

      kubectl apply -f sample-workload.yaml

Com a definição de carga de trabalho implantada, agora é possível testar a capacidade de posicionamento inteligente da Frota de Kubernetes.

Políticas de posicionamento da carga de trabalho de teste

Você pode usar os exemplos a seguir, juntamente com a documentação conceitual, como guias para escrever seu próprio objeto ClusterResourcePlacement.

Observação

Se você quiser experimentar cada política de exemplo, exclua o objeto ClusterResourcePlacement anterior.

Posicionamento com base na contagem de nós do cluster

Este exemplo mostra um classificador de propriedades que usa a ordem Descending. Essa ordem significa que a Frota de Kubernetes prefere os clusters com contagens de nós mais altas.

O cluster com a maior contagem de nós recebe um peso de 20, e o cluster com a menor contagem recebe um peso de 0. Outros clusters recebem pesos proporcionais calculados usando a fórmula de cálculo de peso.

apiVersion: placement.kubernetes-fleet.io/v1
kind: ClusterResourcePlacement
metadata:
  name: crp-demo
spec:
  resourceSelectors:
    - group: ""
      kind: Namespace
      name: test-app
      version: v1
  policy:
    placementType: PickN
    numberOfClusters: 10
    affinity:
        clusterAffinity:
            preferredDuringSchedulingIgnoredDuringExecution:
            - weight: 20
              preference:
                metricSorter:
                  name: kubernetes-fleet.io/node-count
                  sortOrder: Descending

Posicionamento com seletor de rótulos e classificador de propriedades

Neste exemplo, um cluster receberá um peso somente se tiver o rótulo env=prod. Se o cluster atender a essa restrição de rótulo, ele receberá um peso proporcional com base na quantidade total de CPU naquele cluster membro.

Este exemplo demonstra como você pode usar o seletor de rótulo e o classificador de propriedades para a afinidade preferredDuringSchedulingIgnoredDuringExecution. Um cluster membro que falha no seletor de rótulo não recebe nenhum peso. Os clusters membros que conseguirem satisfazer o seletor de rótulos receberão pesos proporcionais conforme especificado no ordenador de propriedades.

apiVersion: placement.kubernetes-fleet.io/v1
kind: ClusterResourcePlacement
metadata:
  name: crp-demo
spec:
  resourceSelectors:
    - group: ""
      kind: Namespace
      name: test-app
      version: v1
  policy:
    placementType: PickN
    numberOfClusters: 10
    affinity:
        clusterAffinity:
            preferredDuringSchedulingIgnoredDuringExecution:
            - weight: 20
              preference:
                labelSelector:
                  matchLabels:
                    env: prod
                metricSorter:
                  name: resources.kubernetes-fleet.io/total-cpu
                  sortOrder: Descending

Posicionamento com base no custo da memória e do núcleo da CPU

Como o classificador neste exemplo tem uma ordem de Ascending, a Frota de Kubernetes prefere os clusters com menores custos de memória e núcleo de CPU. O cluster com o menor custo de memória e núcleo de CPU recebe um peso de 20, e o cluster com o maior recebe um peso de 0. Outros clusters recebem pesos proporcionais calculados usando a fórmula de cálculo de peso.

apiVersion: placement.kubernetes-fleet.io/v1
kind: ClusterResourcePlacement
metadata:
  name: crp-demo
spec:
  resourceSelectors:
    - group: ""
      kind: Namespace
      name: test-app
      version: v1
  policy:
    placementType: PickN
    numberOfClusters: 2
    affinity:
      clusterAffinity:
        preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 20
            preference:
              propertySorter:
                name: kubernetes.azure.com/per-gb-memory-core-cost
                sortOrder: Ascending
          - weight: 20
            preference:
              propertySorter:
                name: kubernetes.azure.com/per-cpu-core-cost
                sortOrder: Ascending

Exibir o status de um posicionamento

Se você quiser exibir o status de um posicionamento, poderá usar o portal do Azure ou o comando kubectl.

Você pode encontrar detalhes sobre como exibir o progresso de um posicionamento em Usar a API ClusterResourcePlacement para propagar recursos para os clusters membros.

Limpar os recursos

Para obter detalhes sobre como remover um posicionamento de recursos de cluster por meio do portal do Azure ou do comando kubectl, confira Limpar recursos no artigo sobre a propagação de recursos.

Conteúdo relacionado