Documentação do Oracle Cloud Infrastructure

Trabalhando com o Cluster Autoscaler como um Programa Independente

Descubra como instalar, configurar e usar o Kubernetes Cluster Autoscaler como um programa independente para redimensionar automaticamente os pools de nós gerenciados em um cluster que você criou usando o Kubernetes Engine (OKE).

O uso do Kubernetes Cluster Autoscaler como um programa independente, e não como um complemento de cluster, oferece total controle e responsabilidade pela configuração e manutenção contínua, incluindo:

  • Instalando uma versão do Kubernetes Cluster Autoscaler compatível com a versão do Kubernetes em execução no cluster.
  • Especificando argumentos de configuração corretamente.
  • Fazendo upgrade manualmente do Kubernetes Cluster Autoscaler quando você faz upgrade de um cluster para uma nova versão do Kubernetes, para garantir que o Kubernetes Cluster Autoscaler seja compatível com a nova versão do Kubernetes do cluster.

As seguintes instruções descrevem como executar o Dimensionador Automático de Clusters do Kubernetes como um programa independente para gerenciar pools de nós:

Etapa 1: Configurando um Controlador de Instâncias ou um Controlador de Identidades de Carga de Trabalho para Ativar o Acesso do Escalador Automático do Cluster a Pools de Nós

Para gerenciar pools de nós, o Kubernetes Cluster Autoscaler executa ações em outros recursos de serviço do Oracle Cloud Infrastructure. Para executar essas ações nos recursos de serviço do OCI, o Kubernetes Cluster Autoscaler usa as credenciais de um ator autorizado (ou principal). No momento, você pode configurar os seguintes tipos de principal para permitir que o Kubernetes Cluster Autoscaler execute ações nos recursos de serviço do OCI:

  • Controlador de instâncias: O Kubernetes Cluster Autoscaler usa a identidade da instância na qual está em execução.
  • Controlador de identidades da carga de trabalho: O Kubernetes Cluster Autoscaler usa a identidade de um recurso da carga de trabalho em execução em um cluster do Kubernetes.

Observe o uso de controladores de identidade de carga de trabalho para permitir que o Kubernetes Cluster Autoscaler acesse serviços e recursos do OCI:

  • é compatível com clusters aprimorados, mas não com clusters básicos.
  • só é suportado com o Cluster Autoscaler versão 1.26 (ou posterior)

Usando controladores de instâncias para permitir o acesso a pools de nós

Você pode configurar um controlador de instâncias para permitir que o Kubernetes Cluster Autoscaler execute ações nos recursos de serviço do OCI.

Para configurar um controlador de instâncias:

  1. Faça log-in na Console.

  2. Crie um novo grupo dinâmico no nível do compartimento contendo os nós de trabalho (instâncias de computação) no cluster:

    1. Abra o menu de navegação e selecione Identidade e Segurança. Em Identidade, selecione Domínios. Em Domínio de identidades, selecione Grupos dinâmicos.
    2. Selecione o compartimento que contém o cluster.
    3. Siga as instruções em Para criar um grupo dinâmico e dê um nome ao grupo dinâmico (por exemplo, acme-oke-cluster-autoscaler-dyn-grp).

    4. Digite uma regra que inclua os nós de trabalho no compartimento no formato:

      ALL {instance.compartment.id = '<compartment-ocid>'}

      em que <compartment-ocid> é o OCID do compartimento ao qual o cluster pertence.

      Por exemplo:

      ALL {instance.compartment.id = 'ocid1.compartment.oc1..aaaaaaaa23______smwa'}
    5. Clique em Criar Grupo Dinâmico.

  3. Crie uma política para permitir que os nós de trabalho gerenciem pools de nós:

    1. Abra o menu de navegação e selecione Identidade e Segurança. Em Identidade, selecione Políticas.
    2. Siga as instruções em Para criar uma política e dê a ela um nome (por exemplo, acme-oke-cluster-autoscaler-dyn-grp-policy).

    3. Digite uma instrução de política para permitir que os nós de trabalho gerenciem os pools de nós (com outras instruções de política relacionadas à inicialização dos nós de trabalho), no formato:

      Allow dynamic-group <dynamic-group-name> to manage cluster-node-pools in compartment <compartment-name>
Allow dynamic-group <dynamic-group-name> to manage instance-family in compartment <compartment-name>
Allow dynamic-group <dynamic-group-name> to use subnets in compartment <compartment-name>
Allow dynamic-group <dynamic-group-name> to read virtual-network-family in compartment <compartment-name>
Allow dynamic-group <dynamic-group-name> to use vnics in compartment <compartment-name>
Allow dynamic-group <dynamic-group-name> to inspect compartments in compartment <compartment-name>

      em que:

      • <dynamic-group-name> é o nome do grupo dinâmico criado anteriormente. Por exemplo, acme-oke-cluster-autoscaler-dyn-grp Observe que, se um grupo dinâmico não estiver no domínio de identidades padrão, coloque o nome do grupo dinâmico como prefixo com o nome do domínio de identidades no formato dynamic-group '<identity-domain-name>'/'<dynamic-group-name>'. Você também pode especificar o grupo dinâmico usando seu OCID, no formato dynamic-group id <dynamic-group-ocid>.
      • <compartment-name> é o nome do compartimento ao qual o cluster pertence. Por exemplo, acme-oke-cluster-autoscaler-compartment

      Por exemplo:

      Allow dynamic-group acme-oke-cluster-autoscaler-dyn-grp to manage cluster-node-pools in compartment acme-oke-cluster-autoscaler-compartment
Allow dynamic-group acme-oke-cluster-autoscaler-dyn-grp to manage instance-family in compartment acme-oke-cluster-autoscaler-compartment
Allow dynamic-group acme-oke-cluster-autoscaler-dyn-grp to use subnets in compartment acme-oke-cluster-autoscaler-compartment
Allow dynamic-group acme-oke-cluster-autoscaler-dyn-grp to read virtual-network-family in compartment acme-oke-cluster-autoscaler-compartment
Allow dynamic-group acme-oke-cluster-autoscaler-dyn-grp to use vnics in compartment acme-oke-cluster-autoscaler-compartment
Allow dynamic-group acme-oke-cluster-autoscaler-dyn-grp to inspect compartments in compartment acme-oke-cluster-autoscaler-compartment
    4. Clique em Criar para criar a nova política.
    Observação

    Se um pool de nós pertencer a um compartimento e os recursos de rede usados pelo pool de nós pertencerem a outro compartimento, você deverá criar políticas em ambos os compartimentos da seguinte forma:

    • No compartimento do pool de nós, crie uma política com instruções de política no seguinte formato:

      Allow dynamic-group acme-oke-cluster-autoscaler-dyn-grp to manage cluster-node-pools in compartment <nodepool-compartment-name>
Allow dynamic-group acme-oke-cluster-autoscaler-dyn-grp to manage instance-family in compartment <nodepool-compartment-name>
Allow dynamic-group acme-oke-cluster-autoscaler-dyn-grp to use subnets in compartment <nodepool-compartment-name>
Allow dynamic-group acme-oke-cluster-autoscaler-dyn-grp to use vnics in compartment <nodepool-compartment-name>
Allow dynamic-group acme-oke-cluster-autoscaler-dyn-grp to inspect compartments in compartment <nodepool-compartment-name>

    • No compartimento de recursos de rede, crie uma política com instruções de política no seguinte formato:

      Allow dynamic-group acme-oke-cluster-autoscaler-dyn-grp to use subnets in compartment <network-compartment-name>
Allow dynamic-group acme-oke-cluster-autoscaler-dyn-grp to read virtual-network-family in compartment <network-compartment-name>
Allow dynamic-group acme-oke-cluster-autoscaler-dyn-grp to use vnics in compartment <network-compartment-name>
Allow dynamic-group acme-oke-cluster-autoscaler-dyn-grp to inspect compartments in compartment <network-compartment-name>

Usando controladores de identidade de carga de trabalho para permitir o acesso a pools de nós

Você pode configurar um controlador de identidades de carga de trabalho para permitir que o Kubernetes Cluster Autoscaler execute ações nos recursos do serviço OCI. Observe que você só pode usar controladores de identidade de carga de trabalho com clusters aprimorados.

Para configurar um controlador de identidades de carga de trabalho:

  1. Obtenha o OCID do cluster (por exemplo, usando a guia Detalhes do Cluster na Console).
  2. Abra o menu de navegação e selecione Identidade e Segurança. Em Identidade, selecione Políticas.
  3. Siga as instruções em Criando uma Política e dê um nome à política (por exemplo, acme-oke-cluster-autoscaler-policy).

  4. Informe instruções de política para permitir o gerenciamento do pool de nós, no formato:

    Allow any-user to manage cluster-node-pools in compartment <compartment-name> where ALL {request.principal.type='workload', request.principal.namespace ='kube-system', request.principal.service_account = 'cluster-autoscaler', request.principal.cluster_id = '<cluster-ocid>'}
Allow any-user to manage instance-family in compartment <compartment-name> where ALL {request.principal.type='workload', request.principal.namespace ='kube-system', request.principal.service_account = 'cluster-autoscaler', request.principal.cluster_id = '<cluster-ocid>'}
Allow any-user to use subnets in compartment <compartment-name> where ALL {request.principal.type='workload', request.principal.namespace ='kube-system', request.principal.service_account = 'cluster-autoscaler', request.principal.cluster_id = '<cluster-ocid>'}
Allow any-user to read virtual-network-family in compartment <compartment-name> where ALL {request.principal.type='workload', request.principal.namespace ='kube-system', request.principal.service_account = 'cluster-autoscaler', request.principal.cluster_id = '<cluster-ocid>'}
Allow any-user to use vnics in compartment <compartment-name> where ALL {request.principal.type='workload', request.principal.namespace ='kube-system', request.principal.service_account = 'cluster-autoscaler', request.principal.cluster_id = '<cluster-ocid>'}
Allow any-user to inspect compartments in compartment <compartment-name> where ALL {request.principal.type='workload', request.principal.namespace ='kube-system', request.principal.service_account = 'cluster-autoscaler', request.principal.cluster_id = '<cluster-ocid>'}

    em que:

    • <compartment-name> é o nome do compartimento ao qual o cluster pertence. Por exemplo, acme-oke-cluster-autoscaler-compartment
    • <cluster-ocid> é o OCID do cluster obtido anteriormente.

    Por exemplo:

    Allow any-user to manage cluster-node-pools in compartment acme-oke-cluster-autoscaler-compartment where ALL {request.principal.type='workload', request.principal.namespace ='kube-system', request.principal.service_account = 'cluster-autoscaler', request.principal.cluster_id = 'ocid1.cluster.oc1.iad.aaaaaaaa______ska'}
Allow any-user to manage instance-family in compartment acme-oke-cluster-autoscaler-compartment where ALL {request.principal.type='workload', request.principal.namespace ='kube-system', request.principal.service_account = 'cluster-autoscaler', request.principal.cluster_id = 'ocid1.cluster.oc1.iad.aaaaaaaa______ska'}
Allow any-user to use subnets in compartment acme-oke-cluster-autoscaler-compartment where ALL {request.principal.type='workload', request.principal.namespace ='kube-system', request.principal.service_account = 'cluster-autoscaler', request.principal.cluster_id = 'ocid1.cluster.oc1.iad.aaaaaaaa______ska'}
Allow any-user to read virtual-network-family in compartment acme-oke-cluster-autoscaler-compartment where ALL {request.principal.type='workload', request.principal.namespace ='kube-system', request.principal.service_account = 'cluster-autoscaler', request.principal.cluster_id = 'ocid1.cluster.oc1.iad.aaaaaaaa______ska'}
Allow any-user to use vnics in compartment acme-oke-cluster-autoscaler-compartment where ALL {request.principal.type='workload', request.principal.namespace ='kube-system', request.principal.service_account = 'cluster-autoscaler', request.principal.cluster_id = 'ocid1.cluster.oc1.iad.aaaaaaaa______ska'}
Allow any-user to inspect compartments in compartment acme-oke-cluster-autoscaler-compartment where ALL {request.principal.type='workload', request.principal.namespace ='kube-system', request.principal.service_account = 'cluster-autoscaler', request.principal.cluster_id = 'ocid1.cluster.oc1.iad.aaaaaaaa______ska'}
  5. Clique em Criar para criar a nova política.
Observação

Se um pool de nós pertencer a um compartimento e os recursos de rede usados pelo pool de nós pertencerem a outro compartimento, você deverá criar políticas em ambos os compartimentos da seguinte forma:

  • No compartimento do pool de nós, crie uma política com instruções de política no seguinte formato:

    Allow any-user to manage cluster-node-pools in compartment <nodepool-compartment-name> where ALL {request.principal.type='workload', request.principal.namespace ='kube-system', request.principal.service_account = 'cluster-autoscaler', request.principal.cluster_id = '<cluster-ocid>'}
Allow any-user to manage instance-family in compartment <nodepool-compartment-name> where ALL {request.principal.type='workload', request.principal.namespace ='kube-system', request.principal.service_account = 'cluster-autoscaler', request.principal.cluster_id = '<cluster-ocid>'}
Allow any-user to use subnets in compartment <nodepool-compartment-name> where ALL {request.principal.type='workload', request.principal.namespace ='kube-system', request.principal.service_account = 'cluster-autoscaler', request.principal.cluster_id = '<cluster-ocid>'}
Allow any-user to use vnics in compartment <nodepool-compartment-name> where ALL {request.principal.type='workload', request.principal.namespace ='kube-system', request.principal.service_account = 'cluster-autoscaler', request.principal.cluster_id = '<cluster-ocid>'}
Allow any-user to inspect compartments in compartment <nodepool-compartment-name> where ALL {request.principal.type='workload', request.principal.namespace ='kube-system', request.principal.service_account = 'cluster-autoscaler', request.principal.cluster_id = '<cluster-ocid>'}

  • No compartimento de recursos de rede, crie uma política com instruções de política no seguinte formato:

    Allow any-user to use subnets in compartment <network-compartment-name> where ALL {request.principal.type='workload', request.principal.namespace ='kube-system', request.principal.service_account = 'cluster-autoscaler', request.principal.cluster_id = '<cluster-ocid>'}
Allow any-user to read virtual-network-family in compartment <network-compartment-name> where ALL {request.principal.type='workload', request.principal.namespace ='kube-system', request.principal.service_account = 'cluster-autoscaler', request.principal.cluster_id = '<cluster-ocid>'}
Allow any-user to use vnics in compartment <network-compartment-name> where ALL {request.principal.type='workload', request.principal.namespace ='kube-system', request.principal.service_account = 'cluster-autoscaler', request.principal.cluster_id = '<cluster-ocid>'}
Allow any-user to inspect compartments in compartment <network-compartment-name> where ALL {request.principal.type='workload', request.principal.namespace ='kube-system', request.principal.service_account = 'cluster-autoscaler', request.principal.cluster_id = '<cluster-ocid>'}

Etapa 2: Copiar e personalizar o arquivo de configuração do Cluster Autoscaler

Etapa 2a: Copiar o arquivo de configuração

  1. Em um editor, crie um arquivo chamado cluster-autoscaler.yaml com o seguinte conteúdo:

    ---
apiVersion: v1
kind: ServiceAccount
metadata:
  labels:
    k8s-addon: cluster-autoscaler.addons.k8s.io
    k8s-app: cluster-autoscaler
  name: cluster-autoscaler
  namespace: kube-system
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: cluster-autoscaler
  labels:
    k8s-addon: cluster-autoscaler.addons.k8s.io
    k8s-app: cluster-autoscaler
rules:
  - apiGroups: [""]
    resources: ["events", "endpoints"]
    verbs: ["create", "patch"]
  - apiGroups: [""]
    resources: ["pods/eviction"]
    verbs: ["create"]
  - apiGroups: [""]
    resources: ["pods/status"]
    verbs: ["update"]
  - apiGroups: [""]
    resources: ["endpoints"]
    resourceNames: ["cluster-autoscaler"]
    verbs: ["get", "update"]
  - apiGroups: [""]
    resources: ["nodes"]
    verbs: ["watch", "list", "get", "patch", "update"]
  - apiGroups: [""]
    resources:
      - "pods"
      - "services"
      - "replicationcontrollers"
      - "persistentvolumeclaims"
      - "persistentvolumes"
    verbs: ["watch", "list", "get"]
  - apiGroups: ["extensions"]
    resources: ["replicasets", "daemonsets"]
    verbs: ["watch", "list", "get"]
  - apiGroups: ["policy"]
    resources: ["poddisruptionbudgets"]
    verbs: ["watch", "list"]
  - apiGroups: ["apps"]
    resources: ["statefulsets", "replicasets", "daemonsets"]
    verbs: ["watch", "list", "get"]
  - apiGroups: ["storage.k8s.io"]
    resources: ["storageclasses", "csinodes", "volumeattachments"]
    verbs: ["watch", "list", "get"]
  - apiGroups: ["batch", "extensions"]
    resources: ["jobs"]
    verbs: ["get", "list", "watch", "patch"]
  - apiGroups: ["coordination.k8s.io"]
    resources: ["leases"]
    verbs: ["create"]
  - apiGroups: ["coordination.k8s.io"]
    resourceNames: ["cluster-autoscaler"]
    resources: ["leases"]
    verbs: ["get", "update"]
  - apiGroups: [""]
    resources: ["namespaces"]
    verbs: ["watch", "list"]
  - apiGroups: ["storage.k8s.io"]
    resources: ["csidrivers", "csistoragecapacities"]
    verbs: ["watch", "list"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: cluster-autoscaler
  namespace: kube-system
  labels:
    k8s-addon: cluster-autoscaler.addons.k8s.io
    k8s-app: cluster-autoscaler
rules:
  - apiGroups: [""]
    resources: ["configmaps"]
    verbs: ["create","list","watch"]
  - apiGroups: [""]
    resources: ["configmaps"]
    resourceNames: ["cluster-autoscaler-status", "cluster-autoscaler-priority-expander"]
    verbs: ["delete", "get", "update", "watch"]

---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: cluster-autoscaler
  labels:
    k8s-addon: cluster-autoscaler.addons.k8s.io
    k8s-app: cluster-autoscaler
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-autoscaler
subjects:
  - kind: ServiceAccount
    name: cluster-autoscaler
    namespace: kube-system

---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: cluster-autoscaler
  namespace: kube-system
  labels:
    k8s-addon: cluster-autoscaler.addons.k8s.io
    k8s-app: cluster-autoscaler
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: cluster-autoscaler
subjects:
  - kind: ServiceAccount
    name: cluster-autoscaler
    namespace: kube-system

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: cluster-autoscaler
  namespace: kube-system
  labels:
    app: cluster-autoscaler
spec:
  replicas: 3
  selector:
    matchLabels:
      app: cluster-autoscaler
  template:
    metadata:
      labels:
        app: cluster-autoscaler
      annotations:
        prometheus.io/scrape: 'true'
        prometheus.io/port: '8085'
    spec:
      serviceAccountName: cluster-autoscaler
      containers:
        - image: iad.ocir.io/oracle/oci-cluster-autoscaler:{{ image tag }}
          name: cluster-autoscaler
          resources:
            limits:
              cpu: 100m
              memory: 300Mi
            requests:
              cpu: 100m
              memory: 300Mi
          command:
            - ./cluster-autoscaler
            - --v=4
            - --stderrthreshold=info
            - --cloud-provider=oci
            - --max-node-provision-time=25m
            - --nodes=1:5:{{ node pool ocid 1 }}
            - --nodes=1:5:{{ node pool ocid 2 }}
            - --scale-down-delay-after-add=10m
            - --scale-down-unneeded-time=10m
            - --unremovable-node-recheck-timeout=5m
            - --balance-similar-node-groups
            - --balancing-ignore-label=displayName
            - --balancing-ignore-label=hostname
            - --balancing-ignore-label=internal_addr
            - --balancing-ignore-label=oci.oraclecloud.com/fault-domain
          imagePullPolicy: "Always"
  2. Salve o arquivo cluster-autoscaler.yaml criado.

Etapa 2b: Especifique os pools de nós a serem gerenciados

No arquivo cluster-autoscaler.yaml criado, especifique os pools de nós do cluster que você deseja que o Kubernetes Cluster Autoscaler gerencie.

Você pode especificar que deseja que o Kubernetes Cluster Autoscaler gerencie um único pool de nós ou vários pools de nós. A recomendação é sempre ter pelo menos um pool de nós que não seja gerenciado pelo Kubernetes Cluster Autoscaler para executar complementos críticos do cluster e garantir que o Kubernetes Cluster Autoscaler não reduza os nós nos quais ele está sendo executado. Observe também que é sua responsabilidade dimensionar manualmente todos os pools de nós que você não especificar no arquivo de configuração.

Você especifica os pools de nós que deseja que o Kubernetes Cluster Autoscaler gerencie de duas maneiras:

  • Você pode especificar explicitamente cada pool de nós a ser gerenciado, usando o parâmetro --nodes para especificar o OCID de cada pool de nós.
  • Você pode especificar que o Kubernetes Cluster Autoscaler deve descobrir qual pool de nós (ou pools de nós) gerenciar, usando o parâmetro --node-group-auto-discovery para especificar as tags a serem correspondidas. Você pode especificar tags definidas e tags de formato livre. Para obter mais informações sobre como adicionar tags a pools de nós, consulte Aplicando Tags a Pools de Nós. O Kubernetes Cluster Autoscaler gerencia pools de nós com tags que correspondem às tags especificadas. Observe que o parâmetro node-group-auto-discovery é suportado com o Cluster Autoscaler versão 1.30.3, versão 1.31.1 e versão 1.32.0 e posterior.

Observe que você não pode especificar o parâmetro --nodes e o parâmetro --node-group-auto-discovery no mesmo arquivo cluster-autoscaler.yaml. Os dois parâmetros são alternativas mutuamente exclusivas.

Para usar o parâmetro --nodes para especificar explicitamente quais pools de nós gerenciar:

  1. No arquivo cluster-autoscaler.yaml criado, localize a seguinte linha de modelo:

    - --nodes=1:5:{{ node pool ocid 1 }}

    O parâmetro --nodes tem o seguinte formato:

    --nodes=<min-nodes>:<max-nodes>:<nodepool-ocid>

    em que:

    • <min-nodes> é o número mínimo de nós permitido no pool de nós. O Kubernetes Cluster Autoscaler não reduzirá o número de nós abaixo desse número.
    • <max-nodes> é o número máximo de nós permitido no pool de nós. O Kubernetes Cluster Autoscaler não aumentará o número de nós acima desse número. Certifique-se de que o número máximo de nós especificado não exceda os limites da tenancy para a forma do nó de trabalho definida para o pool de nós.
    • <nodepool-ocid> é o OCID do pool de nós a ser gerenciado.

  2. Altere o valor do parâmetro --nodes para especificar:

    • O número mínimo de nós permitido no pool de nós. Por exemplo, 1.
    • O número máximo de nós permitido no pool de nós. Por exemplo, 5.
    • O OCID do pool de nós que você deseja que o Kubernetes Cluster Autoscaler gerencie.

    Por exemplo:

    --nodes=1:5:ocid1.nodepool.oc1.iad.aaaaaaaaaeydq...
  3. Se você só quiser que o Kubernetes Cluster Autoscaler gerencie um pool de nós no cluster, localize a seguinte linha no arquivo cluster-autoscaler.yaml e remova-a:
    - --nodes=1:5:{{ node pool ocid 2 }}
  4. Se quiser que o Kubernetes Cluster Autoscaler gerencie um segundo pool de nós no cluster, localize a seguinte linha no arquivo cluster-autoscaler.yaml e defina valores apropriados para o parâmetro --nodes:
    - --nodes=1:5:{{ node pool ocid 2 }}
  5. Se quiser que o Kubernetes Cluster Autoscaler gerencie mais pools de nós, insira parâmetros --nodes adicionais no arquivo cluster-autoscaler.yaml e defina valores apropriados para eles.
  6. Salve o arquivo cluster-autoscaler.yaml.

Para usar o parâmetro --node-group-auto-discovery para especificar que o Kubernetes Cluster Autoscaler deve descobrir quais pools de nós gerenciar:

  1. No arquivo cluster-autoscaler.yaml criado, localize a seguinte linha de modelo:

    - --nodes=1:5:{{ node pool ocid 1 }}
  2. Exclua toda a linha que especifica o parâmetro --nodes e substitua-a pela seguinte linha:
    - --node-group-auto-discovery=clusterId:{{ cluster ocid }},compartmentId:{{ compartment ocid }},nodepoolTags:{{ tagKey1 }}={{ tagValue1 }}&{{ tagKey2 }}={{ tagValue2 }},min:{{ min }},max:{{ max }}

    O parâmetro --node-group-auto-discovery tem o seguinte formato:

    --node-group-auto-discovery=clusterId:{{<cluster-ocid>}},compartmentId:{{<compartment-ocid>}},nodepoolTags:{{<tagKey1>}}={{<tagValue1>}}&{{<tagKey2>}}={{<tagValue2>}},min:{{<min-nodes>}},max:{{<max-nodes>}}

    em que:

    • <cluster-ocid> é o cluster no qual o Kubernetes Cluster Autoscaler será executado.
    • <compartment-ocid> é o OCID do compartimento no qual o pool de nós está localizado.
    • {{<tagKey1>}}={{<tagValue1>}} especifica o nome da primeira tag a ser correspondida e o valor dessa tag a ser correspondida.
    • {{<tagKey2>}}={{<tagValue2>}} especifica opcionalmente o nome de uma segunda tag a ser correspondida e o valor dessa tag a ser correspondida. Você pode especificar quantas tags forem necessárias (você não está limitado a duas). Se você especificar várias tags, todas elas terão que corresponder.
    • <min-nodes> é o número mínimo de nós permitido no pool de nós. O Kubernetes Cluster Autoscaler não reduzirá o número de nós abaixo desse número.
    • <max-nodes> é o número máximo de nós permitido no pool de nós. O Kubernetes Cluster Autoscaler não aumentará o número de nós acima desse número. Certifique-se de que o número máximo de nós especificado não exceda os limites da tenancy para a forma do nó de trabalho definida para o pool de nós.

  3. Altere o valor do parâmetro --node-group-auto-discovery para especificar:

    • O cluster no qual o Kubernetes Cluster Autoscaler será executado.
    • O OCID do compartimento no qual o pool de nós está localizado.
    • Um ou mais nomes de tag e valores de tag para correspondência.
    • O número mínimo de nós permitido no pool de nós. Por exemplo, 1.
    • O número máximo de nós permitido no pool de nós. Por exemplo. 5.

    Por exemplo:

    --node-group-auto-discovery=clusterId:ocid1.cluster.oc1.iad.aaaaaaaa______ixq,compartmentId:ocid1.compartment.oc1..aaaaaaaa______t7a,nodepoolTags:managedby=ca,min:1,max:5
  4. Localize a seguinte linha no arquivo cluster-autoscaler.yaml e remova-a:
    - --nodes=1:5:{{ node pool ocid 2 }}
  5. Se você quiser que o Kubernetes Cluster Autoscaler gerencie mais pools de nós, em compartimentos diferentes ou com nomes de tag e valores de tag diferentes ou com números mínimos e máximos diferentes de nós permitidos, insira parâmetros --node-group-auto-discovery adicionais no arquivo cluster-autoscaler.yaml e defina valores apropriados para eles.

    Por exemplo:

    --node-group-auto-discovery=clusterId:ocid1.cluster.oc1.iad.aaaaaaaa______ixq,compartmentId:ocid1.compartment.oc1..aaaaaaaa______t7a,nodepoolTags:managedby=ca,min:1,max:5
--node-group-auto-discovery=clusterId:ocid1.cluster.oc1.iad.aaaaaaaa______ixq,compartmentId:ocid1.compartment.oc1..aaaaaaaa______jyv,nodepoolTags:managedby=ca,min:2,max:6
  6. Salve o arquivo cluster-autoscaler.yaml.

Etapa 2c: Incluir definições de configuração adicionais

  1. No arquivo cluster-autoscaler.yaml criado, adicione variáveis de ambiente para especificar como você configurou o Kubernetes Cluster Autoscaler para acessar os serviços e recursos do OCI:
    • Se você tiver configurado um controlador de instâncias para permitir que o Kubernetes Cluster Autoscaler acesse serviços e recursos do OCI, após a linha imagePullPolicy: "Always" no final do arquivo, adicione o seguinte:
                env:
          - name: OKE_USE_INSTANCE_PRINCIPAL
            value: "true"
          - name: OCI_SDK_APPEND_USER_AGENT
            value: "oci-oke-cluster-autoscaler"

      Por exemplo:

      ...
          imagePullPolicy: "Always"
          env:
          - name: OKE_USE_INSTANCE_PRINCIPAL
            value: "true"
          - name: OCI_SDK_APPEND_USER_AGENT
            value: "oci-oke-cluster-autoscaler"
    • Se você tiver configurado um controlador de identidades de carga de trabalho para permitir que o Kubernetes Cluster Autoscaler acesse serviços e recursos do OCI, após a linha imagePullPolicy: "Always" no final do arquivo, adicione o seguinte:
                env:
          - name: OKE_USE_INSTANCE_PRINCIPAL
            value: "false"
          - name: OCI_USE_WORKLOAD_IDENTITY
            value: "true"
          - name: OCI_RESOURCE_PRINCIPAL_VERSION
            value: "2.2"
          - name: OCI_RESOURCE_PRINCIPAL_REGION
            value: "<cluster-region>"
          - name: OCI_SDK_APPEND_USER_AGENT
            value: "oci-oke-cluster-autoscaler"

      em que <cluster-region> é a região em que o cluster está localizado.

      Por exemplo:

      ...
          imagePullPolicy: "Always"
          env:
          - name: OKE_USE_INSTANCE_PRINCIPAL
            value: "false"
          - name: OCI_USE_WORKLOAD_IDENTITY
            value: "true"
          - name: OCI_RESOURCE_PRINCIPAL_VERSION
            value: "2.2"
          - name: OCI_RESOURCE_PRINCIPAL_REGION
            value: "us-phoenix-1"
          - name: OCI_SDK_APPEND_USER_AGENT
            value: "oci-oke-cluster-autoscaler"
  2. No arquivo cluster-autoscaler.yaml criado, confirme se o parâmetro --cloud-provider está definido corretamente para a versão do Kubernetes em execução no cluster. Por padrão, o parâmetro assume que o cluster está executando o Kubernetes versão 1.27 ou mais recente (ou 1.23 ou mais recente) e está definido como oci. Se o cluster estiver executando o Kubernetes versão 1.26, 1.25 ou 1.24, altere o valor do parâmetro --cloud-provider para oci-oke:

    1. No arquivo cluster-autoscaler.yaml, localize a seguinte linha:

      - --cloud-provider=oci
    2. Se o cluster estiver executando o Kubernetes versão 1.26, 1.25 ou 1.24, altere o valor do parâmetro --cloud-provider para oci-oke:
      - --cloud-provider=oci-oke
    3. Salve o arquivo cluster-autoscaler.yaml.
  3. No arquivo cluster-autoscaler.yaml criado, altere o caminho da imagem do Kubernetes Cluster Autoscaler para fazer download do Oracle Cloud Infrastructure Registry. As imagens estão disponíveis em várias regiões. Para obter o melhor desempenho, escolha a região mais próxima de uma em que o cluster esteja implantado:

    1. No arquivo cluster-autoscaler.yaml, localize a seguinte linha de modelo:

      - image: iad.ocir.io/oracle/oci-cluster-autoscaler:{{ image tag }}

    2. Altere o caminho da imagem para um dos seguintes, de acordo com a localização e a versão do Kubernetes do cluster no qual executar o Kubernetes Cluster Autoscaler:

      Localização da Imagem Versão do Kubernetes Caminho da Imagem
      Centro da Alemanha (Frankfurt) Kubernetes 1.30 fra.ocir.io/oracle/oci-cluster-autoscaler:1.30.4-3
      Centro da Alemanha (Frankfurt) Kubernetes 1.31 fra.ocir.io/oracle/oci-cluster-autoscaler:1.31.2-1
      Centro da Alemanha (Frankfurt) Kubernetes 1.32 fra.ocir.io/oracle/oci-cluster-autoscaler:1.32.1-1
      Centro da Alemanha (Frankfurt) Kubernetes 1.33 fra.ocir.io/oracle/oci-cluster-autoscaler:1.32.1-1
      Sul do Reino Unido (London) Kubernetes 1.30 lhr.ocir.io/oracle/oci-cluster-autoscaler:1.30.4-3
      Sul do Reino Unido (London) Kubernetes 1.31 lhr.ocir.io/oracle/oci-cluster-autoscaler:1.31.2-1
      Sul do Reino Unido (London) Kubernetes 1.32 lhr.ocir.io/oracle/oci-cluster-autoscaler:1.32.1-1
      Sul do Reino Unido (London) Kubernetes 1.33 lhr.ocir.io/oracle/oci-cluster-autoscaler:1.32.1-1
      Leste dos EUA (Ashburn) Kubernetes 1.30 iad.ocir.io/oracle/oci-cluster-autoscaler:1.30.4-3
      Leste dos EUA (Ashburn) Kubernetes 1.31 iad.ocir.io/oracle/oci-cluster-autoscaler:1.31.2-1
      Leste dos EUA (Ashburn) Kubernetes 1.32 iad.ocir.io/oracle/oci-cluster-autoscaler:1.32.1-1
      Leste dos EUA (Ashburn) Kubernetes 1.33 iad.ocir.io/oracle/oci-cluster-autoscaler:1.32.1-1
      Oeste dos EUA (Phoenix) Kubernetes 1.30 phx.ocir.io/oracle/oci-cluster-autoscaler:1.30.4-3
      Oeste dos EUA (Phoenix) Kubernetes 1.31 phx.ocir.io/oracle/oci-cluster-autoscaler:1.31.2-1
      Oeste dos EUA (Phoenix) Kubernetes 1.32 phx.ocir.io/oracle/oci-cluster-autoscaler:1.32.1-1
      Oeste dos EUA (Phoenix) Kubernetes 1.33 phx.ocir.io/oracle/oci-cluster-autoscaler:1.32.1-1

      Por exemplo, se você quiser executar o Kubernetes Cluster Autoscaler em um cluster do Kubernetes 1.32 localizado na região Sul do Reino Unido, especifique a seguinte imagem:

      - image: lhr.ocir.io/oracle/oci-cluster-autoscaler:1.32.1-1
      Dica

      Se você quiser implantar o Kubernetes Cluster Autoscaler em um cluster do Kubernetes que não esteja na mesma região que qualquer um dos repositórios Oracle que contêm imagens do Cluster Autoscaler, recomendamos que você envie a imagem para um repositório que esteja na mesma região do cluster, da seguinte forma:

      i. Extraia a imagem de um repositório da Oracle usando o comando docker pull. Consulte Extraindo Imagens Usando a CLI do Docker.

      ii. Marque com tag a imagem (usando o comando docker tag) e, em seguida, envie-a para um repositório no Oracle Cloud Infrastructure Registry que esteja na mesma região do cluster no qual você deseja executar o Kubernetes Cluster Autoscaler (usando o comando docker push). Consulte Enviando Imagens Usando a CLI do Docker.

      iii. Especifique o local da imagem, no arquivo cluster-autoscaler.yaml.

      Observação

      Se quiser implantar o Kubernetes Cluster Autoscaler em um cluster do Kubernetes no qual você tenha ativado a verificação de imagem, não especifique simplesmente um caminho de imagem de um dos repositórios da Oracle no arquivo cluster-autoscaler.yaml. Em vez disso, faça o seguinte:

      i. Extraia a imagem de um repositório da Oracle usando o comando docker pull. Consulte Extraindo Imagens Usando a CLI do Docker.

      ii. Marque com tag a imagem (usando o comando docker tag) e, em seguida, envie-a para um repositório no Oracle Cloud Infrastructure Registry que esteja na mesma região do cluster no qual você deseja executar o Kubernetes Cluster Autoscaler (usando o comando docker push). Consulte Enviando Imagens Usando a CLI do Docker.

      iii. Assine a imagem usando uma chave principal e uma versão de chave no serviço Vault, criando uma assinatura de imagem. Consulte Assinando Imagens para Segurança.

      iv. Especifique o local da imagem assinada, no arquivo cluster-autoscaler.yaml. Faça referência à imagem usando a compilação de imagem em vez da tag de imagem (consulte Impondo o Uso de Imagens Assinadas do Registro).

    3. Salve o arquivo cluster-autoscaler.yaml.

  4. No arquivo cluster-autoscaler.yaml criado, confirme se os valores padrão dos parâmetros de limite de CPU e memória são suficientes para o número de pools de nós que você deseja que o Kubernetes Cluster Autoscaler gerencie. Os limites padrão são relativamente baixos; portanto, considere aumentar os limites se quiser que o Kubernetes Cluster Autoscaler gerencie um grande número de pools de nós. Observe que é sua responsabilidade definir os limites para valores adequados.

    1. No arquivo cluster-autoscaler.yaml, localize as seguintes linhas:

                resources:
            limits:
              cpu: 100m
              memory: 300Mi
    2. Defina os limites de CPU e memória para valores apropriados para o número de pools de nós que você deseja que o Kubernetes Cluster Autoscaler gerencie. Por exemplo:
                resources:
            limits:
              cpu: 200m
              memory: 600Mi
    3. Salve o arquivo cluster-autoscaler.yaml.

  5. No arquivo cluster-autoscaler.yaml criado, especifique outros parâmetros para o Kubernetes Cluster Autoscaler. Para obter informações sobre os parâmetros que você pode definir, consulte Parâmetros do Kubernetes Cluster Autoscaler Suportados.

  6. Salve e feche o arquivo cluster-autoscaler.yaml.

Etapa 3: Implantar o Kubernetes Cluster Autoscaler no cluster e confirmar a implantação bem-sucedida

  1. Se você ainda não tiver feito isso, siga as etapas para configurar o arquivo de configuração kubeconfig do cluster e (se necessário) defina a variável de ambiente KUBECONFIG para apontar para o arquivo. Observe que você deve configurar seu próprio arquivo kubeconfig. Não é possível acessar um cluster usando um arquivo kubeconfig que outro usuário tenha configurado. Consulte Configurando o Acesso ao Cluster.
  2. Implante o Kubernetes Cluster Autoscaler no cluster digitando:
    kubectl apply -f cluster-autoscaler.yaml
  3. Exiba os logs do Kubernetes Cluster Autoscaler para confirmar se ele foi implantado com sucesso e está monitorando no momento a carga de trabalho dos pools de nós do cluster, digitando:
    kubectl -n kube-system logs -f deployment.apps/cluster-autoscaler
  4. Identifique qual dos três pods do Kubernetes Cluster Autoscaler definidos no arquivo cluster-autoscaler.yaml está executando ações no momento, digitando:
    kubectl -n kube-system get lease
  5. Tenha uma visão de alto nível do estado do Kubernetes Cluster Autoscaler no mapa de configuração do namespace kube-system, digitando:
    kubectl -n kube-system get cm cluster-autoscaler-status -oyaml

Etapa 4: Exibir a Operação de Dimensionamento

Você pode observar o Kubernetes Cluster Autoscaler implantado porque ele dimensiona automaticamente os nós de trabalho de um pool de nós. Para tornar a operação de dimensionamento mais clara, considere as seguintes sugestões (observe que elas se destinam apenas para fins de observação e podem ser contrárias às recomendações mostradas em Recomendações ao usar o Kubernetes Cluster Autoscaler em Ambientes de Produção):

  • Observe um cluster que tenha um único pool de nós (o pool que está sendo gerenciado pelo Kubernetes Cluster Autoscaler).
  • Se o cluster que você deseja observar tiver mais de um pool de nós, restrinja os pods a serem executados nos nós do pool de nós único que está sendo gerenciado pelo Kubernetes Cluster Autoscaler. Consulte Designando Pods a Nós na documentação do Kubernetes.
  • Comece com um nó no pool de nós que está sendo gerenciado pelo Kubernetes Cluster Autoscaler.
  • No arquivo de configuração do Kubernetes Cluster Autoscaler, especifique o número máximo de nós permitidos no pool de nós. Certifique-se de que o número máximo de nós especificado não exceda o limite da tenancy para a forma do nó de trabalho definida para o pool de nós.

Para exibir o Kubernetes Cluster Autoscaler dimensionando nós de trabalho automaticamente:

  1. Confirme o número total atual de nós de trabalho no cluster digitando:
    kubectl get nodes

  2. Defina um aplicativo Nginx de amostra criando um arquivo chamado nginx.yaml em um editor de texto, com o seguinte conteúdo: 

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  replicas: 2
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80
        resources:
          requests:
            memory: "500Mi"

    Observe que um limite de solicitação de recurso foi definido.

  3. Implante o aplicativo de amostra digitando:
    kubectl create -f nginx.yaml
  4. Aumente o número de pods na implantação para 100 (de 2) digitando:
    kubectl scale deployment nginx-deployment --replicas=100

    O Kubernetes Cluster Autoscaler agora adiciona nós de trabalho ao pool de nós para atender ao aumento da carga de trabalho.

  5. Observe o status da implantação digitando:
    kubectl get deployment nginx-deployment --watch
  6. Após alguns minutos, exiba o aumento do número total de nós de trabalho no cluster digitando:
    kubectl get nodes

    Observe que o número de nós de trabalho que você vê dependerá da forma do nó de trabalho e do número máximo de nós especificados no arquivo de configuração do Kubernetes Cluster Autoscaler.

Etapa 5: Limpar

  1. Exclua o aplicativo Nginx de amostra digitando:
    kubectl delete deployment nginx-deployment
  2. Após dez minutos, confirme se os nós de trabalho foram reduzidos para o número original, digitando:
    kubectl get nodes

Observe que depois de excluir o aplicativo Nginx de amostra e aguardar, talvez você veja menos nós de trabalho, mas ainda mais do que o número original. Isso provavelmente ocorre porque os pods kube-system foram programados para serem executados nesses nós. Os pods kube-system podem impedir que o Kubernetes Cluster Autoscaler remova os nós porque o parâmetro skip-nodes-with-system-pods do Autoscaler é definido como true por padrão.