Versión 1.15. Ya no se admite esta versión. Si quieres obtener información para actualizar a la versión 1.16, consulta Actualiza clústeres en la documentación más reciente. Para obtener más información sobre las versiones compatibles y no compatibles, consulta la página Historial de versiones en la documentación más reciente.

Configura la programación de VM que reconocen NUMA

En este documento, se describe cómo configurar clústeres y VM para admitir cargas de trabajo de alto rendimiento y baja latencia con las eficiencias de procesamiento del acceso a la memoria no uniforme (NUMA). Hay instrucciones para ajustar la configuración de Kubernetes para los nodos del clúster. En este documento, también se incluyen instrucciones para configurar máquinas virtuales (VM) con afinidad de NUMA a fin de que se programen y aprovechen los nodos de NUMA.

Con una VM que reconoce NUMA, toda la comunicación dentro de esta es local para el nodo de NUMA. La VM con reconocimiento de NUMA evita las transacciones de datos desde y hacia recursos remotos que pueden degradar el rendimiento de la VM.

Configura los nodos para usar NUMA

En las siguientes secciones, se describe cómo configurar los componentes fundamentales de Kubernetes para ajustar el nodo y asegurarse de que pueda programar los contenedores compatibles con NUMA. Estos nodos de NUMA se ajustan para optimizar el rendimiento de la CPU y la memoria. Sigue las instrucciones para cada nodo que desees ejecutar en VMs que reconozcan NUMA.

Actualiza la configuración de kubelet

Como parte de la configuración del nodo para admitir la afinidad de nodo de NUMA, debes realizar los siguientes cambios en la configuración de kubelet:

Habilita el administrador de CPU con una política static
Habilita el administrador de memoria con una política Static
Habilita el Administrador de topologías con la topología restricted

Para configurar kubelet en tu nodo trabajador, sigue estos pasos:

Busca el archivo kubelet en tu nodo trabajador y ábrelo para editarlo:
```
edit /etc/default/kubelet
```
Si no ves el archivo kubelet, créalo con el siguiente comando:
```
echo "KUBELET_EXTRA_ARGS=\"\"" >> /etc/default/kubelet
```
Este comando crea el archivo kubelet con una sección KUBELET_EXTRA_ARGS="" vacía.
Para habilitar el administrador de CPU con una política static, agrega la marca --cpu-manager-policy=static a la sección KUBELET_EXTRA_ARGS="" del archivo:
```
KUBELET_EXTRA_ARGS="--cpu-manager-policy=static"
```
Para habilitar el administrador de memoria con una política Static, agrega la marca --memory-manager-policy=Static a la sección KUBELET_EXTRA_ARGS="" del archivo:
```
KUBELET_EXTRA_ARGS="--cpu-manager-policy=static --memory-manager-policy=Static"
```
Para habilitar el Administrador de topologías con una política restricted, agrega la marca --topology-manager-policy=restricted a la sección KUBELET_EXTRA_ARGS="" del archivo:
```
KUBELET_EXTRA_ARGS="--cpu-manager-policy=static --memory-manager-policy=Static --topology-manager-policy=restricted"
```

Verifica la cantidad actual de memoria reservada por GKE en Bare Metal:

cat /var/lib/kubelet/kubeadm-flags.env

El resultado debe tener el siguiente aspecto:

KUBELET_KUBEADM_ARGS="--anonymous-auth=false --authentication-token-webhook=true --authorization-mode=Webhook --container-runtime=remote --container-runtime-endpoint=unix:///run/containerd/containerd.sock --feature-gates=SeccompDefault=true --kube-reserved=cpu=100m,memory=3470Mi --max-pods=110 --node-ip=192.168.1.190 --node-labels=baremetal.cluster.gke.io/k8s-ip=192.168.1.190,baremetal.cluster.gke.io/namespace=cluster-user001,baremetal.cluster.gke.io/node-pool=node-pool-1,cloud.google.com/gke-nodepool=node-pool-1 --pod-infra-container-image=gcr.io/anthos-baremetal-release/pause-amd64:3.1-gke.5 --provider-id=baremetal://192.168.1.190 --read-only-port=10255 --rotate-server-certificates=true --seccomp-default=true"

El parámetro de configuración --kube-reserved=cpu=100m,memory=3470Mi indica que GKE en Bare Metal reservó 3,470 mebibytes de memoria en el nodo.

Establece la marca --reserved-memory en la sección KUBELET_EXTRA_ARGS del archivo kubelet en 100 mebibytes más que la memoria reservada actual para tener en cuenta el umbral de expulsión. Si no hay memoria reservada, puedes omitir este paso.

Por ejemplo, con la memoria reservada de 3470Mi del ejemplo del paso anterior, reservas 3570Mi de memoria en el archivo kubelet:
```
KUBELET_EXTRA_ARGS="--cpu-manager-policy=static --memory-manager-policy=Static --topology-manager-policy=restricted --reserved-memory=0:memory=3570Mi"
```
Quita los archivos de estado de CPU y memoria del directorio /var/lib:
```
rm /var/lib/cpu_manager_state
rm /var/lib/memory_manager_state
```
Reinicia kubelet:
```
systemctl start kubelet
```

Para obtener más información sobre estas configuraciones de políticas, consulta la siguiente documentación de Kubernetes:

Configura el nodo para usar largepages

Una vez que hayas habilitado el Administrador de memoria con la política Static, puedes agregar páginas enormes para mejorar aún más el rendimiento de la carga de trabajo del contenedor en tus nodos de NUMA. Largepages, como su nombre lo indica, te permite especificar páginas de memoria que son más grandes que el estándar de 4 kibibyte (KiB). El entorno de ejecución de VM en GDC admite grandes páginas de 2 mebibyte (MiB) y 1 gibibyte (GiB). Puedes configurar largepages para un nodo en el entorno de ejecución o para cuando se inicia la máquina. Recomendamos que configures grandes páginas en cada nodo en el que desees ejecutar VM compatibles con NUMA.

Para configurar la cantidad de bigpages de un tamaño específico en tu nodo NUMA en el entorno de ejecución, usa el siguiente comando:
```
echo HUGEPAGE_QTY > \
    /sys/devices/system/node/NUMA_NODE/hugepages/hugepages-HUGEPAGE_SIZEkB/nr_hugepages
```
Reemplaza lo siguiente:
- HUGEPAGE_QTY: Es la cantidad de páginas grandes que se asignarán del tamaño especificado.
- NUMA_NODE: Es el nodo de NUMA, como node0, al que le asignarás bigpages.
- HUGEPAGE_SIZE: Es el tamaño de las páginas gigantes en kibibytes, 2048 (2 MiB) o 1048576 (1 GiB).

Configurar una VM para usar el nodo de NUMA

Una vez que los nodos del clúster estén ajustados para NUMA, puedes crear VMs que reconozcan NUMA. Las VMs que reconocen NUMA se programan en nodos de NUMA.

Para crear una VM compatible con NUMA, sigue estos pasos:

Sigue las instrucciones para crear una VM a partir de un manifiesto.

Usa la siguiente configuración de compute para configurar tu VM de modo que sea compatible con NUMA:
- spec.compute.guaranteed: Establece guaranteed en true. Con esta configuración, el Pod virt-launcher se configura para que se coloque en la clase de Calidad de servicio (QoS) garantizada de Kubernetes.
- spec.compute.advancedCompute:
  - dedicatedCPUPlacement: Establece dedicatedCPUPlacement en true. Esta configuración fija las CPU virtuales a las CPU físicas del nodo.
  - hugePageSize: Configura hugePageSize como 2Mi o 1Gi para especificar el tamaño de bigpages que usará tu VM, 2 mebibyte o 1 gibibyte.
  - numaGuestMappingPassthrough: Incluye una estructura vacía ({}) para este parámetro de configuración. Esta configuración establece la afinidad de NUMA para que la VM se programe solo en los nodos de NUMA.
En el siguiente manifiesto de ejemplo de VirtualMachine, se muestra cómo podría verse una configuración de VM compatible con NUMA:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: vm1
spec:
  compute:
    cpu:
      vcpus: 2
    guaranteed: true
    advancedCompute:
      dedicatedCPUPlacement: true
      hugePageSize: 2Mi
      numaGuestMappingPassthrough: {}
    memory:
      capacity: 256Mi
  interfaces:
  - name: eth0
    networkName: pod-network
    default: true
  disks:
  - virtualMachineDiskName: disk-from-gcs
    boot: true
    readOnly: true
```