Trabajo con la escala automática del cluster como programa independiente

1. En un editor de texto, cree un archivo llamado cluster-autoscaler.yaml con el siguiente contenido:

   ---
   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"]
       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"
             env:
             - name: OKE_USE_INSTANCE_PRINCIPAL
               value: "true"
             - name: OCI_SDK_APPEND_USER_AGENT
               value: "oci-oke-cluster-autoscaler"

2. En el archivo cluster-autoscaler.yaml que ha creado, confirme que el parámetro --cloud-provider está definido correctamente para la versión de Kubernetes que se ejecuta en el cluster. Por defecto, el parámetro asume que el cluster está ejecutando la versión 1.27 o posterior de Kubernetes (o 1.23 o anterior) y está definido en oci. Si el cluster está ejecutando la versión 1.26, 1.25 o 1.24 de Kubernetes, cambie el valor del parámetro --cloud-provider a oci-oke:

   1. En el archivo cluster-autoscaler.yaml, busque la siguiente línea:

      - --cloud-provider=oci

   2. Si el cluster está ejecutando la versión 1.26, 1.25 o 1.24 de Kubernetes, cambie el valor del parámetro --cloud-provider a oci-oke:

      - --cloud-provider=oci-oke

   3. Guarde el archivo cluster-autoscaler.yaml.
3. En el archivo cluster-autoscaler.yaml que ha creado, cambie la ruta de imagen de la imagen de la escala automática del cluster de Kubernetes que se va a descargar desde Oracle Cloud Infrastructure Registry. Las imágenes están disponibles en varias regiones. Para obtener el mejor rendimiento, seleccione la región más próxima a la ubicación en la que se ha desplegado el cluster:

   1. En el archivo cluster-autoscaler.yaml, busque la siguiente línea de plantilla:

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

   2. Cambie la ruta de imagen a una de las siguientes, según la ubicación y la versión de Kubernetes del cluster en el que se va a ejecutar la escala automática del cluster de Kubernetes:

      Ubicación de Imagen	Versión de Kubernetes	Ruta de la imagen
      Centro de Alemania (Fráncfort)	Kubernetes 1.27	fra.ocir.io/oracle/oci-cluster-autoscaler:1.27.2-9
      Centro de Alemania (Fráncfort)	Kubernetes 1.28	fra.ocir.io/oracle/oci-cluster-autoscaler:1.28.2-3
      Centro de Alemania (Fráncfort)	Kubernetes en 1.29	fra.ocir.io/oracle/oci-cluster-autoscaler:1.29.0-10
      Centro de Alemania (Fráncfort)	Kubernetes 1.30	fra.ocir.io/oracle/oci-cluster-autoscaler:1.30.1-2
      Sur del Reino Unido (Londres)	Kubernetes 1.27	lhr.ocir.io/oracle/oci-cluster-autoscaler:1.27.2-9
      Sur del Reino Unido (Londres)	Kubernetes 1.28	lhr.ocir.io/oracle/oci-cluster-autoscaler:1.28.2-3
      Sur del Reino Unido (Londres)	Kubernetes en 1.29	lhr.ocir.io/oracle/oci-cluster-autoscaler:1.29.0-10
      Sur del Reino Unido (Londres)	Kubernetes 1.30	lhr.ocir.io/oracle/oci-cluster-autoscaler:1.30.1-2
      Este de Estados Unidos (Ashburn)	Kubernetes 1.27	iad.ocir.io/oracle/oci-cluster-autoscaler:1.27.2-9
      Este de Estados Unidos (Ashburn)	Kubernetes 1.28	iad.ocir.io/oracle/oci-cluster-autoscaler:1.28.2-3
      Este de Estados Unidos (Ashburn)	Kubernetes en 1.29	iad.ocir.io/oracle/oci-cluster-autoscaler:1.29.0-10
      Este de Estados Unidos (Ashburn)	Kubernetes 1.30	iad.ocir.io/oracle/oci-cluster-autoscaler:1.30.1-2
      Oeste de Estados Unidos (Phoenix)	Kubernetes 1.27	phx.ocir.io/oracle/oci-cluster-autoscaler:1.27.2-9
      Oeste de Estados Unidos (Phoenix)	Kubernetes 1.28	phx.ocir.io/oracle/oci-cluster-autoscaler:1.28.2-3
      Oeste de Estados Unidos (Phoenix)	Kubernetes en 1.29	phx.ocir.io/oracle/oci-cluster-autoscaler:1.29.0-10
      Oeste de Estados Unidos (Phoenix)	Kubernetes 1.30	phx.ocir.io/oracle/oci-cluster-autoscaler:1.30.1-2

      Por ejemplo, si desea ejecutar la escala automática del clúster de Kubernetes en un clúster Kubernetes 1.30 ubicado en la región Sur del Reino Unido, especifique la siguiente imagen:

      - image: lhr.ocir.io/oracle/oci-cluster-autoscaler:1.30.1-2

      Consejo
      
      

      Si desea desplegar la escala automática del cluster de Kubernetes en un cluster de Kubernetes que no esté en la misma región que cualquiera de los repositorios de Oracle que contienen imágenes de escala automática de cluster, recomendamos transferir la imagen a un repositorio que esté en la misma región que el cluster, de la siguiente manera:

      i. Extraiga la imagen de un repositorio de Oracle con el comando docker pull. Consulte Extracción de imágenes con la CLI de Docker.

      ii. Etiquete la imagen (con el comando docker tag) y, a continuación, transfiera la imagen a un repositorio de Oracle Cloud Infrastructure Registry que esté en la misma región que el cluster en el que desea ejecutar la escala automática del cluster de Kubernetes (con el comando docker push). Consulte Transferencia de imágenes con la CLI de Docker.

      iii. Especifique la ubicación de la imagen en el archivo cluster-autoscaler.yaml.

      Nota
      
      

      Si desea desplegar la escala automática del cluster de Kubernetes en un cluster de Kubernetes con la verificación de imágenes activada, no especifique simplemente una ruta de imagen de uno de los repositorios de Oracle en el archivo cluster-autoscaler.yaml. En su lugar, haga lo siguiente:

      i. Extraiga la imagen de un repositorio de Oracle con el comando docker pull. Consulte Extracción de imágenes con la CLI de Docker.

      ii. Etiquete la imagen (con el comando docker tag) y, a continuación, transfiera la imagen a un repositorio de Oracle Cloud Infrastructure Registry que esté en la misma región que el cluster en el que desea ejecutar la escala automática del cluster de Kubernetes (con el comando docker push). Consulte Transferencia de imágenes con la CLI de Docker.

      iii. Firme la imagen con una clave maestra y una versión de clave en el servicio Vault, creando una firma de imagen. Consulte Firma de imágenes por seguridad.

      iv. Especifique la ubicación de la imagen firmada en el archivo cluster-autoscaler.yaml. Haga referencia a la imagen mediante el resumen de imagen en lugar de la etiqueta de imagen (consulte Aplicación del uso de imágenes firmadas del registro).

   3. Guarde el archivo cluster-autoscaler.yaml.

4. En el archivo cluster-autoscaler.yaml que ha creado, especifique cada uno de los pools de nodos del cluster que desea que gestione la escala automática del cluster de Kubernetes.

   Puede especificar varios pools de nodos en el archivo cluster-autoscaler.yaml. Tenga en cuenta que la recomendación es que siempre debe tener al menos un pool de nodos que no esté gestionado por la escala automática del cluster de Kubernetes. Tenga en cuenta también que es su responsabilidad escalar manualmente los pools de nodos que no especifique en el archivo de configuración.

   1. En el archivo cluster-autoscaler.yaml, busque la siguiente línea de plantilla:

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

      El parámetro --nodes tiene el siguiente formato:

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

      donde:

      • <min-nodes> es el número mínimo de nodos permitido en el pool de nodos. La escala automática del cluster de Kubernetes no reducirá el número de nodos por debajo de este número.
      • <max-nodes> es el número máximo de nodos permitido en el pool de nodos. La escala automática del cluster de Kubernetes no aumentará el número de nodos por encima de este número. Asegúrese de que el número máximo de nodos especificado no exceda los límites de arrendamiento de la unidad de nodo de trabajador definida para el pool de nodos.
      • <nodepool-ocid> es el OCID de un pool de nodos o más.

   2. Cambie el valor del parámetro --nodes para especificar:

      • Número mínimo de nodos permitido en el pool de nodos. Por ejemplo, 1.
      • Número máximo de nodos permitido en el pool de nodos. Por ejemplo, 5.
      • El OCID del pool de nodos que desea que gestione la escala automática del cluster de Kubernetes.

      Por ejemplo:

      --nodes=1:5:ocid1.nodepool.oc1.iad.aaaaaaaaaeydq...

   3. Si solo desea que la escala automática del cluster de Kubernetes gestione un pool de nodos en el cluster, busque la siguiente línea en el archivo cluster-autoscaler.yaml y elimínela:

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

   4. Si desea que la escala automática del cluster de Kubernetes gestione un segundo pool de nodos en el cluster, busque la siguiente línea en el archivo cluster-autoscaler.yaml y defina los valores adecuados para el parámetro --nodes:

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

   5. Si desea que la escala automática del cluster de Kubernetes gestione más pools de nodos, inserte parámetros --nodes adicionales en el archivo cluster-autoscaler.yaml y defina los valores adecuados para ellos.
   6. Guarde el archivo cluster-autoscaler.yaml.

5. En el archivo cluster-autoscaler.yaml que ha creado, confirme que los valores por defecto de los parámetros de límite de CPU y memoria son suficientes para el número de pools de nodos que desea que gestione la escala automática del cluster de Kubernetes. Los límites por defecto son relativamente bajos, así que considere aumentar los límites si desea que la escala automática del cluster de Kubernetes gestione un gran número de pools de nodos. Tenga en cuenta que es su responsabilidad establecer los límites en valores adecuados.

   1. En el archivo cluster-autoscaler.yaml, busque las siguientes líneas:

                resources:
                  limits:
                    cpu: 100m
                    memory: 300Mi

   2. Defina los límites de CPU y memoria en los valores adecuados para el número de pools de nodos que desea que gestione la escala automática del cluster de Kubernetes. Por ejemplo:

                resources:
                  limits:
                    cpu: 200m
                    memory: 600Mi

   3. Guarde el archivo cluster-autoscaler.yaml.

6. En el archivo cluster-autoscaler.yaml que ha creado, especifique otros parámetros para la escala automática del cluster de Kubernetes. Para obtener información sobre los parámetros que puede definir, consulte Parámetros de la escala automática del cluster de Kubernetes soportados.

7. Guarde y cierre el archivo cluster-autoscaler.yaml.

1. Si todavía no lo ha hecho, siga los pasos para configurar el archivo de configuración kubeconfig del cluster y (si es necesario) defina la variable de entorno KUBECONFIG para que apunte al archivo. Tenga en cuenta que debe configurar su propio archivo kubeconfig. No puede acceder a un cluster utilizando un archivo kubeconfig que haya configurado un usuario diferente. Consulte Configuración del acceso a los clusters.
2. Despliegue la escala automática del cluster de Kubernetes en el cluster introduciendo:

   kubectl apply -f cluster-autoscaler.yaml

3. Consulte los logs de la escala automática del cluster de Kubernetes para confirmar que se ha desplegado correctamente y supervisa actualmente la carga de trabajo de los pools de nodos en el cluster introduciendo:

   kubectl -n kube-system logs -f deployment.apps/cluster-autoscaler

4. Identifique cuál de los tres pods de la escala automática del cluster de Kubernetes definidos en el archivo cluster-autoscaler.yaml está realizando actualmente acciones introduciendo:

   kubectl -n kube-system get lease

5. Obtenga una vista de nivel superior del estado de escala automática del cluster de Kubernetes del mapa de configuración en el espacio de nombre kube-system introduciendo:

   kubectl -n kube-system get cm cluster-autoscaler-status -oyaml

Puede ver la escala automática del cluster de Kubernetes que ha desplegado cuando escala automáticamente los nodos de trabajador en un pool de nodos. Para que la operación de escala sea más obvia, tenga en cuenta las siguientes sugerencias (tenga en cuenta que estas son solo para fines de observación y pueden ser contrarias a las recomendaciones que se muestran en Recomendaciones al utilizar la escala automática del cluster de Kubernetes en entornos de producción):

• Observe un cluster que tenga un único pool de nodos (el pool de nodos que gestiona la escala automática del cluster de Kubernetes).
• Si el cluster que desea observar tiene más de un pool de nodos, restrinja los pods para que se ejecuten en nodos del pool de nodos único que gestiona la escala automática del cluster de Kubernetes. Consulte Asignación de pods a nodos en la documentación de Kubernetes.
• Comience con un nodo del pool de nodos que gestiona la escala automática del cluster de Kubernetes.
• En el archivo de configuración de la escala automática del cluster de Kubernetes, especifique el número máximo de nodos permitidos en el pool de nodos. Asegúrese de que el número máximo de nodos especificado no exceda el límite de arrendamiento de la unidad de nodo de trabajador definida para el pool de nodos.

Para ver la escala automática del cluster de Kubernetes escalando automáticamente los nodos de trabajador:

1. Confirme el número total actual de nodos de trabajador en el cluster introduciendo:

   kubectl get nodes

2. Defina una aplicación Nginx de ejemplo creando un archivo denominado nginx.yaml en un editor de texto con el siguiente contenido:

   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"

   Tenga en cuenta que se ha definido un límite de solicitud de recurso.

3. Despliegue la aplicación de ejemplo introduciendo:

   kubectl create -f nginx.yaml

4. Aumente el número de pods en el despliegue a 100 (de 2) introduciendo:

   kubectl scale deployment nginx-deployment --replicas=100

   La escala automática del cluster de Kubernetes ahora agrega nodos de trabajador al pool de nodos para satisfacer el aumento de la carga de trabajo.

5. Observe el estado del despliegue introduciendo:

   kubectl get deployment nginx-deployment --watch

6. Después de unos minutos, visualice el número total de nodos de trabajador aumentado en el cluster introduciendo:

   kubectl get nodes

   Tenga en cuenta que el número de nodos de trabajador que verá dependerá de la unidad del nodo de trabajador y del número máximo de nodos especificados en el archivo de configuración de la escala automática del cluster de Kubernetes.

1. Suprima la aplicación Nginx de ejemplo introduciendo:

   kubectl delete deployment nginx-deployment

2. Después de diez minutos, confirme que los nodos de trabajador se han reducido al número original introduciendo:

   kubectl get nodes

Tenga en cuenta que después de suprimir la aplicación Nginx de ejemplo y esperar, puede que vea menos nodos de trabajador, pero aun así, más que el número original. Probablemente se deba a que los pods kube-system se han programado para ejecutarse en esos nodos. Los pods kube-system pueden evitar que la escala automática del cluster de Kubernetes elimine nodos porque el parámetro skip-nodes-with-system-pods de la escala automática está definido en true por defecto.