Programar máquinas virtuales que usen el tiempo de ejecución de máquinas virtuales en GDC

Este documento está dirigido a los propietarios de aplicaciones y a los administradores de plataformas que ejecutan Google Distributed Cloud. En este documento se explica cómo usar configuraciones de programación, como la afinidad y la antiafinidad, en las VMs que usan VM Runtime en GDC.

Antes de empezar

Para completar este documento, necesitas tener acceso a los siguientes recursos:

• Acceso a un clúster de Google Distributed Cloud versión 1.12.0 (anthosBareMetalVersion: 1.12.0) o posterior. Puedes usar cualquier tipo de clúster que pueda ejecutar cargas de trabajo. Si es necesario, prueba Google Distributed Cloud en Compute Engine o consulta la descripción general de la creación de clústeres.
• La herramienta de cliente virtctl instalada como complemento de kubectl. Si es necesario, instala la herramienta de cliente virtctl.

Nota: Los manifiestos de VirtualMachine de este documento usan la configuración de red predeterminada. Para obtener más información sobre las redes de máquinas virtuales, consulta Crear y usar redes virtuales para el tiempo de ejecución de máquinas virtuales en GDC.

Información general sobre las configuraciones de programación

Las configuraciones de programación son valores opcionales en el entorno de ejecución de máquinas virtuales de GDC. Si no se especifica ninguna configuración de programación, la VM se ajustará al comportamiento de programación predeterminado de Kubernetes.

Con el comportamiento de programación predeterminado, las VMs se distribuyen por todo el clúster. El programador analiza la disponibilidad de recursos de los nodos actuales, como la CPU y la memoria, y programa las VMs en los nodos para distribuir las demandas de computación. Si no tiene ningún requisito específico, no es necesario que defina ninguna configuración de programación.

Los siguientes tres campos están disponibles para programar las VMs:

• nodeSelector: especifica las etiquetas de nodo que debe tener el nodo host de una VM. El tiempo de ejecución de máquinas virtuales en GDC programa la VM solo en los nodos que tienen una etiqueta específica.
• Afinidad: especifica las reglas de afinidad de la VM. Incluye la afinidad de nodos y la afinidad o antiafinidad entre máquinas virtuales. Puedes definir un requisito flexible o estricto para el programador:
  • preferredDuringSchedulingIgnoredDuringExecution: es un requisito flexible. El programador intenta cumplir tu solicitud. Si el programador no puede atender la solicitud, es posible que la VM se programe en un nodo no preferido.
  • requiredDuringSchedulingIgnoredDuringExecution: es un requisito obligatorio. El programador intenta cumplir tu solicitud. Si no hay nodos disponibles que cumplan tus requisitos, la VM no se programa.
• Tolerations: permite que la VM se programe en nodos con intolerancias coincidentes.

Puedes definir cualquiera de estas configuraciones de programación para admitir tus cargas de trabajo de computación y tus necesidades de programación. Además de las configuraciones de programación, la programación de VMs depende de los recursos disponibles.

Nota: Para actualizar las configuraciones de programación de las VMs, estas deben estar en estado Stopped. Después de hacer los cambios, inicia la VM. El programador usa la nueva configuración para ejecutar la VM en los nodos adecuados. Para obtener más información, consulta cómo gestionar el estado de encendido de una máquina virtual.

El entorno de ejecución de máquinas virtuales en GDC usa la misma lógica de programación de máquinas virtuales y la misma estructura de manifiesto que Kubernetes para asignar pods a nodos. Para obtener más información sobre estas configuraciones de programación, consulta los siguientes enlaces:

• nodeSelector
• Afinidad y antiafinidad
• Taints y tolerancias

Colocar VMs en un nodo específico

Si tienes nodos con configuraciones de hardware específicas, puedes programar máquinas virtuales para que solo se ejecuten en esos nodos. Por ejemplo, tu VM puede necesitar un chipset de CPU concreto o compatibilidad con GPU. Puedes usar un nodeSelector básico o reglas de afinidad más flexibles para programar la ejecución de las VMs en estos nodos.

nodeSelector

El siguiente manifiesto VirtualMachine usa un nodeSelector para un requisito de programación estricto. Si no hay ningún nodo disponible que cumpla los requisitos de la configuración de programación, no se podrá programar la máquina virtual.

1. Crea un manifiesto VirtualMachine, como my-scheduled-vm.yaml,en el editor que prefieras:

   nano my-scheduled-vm.yaml
   

2. Copia y pega el siguiente manifiesto YAML:

   apiVersion: vm.cluster.gke.io/v1
   kind: VirtualMachine
   metadata:
     name: VM_NAME
   spec:
     interfaces:
       - name: eth0
         networkName: pod-network
         default: true
     disks:
       - virtualMachineDiskName: VM_NAME-boot-dv
         boot: true
     scheduling:
       nodeSelector:
         kubernetes.io/hostname: NODE_NAME
   

   Sustituye los siguientes valores:

   • VM_NAME: el nombre de tu VM.
   • NODE_NAME: los nodos en los que quieres programar tu VM.

   El disco de arranque llamado VM_NAME-boot-dv ya debe existir. Para obtener más información, consulta Crear un disco de arranque de VM.

3. Guarda y cierra el manifiesto de la VM en tu editor.

4. Crea la máquina virtual y programa la configuración con kubectl:

   kubectl apply -f my-scheduled-vm.yaml
   

Afinidad

El siguiente manifiesto de VirtualMachine usa la afinidad para un requisito de programación flexible. El programador intenta cumplir tu solicitud. Si el programador no puede atender la solicitud, la VM se programa en un nodo no preferido.

1. Crea un manifiesto VirtualMachine, como my-scheduled-vm.yaml,en el editor que prefieras:

   nano my-scheduled-vm.yaml
   

2. Copia y pega el siguiente manifiesto YAML:

   apiVersion: vm.cluster.gke.io/v1
   kind: VirtualMachine
   metadata:
     name: VM_NAME
   spec:
     interfaces:
       - name: eth0
         networkName: pod-network
         default: true
     disks:
       - virtualMachineDiskName: VM_NAME-boot-dv
         boot: true
     scheduling:
         affinity:
           nodeAffinity:
             preferredDuringSchedulingIgnoredDuringExecution:
             - weight: 100
               preference:
                 matchExpressions:
                 - key: kubernetes.io/hostname
                   operator: In
                   values:
                   - NODE_NAME
   

   Sustituye los siguientes valores:

   • VM_NAME: el nombre de tu VM.
   • NODE_NAME: los nodos en los que quieres programar tu VM.

   El disco de arranque llamado VM_NAME-boot-dv ya debe existir. Para obtener más información, consulta Crear un disco de arranque de VM.

   Nota: Si tienes un requisito de programación estricto, define requiredDuringSchedulingIgnoredDuringExecution en lugar de preferredDuringSchedulingIgnoredDuringExecution.

3. Guarda y cierra el manifiesto de la VM en tu editor.

4. Crea la máquina virtual y programa la configuración con kubectl:

   kubectl apply -f my-scheduled-vm.yaml
   

No colocar VMs en un nodo específico

Es posible que algunas máquinas virtuales tengan cargas de trabajo que no se ejecuten en un nodo concreto. Puedes usar reglas de antiafinidad para evitar que se programen VMs en estos nodos.

El siguiente manifiesto de VirtualMachine usa la afinidad para un requisito de programación flexible. El programador intenta cumplir tu solicitud. Si el programador no puede cumplir la solicitud, la VM se puede programar en un nodo inadecuado.

1. Crea un manifiesto VirtualMachine, como my-scheduled-vm.yaml,en el editor que prefieras:

   nano my-scheduled-vm.yaml
   

2. Copia y pega el siguiente manifiesto YAML:

   apiVersion: vm.cluster.gke.io/v1
   kind: VirtualMachine
   metadata:
     name: VVM_NAME
   spec:
     interfaces:
       - name: eth0
         networkName: pod-network
         default: true
     disks:
       - virtualMachineDiskName: VM_NAME-boot-dv
         boot: true
     scheduling:
       affinity:
         nodeAffinity:
           preferredDuringSchedulingIgnoredDuringExecution:
           - weight: 100
             preference:
               matchExpressions:
               - key: kubernetes.io/hostname
                 operator: NotIn
                 values:
                 - NODE_NAME
   

   Sustituye los siguientes valores:

   • VM_NAME: el nombre de tu VM.
   • NODE_NAME: el nodo en el que quieres programar tu VM.

   El disco de arranque llamado VM_NAME-boot-dv ya debe existir. Para obtener más información, consulta Crear un disco de arranque de VM.

   Nota: Si tienes un requisito de programación estricto, define requiredDuringSchedulingIgnoredDuringExecution en lugar de preferredDuringSchedulingIgnoredDuringExecution.

3. Guarda y cierra el manifiesto de la VM en tu editor.

4. Crea la máquina virtual y programa la configuración con kubectl:

   kubectl apply -f my-scheduled-vm.yaml
   

Mantener las VMs separadas

Es posible que tus cargas de trabajo de computación tengan VMs que deban distribuirse entre nodos para ofrecer alta disponibilidad, como un grupo de VMs de frontend. Puedes usar reglas de antiafinidad entre VMs para evitar que se programen VMs juntas en nodos.

El siguiente manifiesto de VirtualMachine usa la afinidad para un requisito de programación flexible. El programador intenta cumplir tu solicitud. Si el programador no puede cumplir la solicitud, la VM se puede programar en un nodo inadecuado.

1. Crea un manifiesto VirtualMachine, como my-scheduled-vm.yaml,en el editor que prefieras:

   nano my-scheduled-vm.yaml
   

2. Copia y pega el siguiente manifiesto YAML:

   apiVersion: vm.cluster.gke.io/v1
   kind: VirtualMachine
   metadata:
     name: VM_NAME
     labels:
       KEY:VALUE
   spec:
     interfaces:
       - name: eth0
         networkName: pod-network
         default: true
     disks:
       - virtualMachineDiskName: VM_NAME-boot-dv
         boot: true
     scheduling:
       affinity:
         podAntiAffinity:
           preferredDuringSchedulingIgnoredDuringExecution:
           - weight: 100
             podAffinityTerm:
               topologyKey: kubernetes.io/hostname
               labelSelector:
                 matchLabels:
                   KEY:VALUE
   

   Sustituye los siguientes valores:

   • VM_NAME: el nombre de tu VM.
   • KEY:VALUE: la etiqueta key:value que se aplicará a las VMs que quieras programar en diferentes nodos. Para obtener más información, consulta Etiquetas y selectores.

   El disco de arranque llamado VM_NAME-boot-dv ya debe existir. Para obtener más información, consulta Crear un disco de arranque de VM.

   Nota: Si tienes un requisito de programación estricto, define requiredDuringSchedulingIgnoredDuringExecution en lugar de preferredDuringSchedulingIgnoredDuringExecution.

3. Guarda y cierra el manifiesto de la VM en tu editor.

4. Crea la máquina virtual y programa la configuración con kubectl:

   kubectl apply -f my-scheduled-vm.yaml
   

Mantener las VMs juntas

Es posible que tus cargas de trabajo de computación tengan VMs que deban mantenerse juntas en los nodos para reducir la latencia, como un nivel de middleware y de base de datos. Puedes usar reglas de afinidad entre VMs para programar VMs juntas en nodos.

El siguiente manifiesto de VirtualMachine usa la afinidad para un requisito de programación flexible. El programador intenta cumplir tu solicitud. Si el programador no puede cumplir la solicitud, la VM se puede programar en un nodo inadecuado.

1. Crea un manifiesto VirtualMachine, como my-scheduled-vm.yaml,en el editor que prefieras:

   nano my-scheduled-vm.yaml
   

2. Copia y pega el siguiente manifiesto YAML:

   apiVersion: vm.cluster.gke.io/v1
   kind: VirtualMachine
   metadata:
     name: VM_NAME
     labels:
       KEY:VALUE
   spec:
     interfaces:
       - name: eth0
         networkName: pod-network
         default: true
     disks:
       - virtualMachineDiskName: VM_NAME-boot-dv
         boot: true
     scheduling:
       affinity:
         podAffinity:
           preferredDuringSchedulingIgnoredDuringExecution
           - podAffinityTerm:
               topologyKey: kubernetes.io/hostname
               labelSelector:
                 matchLabels:
                   KEY:VALUE
             weight: 100
   

   Sustituye los siguientes valores:

   • VM_NAME: el nombre de tu VM.
   • KEY:VALUE: el par de etiquetas key:value que se aplicará a las VMs que quieras programar en diferentes nodos. Para obtener más información, consulta Etiquetas y selectores.

   El disco de arranque llamado VM_NAME-boot-dv ya debe existir. Para obtener más información, consulta Crear un disco de arranque de VM.

   Nota: Si tienes un requisito de programación estricto, define requiredDuringSchedulingIgnoredDuringExecution en lugar de preferredDuringSchedulingIgnoredDuringExecution.

3. Guarda y cierra el manifiesto de la VM en tu editor.

4. Crea la máquina virtual y programa la configuración con kubectl:

   kubectl apply -f my-scheduled-vm.yaml
   

Programar VMs en nodos con intolerancias

Los taints son una propiedad de programación que permite que los nodos solo admitan que se programen en ellos las VMs con tolerancias especificadas. Puedes aplicar un taint a un nodo y, a continuación, definir una tolerancia en el manifiesto VirtualMachine para permitir que la VM se ejecute en el nodo. Para obtener más información, consulta Taints y tolerancias.

1. Crea un manifiesto VirtualMachine, como my-scheduled-vm.yaml,en el editor que prefieras:

   nano my-scheduled-vm.yaml
   

2. Copia y pega el siguiente manifiesto YAML:

   apiVersion: vm.cluster.gke.io/v1
   kind: VirtualMachine
   metadata:
     name: VM_NAME
   spec:
     interfaces:
       - name: eth0
         networkName: pod-network
         default: true
     disks:
       - virtualMachineDiskName: VM_NAME-boot-dv
         boot: true
     scheduling:
       tolerations:
       - key: KEY_NAME
         operator: "Equal"
         value: KEY_VALUE
         effect: "NoSchedule"
   

   Sustituye los siguientes valores:

   • VM_NAME: el nombre de tu VM.
   • KEY_NAME: el nombre de la clave de tu tolerancia que coincide con el taint del nodo.
   • KEY_VALUE: el valor de la clave de tu tolerancia que coincide con el taint del nodo.

   El disco de arranque llamado VM_NAME-boot-dv ya debe existir. Para obtener más información, consulta Crear un disco de arranque de VM.

3. Guarda y cierra el manifiesto de la VM en tu editor.

4. Crea la máquina virtual y programa la configuración con kubectl:

   kubectl apply -f my-scheduled-vm.yaml
   

Siguientes pasos

• Edita una máquina virtual en Google Distributed Cloud.