Se usó la API de Cloud Translation para traducir esta página.

Programa las VMs que usan el entorno de ejecución de VM en GDC

Este documento está dirigido a propietarios de aplicaciones y administradores de plataformas que ejecutan Google Distributed Cloud. En este documento, se muestra cómo usar las opciones de configuración de programación, como la afinidad y la antiafinidad para las VM que usan el entorno de ejecución de VM en GDC.

Antes de comenzar

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

Acceso a la versión 1.12.0 (anthosBareMetalVersion: 1.12.0) o superior de Google Distributed Cloud. Puedes usar cualquier tipo de clúster capaz de 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 un complemento para kubectl. Si es necesario, instala la herramienta cliente de virtctl.

Descripción general de las configuraciones de programa

Los parámetros de configuración de la programación son valores opcionales en el entorno de ejecución de la VM en GDC. Si no se especifica una configuración de programación, la VM usa el comportamiento de programación predeterminado de Kubernetes de forma predeterminada.

Con el comportamiento de programación predeterminado, las VM se distribuyen en tu clúster. El programador analiza la disponibilidad actual de recursos de nodos, como la CPU y la memoria, y programa las VM en los nodos para distribuir las demandas de procesamiento. Si no tienes requisitos específicos, no necesitas definir ninguna configuración del programa.

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

nodeSelector: Especifica las etiquetas de nodos que debe tener el nodo host de una VM. El entorno de ejecución de VM en GDC programa la VM solo en los nodos que tienen una etiqueta especificada.
Afinidad: Especifica las reglas de afinidad de la VM. Incluye afinidad de nodos y afinidad o antiafinidad entre VM. Debes definir un requisito flexible o estricto para el programador:
- preferredDuringSchedulingIgnoredDuringExecution: es un requisito flexible. El programador intenta respetar tu solicitud. Si el programador no puede cumplir con la solicitud, la VM puede programarse en un nodo no preferido.
- requiredDuringSchedulingIgnoredDuringExecution: es un requisito estricto. El programador intenta respetar tu solicitud. Si no hay nodos disponibles que coincidan con tu requisito, la VM no se programa.
Tolerations: Permite programar la VM en nodos con taints que coincidan.

Puedes definir cualquiera de estas opciones de configuración de programación para admitir tus necesidades de programación y cargas de trabajo de procesamiento. Además de programar configuraciones, la programación de VM está sujeta a los recursos disponibles.

El entorno de ejecución de VM en GDC usa la misma lógica de programación de VM y 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 vínculos:

Coloca las VM en un nodo específico

Si tienes nodos con configuraciones de hardware específicas, puedes programar VM para que se ejecuten solo en estos nodos. Por ejemplo, es posible que tu VM necesite un chipset de CPU particular o compatibilidad con GPU. Puedes usar un nodeSelector básico o reglas de afinidad más flexibles para programar las VM a fin de ejecutarse 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 con la configuración de programación, la VM no se puede programar.

Crea un manifiesto VirtualMachine, como my-scheduled-vm.yaml,, en el editor que elijas:
```
nano my-scheduled-vm.yaml
```

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

Reemplaza los siguientes valores:

VM_NAME: El nombre de tu VM.
NODE_NAME: Los nodos en los que deseas programar tu VM.

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

Guarda y cierra el manifiesto de la VM en el editor.
Crea la VM y programa la configuración con kubectl:
```
kubectl apply -f my-scheduled-vm.yaml
```

Afinidad

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

Crea un manifiesto VirtualMachine, como my-scheduled-vm.yaml,, en el editor que elijas:
```
nano my-scheduled-vm.yaml
```

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

Reemplaza los siguientes valores:

VM_NAME: El nombre de tu VM.
NODE_NAME: Los nodos en los que deseas programar tu VM.

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

Guarda y cierra el manifiesto de la VM en el editor.
Crea la VM y programa la configuración con kubectl:
```
kubectl apply -f my-scheduled-vm.yaml
```

No coloques VM en un nodo específico

Ciertas VM pueden tener cargas de trabajo que no se ejecutan en un nodo en particular. Puedes usar reglas de antiafinidad para evitar programar VM en estos nodos.

Crea un manifiesto VirtualMachine, como my-scheduled-vm.yaml,, en el editor que elijas:
```
nano my-scheduled-vm.yaml
```

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

Reemplaza los siguientes valores:

VM_NAME: El nombre de tu VM.
NODE_NAME: El nodo en el que deseas programar tu VM.

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

Guarda y cierra el manifiesto de la VM en el editor.
Crea la VM y programa la configuración con kubectl:
```
kubectl apply -f my-scheduled-vm.yaml
```

Mantén las VM separadas

Es posible que las cargas de trabajo de procesamiento tengan VM que deben distribuirse entre nodos para una alta disponibilidad, como un grupo de VM de frontend. Puedes usar reglas de antiafinidad entre VM para evitar programar varias VM juntas en los nodos.

Crea un manifiesto VirtualMachine, como my-scheduled-vm.yaml,, en el editor que elijas:
```
nano my-scheduled-vm.yaml
```

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

Reemplaza los siguientes valores:

VM_NAME: El nombre de tu VM.
KEY:VALUE: Es la etiqueta key:value que se aplicará a las VM que deseas 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 Crea un disco de arranque de VM.

Guarda y cierra el manifiesto de la VM en el editor.
Crea la VM y programa la configuración con kubectl:
```
kubectl apply -f my-scheduled-vm.yaml
```

Mantén las VM juntas

Es posible que las cargas de trabajo de procesamiento tengan VM que deben 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 VM para programar las VM juntas en los nodos.

Crea un manifiesto VirtualMachine, como my-scheduled-vm.yaml,, en el editor que elijas:
```
nano my-scheduled-vm.yaml
```

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

Reemplaza los siguientes valores:

VM_NAME: El nombre de tu VM.
KEY:VALUE: Es el par de etiquetas key:value que se aplicará a las VM que deseas 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 Crea un disco de arranque de VM.

Guarda y cierra el manifiesto de la VM en el editor.
Crea la VM y programa la configuración con kubectl:
```
kubectl apply -f my-scheduled-vm.yaml
```

Programa VM en nodos con taints

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

Crea un manifiesto VirtualMachine, como my-scheduled-vm.yaml,, en el editor que elijas:
```
nano my-scheduled-vm.yaml
```
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"
```
Reemplaza los siguientes valores:
- VM_NAME: El nombre de tu VM.
- KEY_NAME: El nombre de clave de la tolerancia que coincide con el taint en el nodo.
- KEY_VALUE: El valor de la clave para la tolerancia que coincide con el taint en el nodo.
El disco de arranque llamado VM_NAME-boot-dv ya debe existir. Para obtener más información, consulta Crea un disco de arranque de VM.
Guarda y cierra el manifiesto de la VM en el editor.
Crea la VM y programa la configuración con kubectl:
```
kubectl apply -f my-scheduled-vm.yaml
```

¿Qué sigue?

Edita una VM en Google Distributed Cloud.