Pianifica VM che utilizzano VM Runtime su Google Distributed Cloud

Questo documento è destinato ai proprietari di applicazioni e agli amministratori di piattaforme che eseguono GKE su Bare Metal. Questo documento mostra come utilizzare le configurazioni di pianificazione, come affinità e anti-affinità, per le VM che utilizzano il runtime VM su Google Distributed Cloud.

Prima di iniziare

Per completare questo documento, devi avere accesso alle seguenti risorse:

Accesso al cluster GKE su Bare Metal versione 1.12.0 (anthosBareMetalVersion: 1.12.0) o successiva. Puoi utilizzare qualsiasi tipo di cluster in grado di eseguire carichi di lavoro. Se necessario, prova GKE su Bare Metal su Compute Engine o consulta la panoramica sulla creazione dei cluster.
Lo strumento client virtctl installato come plug-in per kubectl. Se necessario, installa lo strumento client virtctl.

Panoramica delle configurazioni di pianificazione

Le configurazioni di pianificazione sono valori facoltativi in VM Runtime su Google Distributed Cloud. Se non viene specificata alcuna configurazione di pianificazione, la VM utilizza per impostazione predefinita il comportamento di pianificazione predefinito di Kubernetes.

Con il comportamento di pianificazione predefinito, le VM sono distribuite nel cluster. Lo scheduler esamina l'attuale disponibilità di risorse dei nodi, come CPU e memoria, e pianifica le VM sui nodi per distribuire le esigenze di calcolo. Se non hai requisiti specifici, non è necessario definire alcuna configurazione di pianificazione.

Per pianificare le VM sono disponibili i tre campi seguenti:

nodeSelector: specifica le etichette che il nodo host di una VM deve avere. Il runtime VM su Google Distributed Cloud pianifica la VM solo sui nodi che hanno un'etichetta specificata.
Affinità: specifica le regole di affinità della VM. Include affinità dei nodi e affinità o anti-affinità tra le VM. Puoi definire un requisito flessibile o rigido per lo scheduler:
- preferredDuringSchedulingIgnoredDuringExecution: è un requisito flessibile. Lo scheduler cerca di soddisfare la tua richiesta. Se lo scheduler non riesce a soddisfare la richiesta, la VM potrebbe essere pianificata su un nodo non preferito.
- requiredDuringSchedulingIgnoredDuringExecution: è un requisito rigido. Lo scheduler cerca di soddisfare la tua richiesta. Se non sono disponibili nodi corrispondenti ai tuoi requisiti, la VM non è pianificata.
Tolerations: consente di pianificare la VM sui nodi con incompatibilità corrispondenti.

Puoi definire una qualsiasi di queste configurazioni di pianificazione per supportare i carichi di lavoro di calcolo e le esigenze di pianificazione. Oltre alla pianificazione delle configurazioni, la pianificazione delle VM è subordinata alle risorse disponibili.

Il runtime VM su Google Distributed Cloud utilizza la stessa logica di pianificazione delle VM e la stessa struttura manifest di Kubernetes per assegnare pod ai nodi. Per ulteriori informazioni su queste configurazioni di pianificazione, consulta i seguenti link:

Inserisci le VM su un nodo specifico

Se hai nodi con configurazioni hardware specifiche, puoi pianificare l'esecuzione delle VM solo su questi nodi. Ad esempio, la tua VM potrebbe richiedere un determinato chipset CPU o avere bisogno del supporto per GPU. Puoi utilizzare un nodeSelector di base o regole di affinità più flessibili per pianificare l'esecuzione delle VM su questi nodi.

nodeSelector

Il seguente manifest VirtualMachine utilizza un valore nodeSelector per un requisito di pianificazione rigido. Se non è disponibile alcun nodo che soddisfi la configurazione di pianificazione, non è possibile pianificare la VM.

Crea un manifest VirtualMachine, ad esempio my-scheduled-vm.yaml, nell'editor che preferisci:
```
nano my-scheduled-vm.yaml
```

Copia e incolla il seguente manifest 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

Sostituisci i seguenti valori:

VM_NAME: il nome della VM.
NODE_NAME: i nodi su cui vuoi pianificare la VM.

Il disco di avvio denominato VM_NAME-boot-dv deve già esistere. Per ulteriori informazioni, consulta Creare un disco di avvio delle VM.

Salva e chiudi il manifest della VM nell'editor.
Crea la VM e pianifica la configurazione utilizzando kubectl:
```
kubectl apply -f my-scheduled-vm.yaml
```

Affinità

Il seguente manifest VirtualMachine utilizza l'affinità per un requisito di pianificazione flessibile. Lo scheduler cerca di soddisfare la tua richiesta. Se lo scheduler non può onorare la richiesta, la VM viene pianificata su un nodo non preferito.

Crea un manifest VirtualMachine, ad esempio my-scheduled-vm.yaml, nell'editor che preferisci:
```
nano my-scheduled-vm.yaml
```

Copia e incolla il seguente manifest 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

Sostituisci i seguenti valori:

VM_NAME: il nome della VM.
NODE_NAME: i nodi su cui vuoi pianificare la VM.

Il disco di avvio denominato VM_NAME-boot-dv deve già esistere. Per ulteriori informazioni, consulta Creare un disco di avvio delle VM.

Salva e chiudi il manifest della VM nell'editor.
Crea la VM e pianifica la configurazione utilizzando kubectl:
```
kubectl apply -f my-scheduled-vm.yaml
```

Non posizionare le VM su un nodo specifico

Alcune VM potrebbero avere carichi di lavoro che non vengono eseguiti su un determinato nodo. Puoi utilizzare regole di anti-affinità per evitare di pianificare VM su questi nodi.

Crea un manifest VirtualMachine, ad esempio my-scheduled-vm.yaml, nell'editor che preferisci:
```
nano my-scheduled-vm.yaml
```

Copia e incolla il seguente manifest 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

Sostituisci i seguenti valori:

VM_NAME: il nome della VM.
NODE_NAME: il nodo su cui vuoi pianificare la VM.

Il disco di avvio denominato VM_NAME-boot-dv deve già esistere. Per ulteriori informazioni, consulta Creare un disco di avvio delle VM.

Salva e chiudi il manifest della VM nell'editor.
Crea la VM e pianifica la configurazione utilizzando kubectl:
```
kubectl apply -f my-scheduled-vm.yaml
```

Tieni separate le VM

I carichi di lavoro di computing potrebbero avere VM che devono essere distribuite tra i nodi per l'alta disponibilità, ad esempio un pool di VM di frontend. Puoi utilizzare le regole anti-affinità tra le VM per evitare di pianificare le VM insieme sui nodi.

Crea un manifest VirtualMachine, ad esempio my-scheduled-vm.yaml, nell'editor che preferisci:
```
nano my-scheduled-vm.yaml
```

Copia e incolla il seguente manifest 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

Sostituisci i seguenti valori:

VM_NAME: il nome della VM.
KEY:VALUE: l'etichetta key:value da applicare alle VM che vuoi pianificare in nodi diversi. Per saperne di più, consulta Etichette e selettori.

Il disco di avvio denominato VM_NAME-boot-dv deve già esistere. Per ulteriori informazioni, consulta Creare un disco di avvio delle VM.

Salva e chiudi il manifest della VM nell'editor.
Crea la VM e pianifica la configurazione utilizzando kubectl:
```
kubectl apply -f my-scheduled-vm.yaml
```

Mantieni unite le VM

I tuoi carichi di lavoro di computing potrebbero avere VM che devono essere tenute insieme sui nodi per ridurre la latenza, ad esempio un livello middleware e un livello database. Puoi utilizzare le regole di affinità tra le VM per pianificare insieme le VM sui nodi.

Crea un manifest VirtualMachine, ad esempio my-scheduled-vm.yaml, nell'editor che preferisci:
```
nano my-scheduled-vm.yaml
```

Copia e incolla il seguente manifest 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

Sostituisci i seguenti valori:

VM_NAME: il nome della VM.
KEY:VALUE: la coppia di etichette key:value da applicare alle VM che vuoi pianificare in nodi diversi. Per saperne di più, consulta Etichette e selettori.

Il disco di avvio denominato VM_NAME-boot-dv deve già esistere. Per ulteriori informazioni, consulta Creare un disco di avvio delle VM.

Salva e chiudi il manifest della VM nell'editor.
Crea la VM e pianifica la configurazione utilizzando kubectl:
```
kubectl apply -f my-scheduled-vm.yaml
```

Pianifica le VM su nodi con incompatibilità

Le incompatibilità sono una proprietà di pianificazione che consente ai nodi di consentire solo l'esecuzione di VM con tolleranze specificate. Puoi applicare un'incompatibilità a un nodo, quindi nel manifest VirtualMachine definire una tolleranza per consentire l'esecuzione della VM sul nodo. Per maggiori informazioni, consulta la pagina Incompatibilità e tolleranze.

Crea un manifest VirtualMachine, ad esempio my-scheduled-vm.yaml, nell'editor che preferisci:
```
nano my-scheduled-vm.yaml
```
Copia e incolla il seguente manifest 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"
```
Sostituisci i seguenti valori:
- VM_NAME: il nome della VM.
- KEY_NAME: il nome della chiave della tolleranza che corrisponde all'incompatibilità sul nodo.
- KEY_VALUE: il valore della chiave per la tolleranza che corrisponde all'incompatibilità sul nodo.
Il disco di avvio denominato VM_NAME-boot-dv deve già esistere. Per ulteriori informazioni, consulta Creare un disco di avvio delle VM.
Salva e chiudi il manifest della VM nell'editor.
Crea la VM e pianifica la configurazione utilizzando kubectl:
```
kubectl apply -f my-scheduled-vm.yaml
```

Passaggi successivi

Modifica una VM in GKE su Bare Metal.