Documentazione di Oracle Cloud Infrastructure

Utilizzo di Cluster Autoscaler come programma standalone

Scopri come installare, configurare e utilizzare Kubernetes Cluster Autoscaler come programma standalone per ridimensionare automaticamente i pool di nodi gestiti in un cluster creato utilizzando Kubernetes Engine (OKE).

L'utilizzo di Kubernetes Cluster Autoscaler come programma standalone piuttosto che come componente aggiuntivo cluster offre il controllo completo e la responsabilità della configurazione e della manutenzione continua, tra cui:

  • Installazione di una versione dell'Autoscaler del cluster Kubernetes compatibile con la versione di Kubernetes in esecuzione nel cluster.
  • Specifica degli argomenti di configurazione corretta.
  • Eseguire manualmente l'upgrade di Kubernetes Cluster Autoscaler quando si aggiorna un cluster a una nuova versione di Kubernetes, per garantire che Kubernetes Cluster Autoscaler sia compatibile con la nuova versione di Kubernetes del cluster.

Le istruzioni riportate di seguito descrivono come eseguire Kubernetes Cluster Autoscaler come programma standalone per la gestione dei pool di nodi.

Passo 1: impostazione di un principal dell'istanza o di un principal dell'identità del carico di lavoro per abilitare l'accesso di scala automatica del cluster ai pool di nodi

Per gestire i pool di nodi, Kubernetes Cluster Autoscaler esegue azioni su altre risorse del servizio Oracle Cloud Infrastructure. Per eseguire tali azioni sulle risorse del servizio OCI, Kubernetes Cluster Autoscaler utilizza le credenziali di un attore (o principal) autorizzato. Al momento, è possibile impostare i seguenti tipi di principal per consentire a Kubernetes Cluster Autoscaler di eseguire azioni sulle risorse del servizio OCI:

  • Principal istanza: l'Autoscaler del cluster Kubernetes utilizza l'identità dell'istanza in cui è in esecuzione.
  • Principal di identità del carico di lavoro: l'Autoscaler del cluster Kubernetes utilizza l'identità di una risorsa del carico di lavoro in esecuzione su un cluster Kubernetes.

Tenere presente l'uso dei principal delle identità del carico di lavoro per consentire all'Autoscaler del cluster Kubernetes di accedere ai servizi e alle risorse OCI:

  • è supportato con cluster avanzati, ma non con cluster di base.
  • è supportato solo con Cluster Autoscaler versione 1.26 (o successiva)

Utilizzo dei principal istanza per abilitare l'accesso ai pool di nodi

È possibile impostare un principal istanza per consentire all'Autoscaler del cluster Kubernetes di eseguire azioni sulle risorse del servizio OCI.

Per impostare un principal istanza:

  1. Eseguire il login a Console.

  2. Creare un nuovo gruppo dinamico a livello di compartimento contenente i nodi di lavoro (istanze di computazione) nel cluster:

    1. Aprire il menu di navigazione e selezionare Identità e sicurezza. In Identità, selezionare Domini. In Dominio di Identity, selezionare Gruppi dinamici.
    2. Selezionare il compartimento contenente il cluster.
    3. Seguire le istruzioni in Per creare un gruppo dinamico e assegnare al gruppo dinamico un nome (ad esempio, acme-oke-cluster-autoscaler-dyn-grp).

    4. Immettere una regola che includa i nodi di lavoro nel compartimento, nel formato seguente:

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

      dove <compartment-ocid> è l'OCID del compartimento a cui appartiene il cluster.

      Ad esempio:

      ALL {instance.compartment.id = 'ocid1.compartment.oc1..aaaaaaaa23______smwa'}
    5. Fare clic su Crea gruppo dinamico.

  3. Creare un criterio per consentire ai nodi di lavoro di gestire i pool di nodi:

    1. Aprire il menu di navigazione e selezionare Identità e sicurezza. In Identità, selezionare Criteri.
    2. Seguire le istruzioni in Per creare un criterio e assegnare un nome al criterio, ad esempio acme-oke-cluster-autoscaler-dyn-grp-policy.

    3. Immettere un'istruzione dei criteri per consentire ai nodi di lavoro di gestire i pool di nodi (insieme ad altre istruzioni dei criteri correlate all'inizializzazione dei nodi di lavoro) nel formato seguente:

      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>

      Dove:

      • <dynamic-group-name> è il nome del gruppo dinamico creato in precedenza. Ad esempio, acme-oke-cluster-autoscaler-dyn-grp. Si noti che se un gruppo dinamico non si trova nel dominio di identità predefinito, anteporre al nome del gruppo dinamico il nome del dominio di identità nel formato dynamic-group '<identity-domain-name>'/'<dynamic-group-name>'. È inoltre possibile specificare il gruppo dinamico utilizzando il relativo OCID, nel formato dynamic-group id <dynamic-group-ocid>.
      • <compartment-name> è il nome del compartimento a cui appartiene il cluster. Ad esempio, acme-oke-cluster-autoscaler-compartment

      Ad esempio:

      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. Fare clic su Crea per creare il nuovo criterio.
    Nota

    Se un pool di nodi appartiene a un compartimento e le risorse di rete utilizzate dal pool di nodi appartengono a un altro compartimento, è necessario creare criteri in entrambi i compartimenti come indicato di seguito.

    • Nel compartimento del pool di nodi creare un criterio con istruzioni criteri nel formato seguente:

      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>

    • Nel compartimento delle risorse di rete, creare un criterio con istruzioni criterio nel formato seguente:

      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>

Utilizzo delle identità del carico di lavoro per abilitare l'accesso ai pool di nodi

È possibile impostare un principal di identità del carico di lavoro per consentire all'Autoscaler del cluster Kubernetes di eseguire azioni sulle risorse del servizio OCI. Tenere presente che è possibile utilizzare solo le identità dei carichi di lavoro con cluster avanzati.

Per impostare un principal di identità del carico di lavoro, effettuare le operazioni riportate di seguito.

  1. Ottenere l'OCID del cluster (ad esempio, utilizzando la scheda Dettagli cluster nella console).
  2. Aprire il menu di navigazione e selezionare Identità e sicurezza. In Identità, selezionare Criteri.
  3. Seguire le istruzioni in Creazione di un criterio e assegnare un nome al criterio, ad esempio acme-oke-cluster-autoscaler-policy.

  4. Immettere le istruzioni dei criteri per consentire la gestione del pool di nodi nel formato seguente:

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

    Dove:

    • <compartment-name> è il nome del compartimento a cui appartiene il cluster. Ad esempio, acme-oke-cluster-autoscaler-compartment
    • <cluster-ocid> è l'OCID del cluster ottenuto in precedenza.

    Ad esempio:

    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. Fare clic su Crea per creare il nuovo criterio.
Nota

Se un pool di nodi appartiene a un compartimento e le risorse di rete utilizzate dal pool di nodi appartengono a un altro compartimento, è necessario creare criteri in entrambi i compartimenti come indicato di seguito.

  • Nel compartimento del pool di nodi creare un criterio con istruzioni criteri nel formato seguente:

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

  • Nel compartimento delle risorse di rete, creare un criterio con istruzioni criterio nel formato seguente:

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

Passo 2: copiare e personalizzare il file di configurazione di Cluster Autoscaler

Passo 2a: copiare il file di configurazione

  1. In un editor di testo, creare un file denominato cluster-autoscaler.yaml con il seguente contenuto:

    ---
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. Salvare il file cluster-autoscaler.yaml creato.

Passo 2b: specificare i pool di nodi da gestire

Nel file cluster-autoscaler.yaml creato, specificare i pool di nodi del cluster che si desidera gestire dal gestore automatico cluster Kubernetes.

È possibile specificare che si desidera che il gestore automatico cluster Kubernetes gestisca un pool a nodo singolo o più pool di nodi. Si consiglia di disporre sempre di almeno un pool di nodi non gestito da Kubernetes Cluster Autoscaler per eseguire componenti aggiuntivi di cluster critici e per garantire che Kubernetes Cluster Autoscaler non esegua lo scale down dei nodi su cui è in esecuzione. Si noti inoltre che è responsabilità dell'utente ridimensionare manualmente tutti i pool di nodi non specificati nel file di configurazione.

È possibile specificare i pool di nodi che si desidera vengano gestiti da Kubernetes Cluster Autoscaler in uno dei due modi riportati di seguito.

  • È possibile specificare in modo esplicito ogni pool di nodi da gestire, utilizzando il parametro --nodes per specificare l'OCID di ogni pool di nodi.
  • È possibile specificare che l'Autoscaler del cluster Kubernetes deve individuare il pool di nodi (o i pool di nodi) da gestire, utilizzando il parametro --node-group-auto-discovery per specificare le tag corrispondenti. È possibile specificare sia le tag definite che le tag in formato libero. Per ulteriori informazioni sull'aggiunta di tag ai pool di nodi, vedere Applicazione di tag ai pool di nodi. Il gestore automatico cluster Kubernetes gestisce i pool di nodi con tag corrispondenti alle tag specificate. Si noti che il parametro node-group-auto-discovery è supportato con Cluster Autoscaler versione 1.30.3, versione 1.31.1 e versione 1.32.0 e successive.

Non è possibile specificare sia il parametro --nodes che il parametro --node-group-auto-discovery nello stesso file cluster-autoscaler.yaml. I due parametri sono alternative che si escludono a vicenda.

Per utilizzare il parametro --nodes per specificare in modo esplicito i pool di nodi da gestire, procedere come segue.

  1. Nel file cluster-autoscaler.yaml creato, individuare la riga modello seguente:

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

    Il parametro --nodes ha il formato seguente:

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

    Dove:

    • <min-nodes> è il numero minimo di nodi consentiti nel pool di nodi. L'Autoscaler del cluster Kubernetes non ridurrà il numero di nodi al di sotto di questo numero.
    • <max-nodes> è il numero massimo di nodi consentiti nel pool di nodi. L'Autoscaler del cluster Kubernetes non aumenterà il numero di nodi sopra questo numero. Assicurarsi che il numero massimo di nodi specificato non superi i limiti della tenancy per la forma del nodo di lavoro definita per il pool di nodi.
    • <nodepool-ocid> è l'OCID del pool di nodi da gestire.

  2. Modificare il valore del parametro --nodes per specificare:

    • Il numero minimo di nodi consentiti nel pool di nodi. ad esempio 1.
    • Il numero massimo di nodi consentiti nel pool di nodi. ad esempio 5.
    • L'OCID del pool di nodi che si desidera gestire dal gestore automatico del cluster Kubernetes.

    Ad esempio:

    --nodes=1:5:ocid1.nodepool.oc1.iad.aaaaaaaaaeydq...
  3. Se si desidera che l'Autoscaler del cluster Kubernetes gestisca un solo pool di nodi nel cluster, individuare la riga seguente nel file cluster-autoscaler.yaml e rimuoverla:
    - --nodes=1:5:{{ node pool ocid 2 }}
  4. Se si desidera che Kubernetes Cluster Autoscaler gestisca un secondo pool di nodi nel cluster, individuare la riga seguente nel file cluster-autoscaler.yaml e impostare i valori appropriati per il parametro --nodes:
    - --nodes=1:5:{{ node pool ocid 2 }}
  5. Se si desidera che l'Autoscaler del cluster Kubernetes gestisca più pool di nodi, inserire ulteriori parametri --nodes nel file cluster-autoscaler.yaml e impostare i valori appropriati.
  6. Salvare il file cluster-autoscaler.yaml.

Per utilizzare il parametro --node-group-auto-discovery per specificare che l'Autoscaler del cluster Kubernetes deve individuare i pool di nodi da gestire, procedere come segue.

  1. Nel file cluster-autoscaler.yaml creato, individuare la riga modello seguente:

    - --nodes=1:5:{{ node pool ocid 1 }}
  2. Eliminare l'intera riga specificando il parametro --nodes e sostituirlo con la riga seguente:
    - --node-group-auto-discovery=clusterId:{{ cluster ocid }},compartmentId:{{ compartment ocid }},nodepoolTags:{{ tagKey1 }}={{ tagValue1 }}&{{ tagKey2 }}={{ tagValue2 }},min:{{ min }},max:{{ max }}

    Il parametro --node-group-auto-discovery ha il formato seguente:

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

    Dove:

    • <cluster-ocid> è il cluster in cui eseguire Kubernetes Cluster Autoscaler.
    • <compartment-ocid> è l'OCID del compartimento in cui si trova il pool di nodi.
    • {{<tagKey1>}}={{<tagValue1>}} specifica il nome della prima tag corrispondente e il valore della tag corrispondente.
    • {{<tagKey2>}}={{<tagValue2>}} specifica facoltativamente il nome di una seconda tag da abbinare e il valore di tale tag da abbinare. È possibile specificare il numero di tag desiderato (non si è limitati a due). Se si specificano più tag, tutte le tag devono corrispondere.
    • <min-nodes> è il numero minimo di nodi consentiti nel pool di nodi. L'Autoscaler del cluster Kubernetes non ridurrà il numero di nodi al di sotto di questo numero.
    • <max-nodes> è il numero massimo di nodi consentiti nel pool di nodi. L'Autoscaler del cluster Kubernetes non aumenterà il numero di nodi sopra questo numero. Assicurarsi che il numero massimo di nodi specificato non superi i limiti della tenancy per la forma del nodo di lavoro definita per il pool di nodi.

  3. Modificare il valore del parametro --node-group-auto-discovery per specificare:

    • Cluster in cui eseguire l'Autoscaler del cluster Kubernetes.
    • OCID del compartimento in cui si trova il pool di nodi.
    • Uno o più nomi di tag e valori di tag corrispondenti.
    • Numero minimo di nodi consentiti nel pool di nodi. ad esempio 1.
    • Numero massimo di nodi consentiti nel pool di nodi. ad esempio 5.

    Ad esempio:

    --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. Individuare la riga seguente nel file cluster-autoscaler.yaml e rimuoverla:
    - --nodes=1:5:{{ node pool ocid 2 }}
  5. Se si desidera che Kubernetes Cluster Autoscaler gestisca più pool di nodi, in compartimenti diversi, con nomi di tag e valori di tag diversi o con numeri minimi e massimi diversi di nodi consentiti, inserire parametri --node-group-auto-discovery aggiuntivi nel file cluster-autoscaler.yaml e impostare i valori appropriati.

    Ad esempio:

    --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. Salvare il file cluster-autoscaler.yaml.

Passo 2c: includere impostazioni di configurazione aggiuntive

  1. Nel file cluster-autoscaler.yaml creato, aggiungere le variabili di ambiente per specificare la modalità di impostazione dell'Autoscaler del cluster Kubernetes per accedere ai servizi e alle risorse OCI:
    • Se è stato impostato un principal istanza per consentire all'Autoscaler del cluster Kubernetes di accedere ai servizi e alle risorse OCI, dopo la riga imagePullPolicy: "Always" alla fine del file aggiungere quanto segue:
                env:
          - name: OKE_USE_INSTANCE_PRINCIPAL
            value: "true"
          - name: OCI_SDK_APPEND_USER_AGENT
            value: "oci-oke-cluster-autoscaler"

      Ad esempio:

      ...
          imagePullPolicy: "Always"
          env:
          - name: OKE_USE_INSTANCE_PRINCIPAL
            value: "true"
          - name: OCI_SDK_APPEND_USER_AGENT
            value: "oci-oke-cluster-autoscaler"
    • Se è stato impostato un principal di identità del carico di lavoro per consentire all'Autoscaler del cluster Kubernetes di accedere ai servizi e alle risorse OCI, dopo la riga imagePullPolicy: "Always" alla fine del file aggiungere quanto segue:
                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"

      dove <cluster-region> è l'area in cui si trova il cluster.

      Ad esempio:

      ...
          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. Nel file cluster-autoscaler.yaml creato, confermare che il parametro --cloud-provider sia impostato correttamente per la versione di Kubernetes in esecuzione nel cluster. Per impostazione predefinita, il parametro presuppone che il cluster stia eseguendo Kubernetes versione 1.27 o successiva (o 1.23 o precedente) ed è impostato su oci. Se il cluster esegue Kubernetes versione 1.26, 1.25 o 1.24, modificare il valore del parametro --cloud-provider in oci-oke:

    1. Nel file cluster-autoscaler.yaml individuare la riga seguente:

      - --cloud-provider=oci
    2. Se il cluster esegue Kubernetes versione 1.26, 1.25 o 1.24, modificare il valore del parametro --cloud-provider in oci-oke:
      - --cloud-provider=oci-oke
    3. Salvare il file cluster-autoscaler.yaml.
  3. Nel file cluster-autoscaler.yaml creato, modificare il percorso immagine dell'immagine Autoscaler del cluster Kubernetes da scaricare da Oracle Cloud Infrastructure Registry. Le immagini sono disponibili in diverse aree. Per ottenere le prestazioni migliori, scegliere l'area più vicina a quella in cui viene distribuito il cluster:

    1. Nel file cluster-autoscaler.yaml individuare la riga modello seguente:

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

    2. Modificare il percorso dell'immagine in base alla posizione e alla versione Kubernetes del cluster in cui eseguire l'Autoscaler del cluster Kubernetes:

      Posizione immagine Versione Kubernetes Percorso immagine
      Germania (centrale) - Francoforte Kubernetes 1.30 fra.ocir.io/oracle/oci-cluster-autoscaler:1.30.4-3
      Germania (centrale) - Francoforte Kubernetes 1.31 fra.ocir.io/oracle/oci-cluster-autoscaler:1.31.2-1
      Germania (centrale) - Francoforte Kubernetes 1.32 fra.ocir.io/oracle/oci-cluster-autoscaler:1.32.1-1
      Germania (centrale) - Francoforte Kubernetes 1.33 fra.ocir.io/oracle/oci-cluster-autoscaler:1.32.1-1
      Regno Unito - Sud (Londra) Kubernetes 1.30 lhr.ocir.io/oracle/oci-cluster-autoscaler:1.30.4-3
      Regno Unito - Sud (Londra) Kubernetes 1.31 lhr.ocir.io/oracle/oci-cluster-autoscaler:1.31.2-1
      Regno Unito - Sud (Londra) Kubernetes 1.32 lhr.ocir.io/oracle/oci-cluster-autoscaler:1.32.1-1
      Regno Unito - Sud (Londra) Kubernetes 1.33 lhr.ocir.io/oracle/oci-cluster-autoscaler:1.32.1-1
      Stati Uniti (Est) - Ashburn Kubernetes 1.30 iad.ocir.io/oracle/oci-cluster-autoscaler:1.30.4-3
      Stati Uniti (Est) - Ashburn Kubernetes 1.31 iad.ocir.io/oracle/oci-cluster-autoscaler:1.31.2-1
      Stati Uniti (Est) - Ashburn Kubernetes 1.32 iad.ocir.io/oracle/oci-cluster-autoscaler:1.32.1-1
      Stati Uniti (Est) - Ashburn Kubernetes 1.33 iad.ocir.io/oracle/oci-cluster-autoscaler:1.32.1-1
      Stati Uniti/Ovest (Phoenix) Kubernetes 1.30 phx.ocir.io/oracle/oci-cluster-autoscaler:1.30.4-3
      Stati Uniti/Ovest (Phoenix) Kubernetes 1.31 phx.ocir.io/oracle/oci-cluster-autoscaler:1.31.2-1
      Stati Uniti/Ovest (Phoenix) Kubernetes 1.32 phx.ocir.io/oracle/oci-cluster-autoscaler:1.32.1-1
      Stati Uniti/Ovest (Phoenix) Kubernetes 1.33 phx.ocir.io/oracle/oci-cluster-autoscaler:1.32.1-1

      Ad esempio, se si desidera eseguire il cluster Kubernetes Autoscaler in un cluster Kubernetes 1.32 situato nell'area meridionale del Regno Unito, specificare l'immagine seguente:

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

      Se si desidera distribuire l'Autoscaler del cluster Kubernetes in un cluster Kubernetes che non si trova nella stessa area di uno qualsiasi dei repository Oracle contenenti immagini Cluster Autoscaler, è consigliabile eseguire il PUSH dell'immagine in un repository che si trova nella stessa area del cluster, come indicato di seguito.

      c. Estrarre l'immagine da un repository Oracle utilizzando il comando docker pull. Vedere Pulling Images Using the Docker CLI.

      ii. Contrassegnare l'immagine (utilizzando il comando docker tag), quindi eseguire il PUSH dell'immagine in un repository in Oracle Cloud Infrastructure Registry che si trova nella stessa area del cluster in cui si desidera eseguire il Cluster Autoscaler Kubernetes (utilizzando il comando docker push). Vedere Push delle immagini mediante l'interfaccia CLI Docker.

      iii. Specificare la posizione dell'immagine nel file cluster-autoscaler.yaml.

      Nota

      Se si desidera distribuire l'Autoscaler del cluster Kubernetes in un cluster Kubernetes in cui è stata abilitata la verifica delle immagini, non specificare semplicemente un percorso di immagine da uno dei repository Oracle nel file cluster-autoscaler.yaml. In alternativa, effettuare le operazioni riportate di seguito.

      c. Estrarre l'immagine da un repository Oracle utilizzando il comando docker pull. Vedere Pulling Images Using the Docker CLI.

      ii. Contrassegnare l'immagine (utilizzando il comando docker tag), quindi eseguire il PUSH dell'immagine in un repository in Oracle Cloud Infrastructure Registry che si trova nella stessa area del cluster in cui si desidera eseguire il Cluster Autoscaler Kubernetes (utilizzando il comando docker push). Vedere Push delle immagini mediante l'interfaccia CLI Docker.

      iii. Firma l'immagine utilizzando una chiave master e una versione della chiave nel servizio Vault, creando una firma dell'immagine. Vedere Firma di immagini per la sicurezza.

      iv. Specificare la posizione dell'immagine firmata nel file cluster-autoscaler.yaml. Fare riferimento all'immagine utilizzando il digest immagine anziché il tag immagine (vedere Applicazione dell'uso delle immagini firmate dal registro).

    3. Salvare il file cluster-autoscaler.yaml.

  4. Nel file cluster-autoscaler.yaml creato, verificare che i valori predefiniti dei parametri CPU e limite di memoria siano sufficienti per il numero di pool di nodi che si desidera gestire da parte di Kubernetes Cluster Autoscaler. I limiti predefiniti sono relativamente bassi, pertanto è consigliabile aumentare i limiti se si desidera che l'Autoscaler del cluster Kubernetes gestisca un numero elevato di pool di nodi. Si noti che è responsabilità dell'utente impostare i limiti sui valori appropriati.

    1. Nel file cluster-autoscaler.yaml individuare le righe seguenti:

                resources:
            limits:
              cpu: 100m
              memory: 300Mi
    2. Impostare i limiti di CPU e memoria sui valori appropriati per il numero di pool di nodi che si desidera gestire dal gestore automatico del cluster Kubernetes. Ad esempio:
                resources:
            limits:
              cpu: 200m
              memory: 600Mi
    3. Salvare il file cluster-autoscaler.yaml.

  5. Nel file cluster-autoscaler.yaml creato, specificare altri parametri per l'Autoscaler del cluster Kubernetes. Per informazioni sui parametri che è possibile impostare, vedere Parametri Autoscaler del cluster Kubernetes supportati.

  6. Salvare e chiudere il file cluster-autoscaler.yaml.

Passo 3: distribuire l'Autoscaler del cluster Kubernetes nel cluster e confermare la distribuzione riuscita

  1. Se non è già stato fatto, attenersi alla procedura per impostare il file di configurazione kubeconfig del cluster e (se necessario) impostare la variabile di ambiente KUBECONFIG in modo che punti al file. Si noti che è necessario impostare il proprio file kubeconfig. Non è possibile accedere a un cluster utilizzando un file kubeconfig impostato da un altro utente. Vedere Impostazione dell'accesso al cluster.
  2. Distribuire Kubernetes Cluster Autoscaler sul cluster immettendo:
    kubectl apply -f cluster-autoscaler.yaml
  3. Visualizzare i log di Kubernetes Cluster Autoscaler per confermare che la distribuzione è riuscita e che attualmente sta monitorando il carico di lavoro dei pool di nodi nel cluster, immettendo:
    kubectl -n kube-system logs -f deployment.apps/cluster-autoscaler
  4. Identificare quale dei tre pod Kubernetes Cluster Autoscaler definiti nel file cluster-autoscaler.yaml sta attualmente eseguendo le azioni immettendo:
    kubectl -n kube-system get lease
  5. Ottenere una vista di alto livello dello stato di Kubernetes Cluster Autoscaler dalla mappa di configurazione nello spazio di nomi kube-system, immettendo:
    kubectl -n kube-system get cm cluster-autoscaler-status -oyaml

Passo 4: Visualizzare l'operazione di scala

Puoi guardare l'Autoscaler del cluster Kubernetes distribuito mentre ridimensiona automaticamente i nodi di lavoro in un pool di nodi. Per rendere più ovvia l'operazione di ridimensionamento, considera i seguenti suggerimenti (nota che sono solo a scopo di osservazione e potrebbero essere contrari ai suggerimenti mostrati nei raccomandazioni quando si utilizza il ridimensionatore automatico del cluster Kubernetes negli ambienti di produzione):

  • Osservare un cluster con un pool a nodo singolo (il pool di nodi gestito da Kubernetes Cluster Autoscaler).
  • Se il cluster che si desidera osservare dispone di più pool di nodi, limitare l'esecuzione dei pod sui nodi nel pool a nodo singolo gestito da Kubernetes Cluster Autoscaler. Vedere Assegnazione dei pod ai nodi nella documentazione di Kubernetes.
  • Iniziare con un nodo nel pool di nodi gestito da Autoscaler del cluster Kubernetes.
  • Nel file di configurazione Autoscaler del cluster Kubernetes è possibile specificare il numero massimo di nodi consentiti nel pool di nodi. Assicurarsi che il numero massimo di nodi specificato non superi il limite della tenancy per la forma del nodo di lavoro definita per il pool di nodi.

Per visualizzare il ridimensionamento automatico dei nodi di lavoro del cluster Kubernetes:

  1. Confermare il numero totale corrente di nodi di lavoro nel cluster immettendo:
    kubectl get nodes

  2. Definire un'applicazione Nginx di esempio creando un file denominato nginx.yaml in un editor di testo, con il seguente contenuto: 

    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"

    Si noti che è stato impostato un limite di richiesta di risorsa.

  3. Per distribuire l'applicazione di esempio, immettere:
    kubectl create -f nginx.yaml
  4. Aumentare il numero di pod nella distribuzione a 100 (da 2) immettendo:
    kubectl scale deployment nginx-deployment --replicas=100

    Kubernetes Cluster Autoscaler ora aggiunge nodi di lavoro al pool di nodi per soddisfare il carico di lavoro aumentato.

  5. Osservare lo stato della distribuzione immettendo:
    kubectl get deployment nginx-deployment --watch
  6. Dopo alcuni minuti, visualizzare il numero totale aumentato di nodi di lavoro nel cluster immettendo:
    kubectl get nodes

    Si noti che il numero di nodi di lavoro visualizzati dipenderà dalla forma del nodo di lavoro e dal numero massimo di nodi specificati nel file di configurazione Autoscaler del cluster Kubernetes.

Passo 5: eseguire il cleanup

  1. Eliminare l'applicazione Nginx di esempio immettendo:
    kubectl delete deployment nginx-deployment
  2. Dopo dieci minuti, confermare che i nodi di lavoro sono stati ridotti al numero originale immettendo:
    kubectl get nodes

Tenere presente che dopo l'eliminazione dell'applicazione Nginx di esempio e l'attesa, è possibile che vengano visualizzati meno nodi di lavoro, ma comunque più del numero originale. Ciò è probabilmente dovuto al fatto che i pod del sistema kube sono stati programmati per l'esecuzione su tali nodi. I pod del sistema kube possono impedire all'Autoscaler del cluster Kubernetes di rimuovere i nodi perché il parametro skip-nodes-with-system-pods dell'Autoscaler è impostato su true per impostazione predefinita.