Compartilhar via


Usar o PowerShell para dimensionamento automático de cluster no AKS habilitado pelo Azure Arc

Aplicável a: AKS no Azure Local 22H2, AKS no Windows Server

Você pode usar o PowerShell para habilitar o dimensionador automático e gerenciar o dimensionamento automático de pools de nós em seus clusters de destino no AKS habilitado pelo Arc. Você também pode usar o PowerShell para configurar e gerenciar o dimensionamento automático do cluster.

Criar um novo objeto AksHciAutoScalerConfig

Para criar um novo objeto AksHciAutoScalerConfig para passar para o New-AksHciCluster comando or Set-AksHciCluster , use este comando:

New-AksHciAutoScalerProfile -Name asp1 -AutoScalerProfileConfig @{ "min-node-count"=2; "max-node-count"=7; 'scale-down-unneeded-time'='1m'}

Você pode fornecer o objeto autoscalerconfig ao criar seu cluster. O objeto contém os parâmetros para o dimensionador automático. Para obter informações sobre parâmetros, consulte Como usar os perfis do dimensionador automático.

Alterar um objeto de perfil AksHciAutoScalerConfig existente

Quando você atualiza um objeto de perfil AksHciAutoScalerConfig existente, os clusters que usam esse objeto são atualizados para usar os novos parâmetros:

Set-AksHciAutoScalerProfile -name myProfile -autoScalerProfileConfig @{ "max-node-count"=5; "min-node-count"=2 }

Você pode atualizar o objeto autoscalerconfig , que contém os parâmetros do dimensionador automático. Para obter informações sobre parâmetros, consulte Como usar os perfis do dimensionador automático.

Habilitar o dimensionamento automático para novos clusters

Para habilitar o dimensionamento automático automaticamente em todos os pools de nós recém-criados, use os seguintes parâmetros com o New-AksHciCluster comando:

New-AksHciCluster -name mycluster -enableAutoScaler -autoScalerProfileName myAutoScalerProfile

Habilitar o dimensionamento automático em um cluster existente

Para habilitar o dimensionamento automático automaticamente em cada pool de nós recém-criado em um cluster existente, use o enableAutoScaler parâmetro com o Set-AksHciCluster comando:

Set-AksHciCluster -Name <string> [-enableAutoScaler <boolean>] [-autoScalerProfileName <String>] 

Habilitar o dimensionamento automático em um pool de nós existente

Para habilitar o dimensionamento automático em um pool de nós existente, use o autoScaler parâmetro com o Set-AksHciNodePool comando:

Set-AksHciNodePool -clusterName <Your-Cluster-Name> -name <Your-NodePool-Name> -autoScaler $true

Desabilitar o dimensionamento automático

Para desabilitar o dimensionamento automático em todos os pools de nós existentes e recém-criados em um cluster existente, defina enableAutoScaler como false usando o Set-AksHciCluster comando:

Set-AksHciCluster -Name <string> -enableAutoScaler $false

Fazendo uso eficaz do escalonador automático horizontal

Agora que o cluster e o pool de nós estão configurados para escalar automaticamente, você pode configurar uma carga de trabalho para também escalar de uma forma que use os recursos do dimensionador automático horizontal.

Dois métodos estão disponíveis para dimensionamento de carga de trabalho:

  • Kubernetes Horizontal Pod Autoscaler: Com base nas características de carga, o Horizontal Pod Autoscaler (também conhecido como horizontal autoscaler) dimensiona os pods de uma implantação de aplicativo para nós disponíveis no cluster do Kubernetes. Se não houver mais nós disponíveis para serem agendados, o dimensionador automático horizontal instanciará um novo nó para o qual agendar os pods. Se a carga do aplicativo diminuir, os nós serão reduzidos novamente.
  • Regras de antiafinidade do nó do Kubernetes: as regras de antiafinidade para uma implantação do Kubernetes podem especificar que um conjunto de pods não pode ser dimensionado no mesmo nó e um nó diferente é necessário para dimensionar a carga de trabalho. Em combinação com as características de carga ou o número de pods de destino para as instâncias do aplicativo, o dimensionador automático horizontal instancia novos nós no pool de nós para atender às solicitações. Se a demanda do aplicativo diminuir, o dimensionador automático horizontal reduzirá o pool de nós novamente.

Esta seção contém alguns exemplos.

Dimensionador automático de pod horizontal

Pré-requisitos:

  • O AKS habilitado pelo Arc está instalado.
  • O cluster de destino está instalado e conectado ao Azure.
  • Um pool de nós do Linux é implantado, com pelo menos um nó de trabalho do Linux ativo.
  • O dimensionador automático de nó horizontal está habilitado no cluster de destino e no pool de nós do Linux, conforme descrito anteriormente.

Usamos o exemplo de passo a passo do Kubernetes Horizontal Pod Autoscaler para mostrar como o Horizontal Pod Autoscaler funciona.

Para que o Horizontal Pod Autoscaler funcione, você deve implantar o componente Metrics Server no cluster de destino.

Para implantar o servidor de métricas em um cluster de destino chamado mycluster, execute os seguintes comandos:

Get-AksHciCredential -name mycluster
kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

Depois que o Kubernetes Metrics Server for implantado, você poderá implantar um aplicativo no pool de nós, que você usa para dimensionar. Usamos um aplicativo de teste do site da comunidade Kubernetes para este exemplo:

kubectl apply -f https://k8s.io/examples/application/php-apache.yaml
deployment.apps/php-apache created
service/php-apache created

Esse comando cria uma implantação de um aplicativo PHP baseado em servidor web Apache que retornará uma mensagem "OK" para um cliente de chamada.

Em seguida, configure o Horizontal Pod Autoscaler para agendar um novo pod quando o uso da CPU do pod atual atingir 50% e dimensione de 1 a 50 pods:

kubectl autoscale deployment php-apache --cpu-percent=50 --min=1 --max=10
horizontalpodautoscaler.autoscaling/php-apache autoscaled

Você pode verificar o status atual do Horizontal Pod Autoscaler recém-criado executando o seguinte comando:

kubectl get hpa
NAME         REFERENCE                     TARGET    MINPODS   MAXPODS   REPLICAS   AGE
php-apache   Deployment/php-apache/scale   0% / 50%  1         10        1          18s

Por fim, aumente a carga no servidor Web para vê-lo escalar horizontalmente. Abra uma nova janela do PowerShell e execute o seguinte comando:

kubectl run -i --tty load-generator --rm --image=busybox:1.28 --restart=Never -- /bin/sh -c "while sleep 0.01; do wget -q -O- http://php-apache; done"

Se você voltar para a janela anterior do PowerShell e executar o seguinte comando, deverá ver o número de pods mudar em um curto período:

kubectl get hpa php-apache --watch
NAME         REFERENCE                     TARGET      MINPODS   MAXPODS   REPLICAS   AGE
php-apache   Deployment/php-apache/scale   305% / 50%  1         10        1          3m

Neste exemplo, o número de pods muda de 1 para 7, conforme mostrado aqui:

NAME         REFERENCE                     TARGET      MINPODS   MAXPODS   REPLICAS   AGE
php-apache   Deployment/php-apache/scale   305% / 50%  1         10        7          3m

Se isso não for suficiente para disparar o dimensionador automático de nó porque todos os pods cabem em um nó, abra mais janelas do PowerShell e execute mais comandos do gerador de carga. Certifique-se de alterar o nome do pod que você está criando sempre que executar o comando. Por exemplo, use load-generator-2 em vez de load-generator, conforme mostrado no comando a seguir.

kubectl run -i --tty load-generator-2 --rm --image=busybox:1.28 --restart=Never -- /bin/sh -c "while sleep 0.01; do wget -q -O- http://php-apache; done"

Em seguida, verifique o número de nós instanciados com o seguinte comando:

kubectl get nodes
NAME              STATUS   ROLES                  AGE    VERSION
moc-laondkmydzp   Ready    control-plane,master   3d4h   v1.22.4
moc-lorl6k76q01   Ready    <none>                 3d4h   v1.22.4
moc-lorl4323d02   Ready    <none>                   9m   v1.22.4
moc-lorl43bc3c3   Ready    <none>                   2m   v1.22.4

Para assistir a uma redução vertical, pressione CTRL-C para encerrar os pods do gerador de carga e fechar as janelas do PowerShell associadas a eles. Após cerca de 30 minutos, você verá o número de pods diminuir. Cerca de 30 minutos depois, os nós são desprovisionados.

Para obter mais informações sobre o Kubernetes Horizontal Pod Autoscaler, consulte Horizontal Pod Autoscaling.

Regras de afinidade de nó

Você pode usar regras de afinidade de nó para permitir que o agendador do Kubernetes execute pods somente em um conjunto específico de nós em um cluster ou pool de nós com base em determinadas características do nó. Para mostrar a função do Horizontal Node Autoscaler, você pode usar as mesmas regras para garantir que apenas uma instância de um determinado pod seja executada em cada nó.

Pré-requisitos:

  • O AKS Arc está instalado.
  • O cluster de destino está instalado e conectado ao Azure.
  • Um pool de nós do Linux é implantado, com pelo menos um nó de trabalho do Linux ativo.
  • O Horizontal Node Autoscaler está habilitado no cluster de destino e no pool de nós do Linux, conforme descrito anteriormente.

Crie um arquivo YAML com o conteúdo a seguir e salve-o como node-anti-affinity.yaml em uma pasta local.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: redis-cache
spec:
  selector:
    matchLabels:
      app: store
  replicas: 4
  template:
    metadata:
      labels:
        app: store
    spec:
      nodeSelector:
        kubernetes.io/os: linux
      affinity:
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
          - labelSelector:
              matchExpressions:
              - key: app
                operator: In
                values:
                - store
            topologyKey: "kubernetes.io/hostname"
      containers:
      - name: redis-server
        image: redis:3.2-alpine

Abra uma janela do PowerShell e carregue as credenciais do cluster de destino. Neste exemplo, o cluster é chamado mycluster:

Get-AksHciCredential -name mycluster

Agora, aplique o arquivo YAML ao cluster de destino:

kubectl apply -f node-anti-affinity.yaml

Após alguns minutos, você pode usar o seguinte comando para verificar se os novos nós ficaram online:

kubectl get nodes
NAME              STATUS   ROLES                  AGE    VERSION
moc-laondkmydzp   Ready    control-plane,master   3d4h   v1.22.4
moc-lorl6k76q01   Ready    <none>                 3d4h   v1.22.4
moc-lorl4323d02   Ready    <none>                   9m   v1.22.4
moc-lorl43bc3c3   Ready    <none>                   9m   v1.22.4
moc-lorl44ef56c   Ready    <none>                   9m   v1.22.4

Para remover o nó, exclua a implantação do servidor redis com este comando:

kubectl delete -f node-anti-affinity.yaml

Para obter mais informações sobre as regras de afinidade de pod do Kubernetes, consulte Designando pods a nós.

Solucionar problemas do dimensionador automático horizontal

Quando o Horizontal Pod Autoscaler está habilitado para um cluster de destino, uma nova implantação do Kubernetes chamada <cluster_name>-cluster-autoscaler é criada no cluster de gerenciamento. Essa implantação monitora o cluster de destino para garantir que haja nós de trabalho suficientes para agendar pods.

Aqui estão algumas maneiras diferentes de depurar problemas relacionados ao dimensionador automático:

  • Os pods do dimensionador automático de cluster em execução no cluster de gerenciamento coletam informações úteis sobre como ele toma decisões de dimensionamento, o número de nós que ele precisa ativar ou remover e quaisquer erros gerais que possam ocorrer. O dimensionador automático salva essas informações em logs. Execute o seguinte comando para acessar os logs:

    kubectl --kubeconfig $(Get-AksHciConfig).Kva.kubeconfig logs -l app=<cluster_name>-cluster-autoscaler
    
  • Os logs do operador de nuvem registram eventos do Kubernetes no cluster de gerenciamento, o que pode ser útil para entender quando o dimensionador automático foi habilitado ou desabilitado para um cluster e um pool de nós. Eles podem ser visualizados executando o seguinte comando:

    kubectl --kubeconfig $(Get-AksHciConfig).Kva.kubeconfig get events
    
  • A implantação do dimensionador automático de cluster cria um configmap no cluster de destino que ele gerencia. Isso configmap contém informações sobre o status do dimensionador automático, nível em todo o cluster e por pool de nós. Execute o seguinte comando no cluster de destino para exibir o status:

    Observação

    Verifique se você executou Get-AksHciCredentials -Name <clustername> para recuperar as kubeconfig informações para acessar o cluster de destino em questão.

    kubectl --kubeconfig ~\.kube\config get configmap cluster-autoscaler-status -o yaml
    
  • O dimensionador automático de cluster registra eventos no status configmap do dimensionador automático de cluster quando dimensiona o pool de nós de um cluster. Você pode visualizar esses logs executando este comando no cluster de destino:

    kubectl --kubeconfig ~\.kube\config describe configmap cluster-autoscaler-status
    
  • O dimensionador automático de cluster emite eventos em pods no cluster de destino quando toma uma decisão de dimensionamento se o pod não puder ser agendado. Execute este comando para visualizar os eventos em um pod:

    kubectl --kubeconfig ~\.kube\config describe pod <pod_name>
    

Referência do PowerShell

Consulte as seguintes páginas de referência para os cmdlets do PowerShell que dão suporte ao dimensionamento automático do cluster:

Próximas etapas