10.22. Disques de la machine virtuelle

1. Les PVC doivent demander un mode d'accès ReadWriteMany.
2. Le fournisseur de stockage doit prendre en charge les API d'instantanés Kubernetes et CSI

Procédure

1. Créez un fichier hpp_cr.yaml avec une strophe storagePools comme dans l'exemple suivant :

   apiVersion: hostpathprovisioner.kubevirt.io/v1beta1
   kind: HostPathProvisioner
   metadata:
     name: hostpath-provisioner
   spec:
     imagePullPolicy: IfNotPresent
     storagePools: 1
     - name: any_name
       path: "/var/myvolumes" 2
   workload:
     nodeSelector:
       kubernetes.io/os: linux

   1

   La strophe storagePools est un tableau auquel vous pouvez ajouter plusieurs entrées.

   2

   Spécifiez les répertoires du pool de stockage sous le chemin de ce nœud.

2. Enregistrez le fichier et quittez.

3. Créez le HPP en exécutant la commande suivante :

   $ oc create -f hpp_cr.yaml

Procédure

1. Modifiez le profil de stockage. Dans cet exemple, le provisionneur n'est pas reconnu par CDI :

   oc edit -n openshift-cnv storageprofile <storage_class>

   Exemple de profil de stockage

   apiVersion: cdi.kubevirt.io/v1beta1
   kind: StorageProfile
   metadata:
     name: <unknown_provisioner_class>
   #   ...
   spec: {}
   status:
     provisioner: <unknown_provisioner>
     storageClass: <unknown_provisioner_class>

2. Fournir les valeurs d'attribut nécessaires dans le profil de stockage :

   Exemple de profil de stockage

   apiVersion: cdi.kubevirt.io/v1beta1
   kind: StorageProfile
   metadata:
     name: <unknown_provisioner_class>
   #   ...
   spec:
     claimPropertySets:
     - accessModes:
       - ReadWriteOnce 1
       volumeMode:
         Filesystem 2
   status:
     provisioner: <unknown_provisioner>
     storageClass: <unknown_provisioner_class>

   1

   Le site accessModes que vous avez sélectionné.

   2

   Le site volumeMode que vous avez sélectionné.

   Après avoir enregistré vos modifications, les valeurs sélectionnées apparaissent dans l'élément du profil de stockage status.

Procédure

1. Ouvrez l'objet HCO pour le modifier en exécutant la commande suivante :

   $ oc edit hco -n openshift-cnv kubevirt-hyperconverged

2. Modifiez les champs spec.config.filesystemOverhead en y ajoutant les valeurs que vous avez choisies :

   ...
   spec:
     config:
       filesystemOverhead:
         global: "<new_global_value>" 1
         storageClass:
           <storage_class_name>: "<new_value_for_this_storage_class>" 2

   1

   Le pourcentage de frais généraux du système de fichiers par défaut utilisé pour toutes les classes de stockage qui n'ont pas encore de valeur définie. Par exemple, global: "0.07" réserve 7 % du PVC à l'overhead du système de fichiers.

   2

   Le pourcentage de frais généraux du système de fichiers pour la classe de stockage spécifiée. Par exemple, mystorageclass: "0.04" modifie la valeur de surcharge par défaut pour les PVC dans la classe de stockage mystorageclass à 4 %.

3. Enregistrez et quittez l'éditeur pour mettre à jour l'objet HCO.

Procédure

1. Modifiez le CR HyperConverged en exécutant la commande suivante :

   $ oc edit hco -n openshift-cnv kubevirt-hyperconverged

2. Ajoutez la strophe spec.resourceRequirements.storageWorkloads à la CR, en définissant les valeurs en fonction de votre cas d'utilisation. Par exemple :

   apiVersion: hco.kubevirt.io/v1beta1
   kind: HyperConverged
   metadata:
     name: kubevirt-hyperconverged
   spec:
     resourceRequirements:
       storageWorkloads:
         limits:
           cpu: "500m"
           memory: "2Gi"
         requests:
           cpu: "250m"
           memory: "1Gi"

3. Sauvegardez et quittez l'éditeur pour mettre à jour le CR HyperConverged.

Procédure

1. Dans le menu latéral de la console web, cliquez sur Storage Persistent Volume Claims.
2. Cliquez sur la liste déroulante Create Persistent Volume Claim pour la développer.
3. Cliquez sur With Data Upload Form pour ouvrir la page Upload Data to Persistent Volume Claim.
4. Cliquez sur Browse pour ouvrir le gestionnaire de fichiers et sélectionnez l'image que vous souhaitez télécharger, ou faites glisser le fichier dans le champ Drag a file here or browse to upload.

5. Facultatif : Définir cette image comme image par défaut pour un système d'exploitation spécifique.

   1. Cochez la case Attach this data to a virtual machine operating system.
   2. Sélectionnez un système d'exploitation dans la liste.
6. Le champ Persistent Volume Claim Name est automatiquement rempli avec un nom unique et ne peut pas être modifié. Notez le nom attribué au PVC afin de pouvoir l'identifier ultérieurement, si nécessaire.
7. Sélectionnez une classe de stockage dans la liste Storage Class.

8. Dans le champ Size, entrez la valeur de la taille du PVC. Sélectionnez l'unité de mesure correspondante dans la liste déroulante.

   Avertissement

   La taille du PVC doit être supérieure à la taille du disque virtuel non compressé.

9. Sélectionnez une adresse Access Mode correspondant à la classe de stockage que vous avez sélectionnée.
10. Cliquez sur Upload.

Procédure

1. Créez une configuration de volume de données qui spécifie spec: source: upload{}:

   apiVersion: cdi.kubevirt.io/v1beta1
   kind: DataVolume
   metadata:
     name: <upload-datavolume> 1
   spec:
     source:
         upload: {}
     pvc:
       accessModes:
         - ReadWriteOnce
       resources:
         requests:
           storage: <2Gi> 2

   1

   Le nom du volume de données.

   2

   La taille du volume de données. Assurez-vous que cette valeur est supérieure ou égale à la taille du disque que vous téléchargez.

2. Créez le volume de données en exécutant la commande suivante :

   oc create -f <upload-datavolume>.yaml

Procédure

1. Identifiez les éléments suivants :

   • Le nom du volume de données de téléchargement que vous souhaitez utiliser. Si ce volume de données n'existe pas, il est créé automatiquement.
   • La taille du volume de données, si vous souhaitez qu'il soit créé pendant la procédure de téléchargement. La taille doit être supérieure ou égale à la taille de l'image disque.
   • L'emplacement du fichier de l'image du disque de la machine virtuelle que vous souhaitez télécharger.

2. Téléchargez l'image disque en exécutant la commande virtctl image-upload. Spécifiez les paramètres que vous avez identifiés à l'étape précédente. Par exemple :

   $ virtctl image-upload dv <datavolume_name> \ 1
   --size=<datavolume_size> \ 2
   --image-path=</path/to/image> \ 3

   1

   Le nom du volume de données.

   2

   La taille du volume de données. Par exemple : --size=500Mi, --size=1G

   3

   Le chemin d'accès au fichier de l'image du disque de la machine virtuelle.

   Note
   • Si vous ne souhaitez pas créer un nouveau volume de données, omettez le paramètre --size et incluez l'indicateur --no-create.
   • Lors du téléchargement d'une image de disque vers un PVC, la taille du PVC doit être supérieure à la taille du disque virtuel non compressé.
   • Pour autoriser les connexions de serveur non sécurisées lors de l'utilisation de HTTPS, utilisez le paramètre --insecure. Sachez que lorsque vous utilisez le paramètre --insecure, l'authenticité du point de terminaison du téléchargement est vérifiée par not.

3. Facultatif. Pour vérifier qu'un volume de données a été créé, affichez tous les volumes de données en exécutant la commande suivante :

   $ oc get dvs

Procédure

1. Connectez-vous en tant que root au nœud sur lequel vous souhaitez créer le PV local. Cette procédure utilise node01 pour ses exemples.

2. Créez un fichier et remplissez-le de caractères nuls afin qu'il puisse être utilisé comme périphérique de bloc. L'exemple suivant crée un fichier loop10 d'une taille de 2 Go (20 blocs de 100 Mo) :

   $ dd if=/dev/zero of=<loop10> bs=100M count=20

3. Monter le fichier loop10 en tant que périphérique en boucle.

   $ losetup </dev/loop10>d3 <loop10> 1 2

   1

   Chemin d'accès au fichier où le périphérique loop est monté.

   2

   Le fichier créé à l'étape précédente doit être monté en tant que périphérique de boucle.

4. Créez un manifeste PersistentVolume qui fait référence au périphérique en boucle monté.

   kind: PersistentVolume
   apiVersion: v1
   metadata:
     name: <local-block-pv10>
     annotations:
   spec:
     local:
       path: </dev/loop10> 1
     capacity:
       storage: <2Gi>
     volumeMode: Block 2
     storageClassName: local 3
     accessModes:
       - ReadWriteOnce
     persistentVolumeReclaimPolicy: Delete
     nodeAffinity:
       required:
         nodeSelectorTerms:
         - matchExpressions:
           - key: kubernetes.io/hostname
             operator: In
             values:
             - <node01> 4

   1

   Chemin d'accès du dispositif de boucle sur le nœud.

   2

   Indique qu'il s'agit d'un PV en bloc.

   3

   Facultatif : Définissez une classe de stockage pour le PV. Si vous ne le faites pas, la valeur par défaut du cluster est utilisée.

   4

   Le nœud sur lequel le périphérique de bloc a été monté.

5. Créer le bloc PV.

   # oc create -f <local-block-pv10.yaml>1

   1

   Le nom de fichier du volume persistant créé à l'étape précédente.

Procédure

1. Créez une configuration de volume de données qui spécifie spec: source: upload{}:

   apiVersion: cdi.kubevirt.io/v1beta1
   kind: DataVolume
   metadata:
     name: <upload-datavolume> 1
   spec:
     source:
         upload: {}
     pvc:
       accessModes:
         - ReadWriteOnce
       resources:
         requests:
           storage: <2Gi> 2

   1

   Le nom du volume de données.

   2

   La taille du volume de données. Assurez-vous que cette valeur est supérieure ou égale à la taille du disque que vous téléchargez.

2. Créez le volume de données en exécutant la commande suivante :

   oc create -f <upload-datavolume>.yaml

Procédure

1. Identifiez les éléments suivants :

   • Le nom du volume de données de téléchargement que vous souhaitez utiliser. Si ce volume de données n'existe pas, il est créé automatiquement.
   • La taille du volume de données, si vous souhaitez qu'il soit créé pendant la procédure de téléchargement. La taille doit être supérieure ou égale à la taille de l'image disque.
   • L'emplacement du fichier de l'image du disque de la machine virtuelle que vous souhaitez télécharger.

2. Téléchargez l'image disque en exécutant la commande virtctl image-upload. Spécifiez les paramètres que vous avez identifiés à l'étape précédente. Par exemple :

   $ virtctl image-upload dv <datavolume_name> \ 1
   --size=<datavolume_size> \ 2
   --image-path=</path/to/image> \ 3

   1

   Le nom du volume de données.

   2

   La taille du volume de données. Par exemple : --size=500Mi, --size=1G

   3

   Le chemin d'accès au fichier de l'image du disque de la machine virtuelle.

   Note
   • Si vous ne souhaitez pas créer un nouveau volume de données, omettez le paramètre --size et incluez l'indicateur --no-create.
   • Lors du téléchargement d'une image de disque vers un PVC, la taille du PVC doit être supérieure à la taille du disque virtuel non compressé.
   • Pour autoriser les connexions de serveur non sécurisées lors de l'utilisation de HTTPS, utilisez le paramètre --insecure. Sachez que lorsque vous utilisez le paramètre --insecure, l'authenticité du point de terminaison du téléchargement est vérifiée par not.

3. Facultatif. Pour vérifier qu'un volume de données a été créé, affichez tous les volumes de données en exécutant la commande suivante :

   $ oc get dvs

Procédure

1. Accédez à la ligne de commande de la machine virtuelle via l'une des consoles ou via SSH.

2. Installer l'agent invité QEMU sur la machine virtuelle :

   $ yum install -y qemu-guest-agent

3. Assurez-vous que le service est persistant et démarrez-le :

   $ systemctl enable --now qemu-guest-agent

Procédure

1. Cliquez sur Virtualization VirtualMachines dans le menu latéral.
2. Sélectionnez une machine virtuelle pour ouvrir la page VirtualMachine details.
3. Si la machine virtuelle est en cours d'exécution, cliquez sur Actions Stop pour l'éteindre.
4. Cliquez sur l'onglet Snapshots puis sur Take Snapshot.
5. Remplir les champs Snapshot Name et Description (facultatif).
6. Développez Disks included in this Snapshot pour voir les volumes de stockage à inclure dans l'instantané.
7. Si votre VM possède des disques qui ne peuvent pas être inclus dans l'instantané et que vous souhaitez quand même continuer, cochez la case I am aware of this warning and wish to proceed.
8. Cliquez sur Save.

Procédure

1. Créer un fichier YAML pour définir un objet VirtualMachineSnapshot qui spécifie le nom du nouveau VirtualMachineSnapshot et le nom de la VM source.

   Par exemple :

   apiVersion: snapshot.kubevirt.io/v1alpha1
   kind: VirtualMachineSnapshot
   metadata:
     name: my-vmsnapshot 1
   spec:
     source:
       apiGroup: kubevirt.io
       kind: VirtualMachine
       name: my-vm 2

   1

   Le nom du nouvel objet VirtualMachineSnapshot.

   2

   Le nom de la VM source.

2. Créer la ressource VirtualMachineSnapshot. Le contrôleur d'instantanés crée un objet VirtualMachineSnapshotContent, le lie à VirtualMachineSnapshot et met à jour les champs status et readyToUse de l'objet VirtualMachineSnapshot.

   oc create -f <my-vmsnapshot>.yaml

3. Facultatif : si vous prenez un instantané en ligne, vous pouvez utiliser la commande wait et surveiller l'état de l'instantané :

   1. Entrez la commande suivante :

      $ oc wait my-vm my-vmsnapshot --for condition=Ready

   2. Vérifier l'état de l'instantané :

      • InProgress - L'opération d'instantané en ligne est toujours en cours.
      • Succeeded - L'opération d'instantané en ligne s'est terminée avec succès.

      • Failed - L'opération d'instantané en ligne a échoué.

        Note

        Les instantanés en ligne ont un délai par défaut de cinq minutes (5m). Si l'instantané ne se termine pas avec succès dans les cinq minutes, l'état est défini sur failed. Par la suite, le système de fichiers sera décongelé et la VM dégelée, mais l'état restera failed jusqu'à ce que vous supprimiez l'image de l'instantané qui a échoué.

        Pour modifier le délai par défaut, ajoutez l'attribut FailureDeadline à la spécification d'instantané VM avec le délai en minutes (m) ou en secondes (s) que vous souhaitez spécifier avant que l'opération d'instantané ne se termine.

        Pour ne pas fixer de délai, vous pouvez spécifier 0, bien que cela ne soit généralement pas recommandé, car cela peut entraîner une absence de réponse de la part de la VM.

        Si vous ne spécifiez pas d'unité de temps telle que m ou s, la valeur par défaut est la seconde (s).

Vérification

1. Vérifiez que l'objet VirtualMachineSnapshot est créé et lié à VirtualMachineSnapshotContent. L'indicateur readyToUse doit être défini sur true.

   $ oc describe vmsnapshot <my-vmsnapshot>

   Exemple de sortie

   apiVersion: snapshot.kubevirt.io/v1alpha1
   kind: VirtualMachineSnapshot
   metadata:
     creationTimestamp: "2020-09-30T14:41:51Z"
     finalizers:
     - snapshot.kubevirt.io/vmsnapshot-protection
     generation: 5
     name: mysnap
     namespace: default
     resourceVersion: "3897"
     selfLink: /apis/snapshot.kubevirt.io/v1alpha1/namespaces/default/virtualmachinesnapshots/my-vmsnapshot
     uid: 28eedf08-5d6a-42c1-969c-2eda58e2a78d
   spec:
     source:
       apiGroup: kubevirt.io
       kind: VirtualMachine
       name: my-vm
   status:
     conditions:
     - lastProbeTime: null
       lastTransitionTime: "2020-09-30T14:42:03Z"
       reason: Operation complete
       status: "False" 1
       type: Progressing
     - lastProbeTime: null
       lastTransitionTime: "2020-09-30T14:42:03Z"
       reason: Operation complete
       status: "True" 2
       type: Ready
     creationTime: "2020-09-30T14:42:03Z"
     readyToUse: true 3
     sourceUID: 355897f3-73a0-4ec4-83d3-3c2df9486f4f
     virtualMachineSnapshotContentName: vmsnapshot-content-28eedf08-5d6a-42c1-969c-2eda58e2a78d 4

   1

   Le champ status de la condition Progressing indique si l'instantané est toujours en cours de création.

   2

   Le champ status de la condition Ready indique si le processus de création de l'instantané est terminé.

   3

   Indique si l'instantané est prêt à être utilisé.

   4

   Spécifie que l'instantané est lié à un objet VirtualMachineSnapshotContent créé par le contrôleur d'instantanés.

2. Vérifiez la propriété spec:volumeBackups de la ressource VirtualMachineSnapshotContent pour vérifier que les PVC prévus sont inclus dans l'instantané.

Procédure

1. Affichez la sortie des indications de l'instantané en effectuant l'une des opérations suivantes :

   • Pour les instantanés créés à l'aide de l'interface de programmation, affichez l'indicateur dans l'objet YAML VirtualMachineSnapshot, dans le champ status.
   • Pour les instantanés créés à l'aide de la console Web, cliquez sur VirtualMachineSnapshot > Status dans l'écran Snapshot details.

2. Vérifiez l'état de l'instantané de votre VM en ligne :

   • Online indique que la machine virtuelle était en cours d'exécution lors de la création de l'instantané en ligne.
   • NoGuestAgent indique que l'agent invité QEMU n'était pas en cours d'exécution lors de la création d'un instantané en ligne. L'agent invité QEMU n'a pas pu être utilisé pour geler et dégeler le système de fichiers, soit parce que l'agent invité QEMU n'était pas installé ou en cours d'exécution, soit en raison d'une autre erreur.

Procédure

1. Cliquez sur Virtualization VirtualMachines dans le menu latéral.
2. Sélectionnez une machine virtuelle pour ouvrir la page VirtualMachine details.
3. Si la machine virtuelle est en cours d'exécution, cliquez sur Actions Stop pour l'éteindre.
4. Cliquez sur l'onglet Snapshots. La page affiche une liste des instantanés associés à la machine virtuelle.

5. Choisissez l'une des méthodes suivantes pour restaurer un instantané de VM :

   1. Pour l'instantané que vous souhaitez utiliser comme source pour restaurer la VM, cliquez sur Restore.
   2. Sélectionnez un instantané pour ouvrir l'écran Snapshot Details et cliquez sur Actions Restore VirtualMachineSnapshot.
6. Dans la fenêtre de confirmation, cliquez sur Restore pour restaurer la configuration précédente de la VM, représentée par l'instantané.

Procédure

1. Créez un fichier YAML pour définir un objet VirtualMachineRestore qui spécifie le nom de la VM à restaurer et le nom de l'instantané à utiliser comme source.

   Par exemple :

   apiVersion: snapshot.kubevirt.io/v1alpha1
   kind: VirtualMachineRestore
   metadata:
     name: my-vmrestore 1
   spec:
     target:
       apiGroup: kubevirt.io
       kind: VirtualMachine
       name: my-vm 2
     virtualMachineSnapshotName: my-vmsnapshot 3

   1

   Le nom du nouvel objet VirtualMachineRestore.

   2

   Le nom de la VM cible que vous souhaitez restaurer.

   3

   Le nom de l'objet VirtualMachineSnapshot à utiliser comme source.

2. Créez la ressource VirtualMachineRestore. Le contrôleur d'instantanés met à jour les champs d'état de l'objet VirtualMachineRestore et remplace la configuration existante de la VM par le contenu de l'instantané.

   $ oc create -f <my-vmrestore>.yaml

Procédure

1. Cliquez sur Virtualization VirtualMachines dans le menu latéral.
2. Sélectionnez une machine virtuelle pour ouvrir la page VirtualMachine details.
3. Cliquez sur l'onglet Snapshots. La page affiche une liste des instantanés associés à la machine virtuelle.
4. Cliquez sur le menu Options de l'instantané de la machine virtuelle que vous souhaitez supprimer et sélectionnez Delete VirtualMachineSnapshot.
5. Dans la fenêtre de confirmation, cliquez sur Delete pour supprimer l'instantané.

Procédure

1. Créer un nouveau PV local sur le nœud ou identifier un PV local déjà présent sur le nœud :

   • Créer un PV local qui inclut les paramètres nodeAffinity.nodeSelectorTerms. Le manifeste suivant crée un PV local 10Gi sur node01.

     kind: PersistentVolume
     apiVersion: v1
     metadata:
       name: <destination-pv> 1
       annotations:
     spec:
       accessModes:
       - ReadWriteOnce
       capacity:
         storage: 10Gi 2
       local:
         path: /mnt/local-storage/local/disk1 3
       nodeAffinity:
         required:
           nodeSelectorTerms:
           - matchExpressions:
             - key: kubernetes.io/hostname
               operator: In
               values:
               - node01 4
       persistentVolumeReclaimPolicy: Delete
       storageClassName: local
       volumeMode: Filesystem

     1

     Le nom du PV.

     2

     La taille du PV. Vous devez allouer suffisamment d'espace, sinon l'opération de clonage échoue. La taille doit être égale ou supérieure à celle du PVC source.

     3

     Le chemin de montage sur le nœud.

     4

     Le nom du nœud où vous voulez créer le PV.

   • Identifier un PV qui existe déjà sur le nœud cible. Vous pouvez identifier le nœud où un PV est provisionné en consultant le champ nodeAffinity dans sa configuration :

     $ oc get pv <destination-pv> -o yaml

     L'extrait suivant montre que le PV est sur node01:

     Exemple de sortie

     ...
     spec:
       nodeAffinity:
         required:
           nodeSelectorTerms:
           - matchExpressions:
             - key: kubernetes.io/hostname 1
               operator: In
               values:
               - node01 2
     ...

     1

     La clé kubernetes.io/hostname utilise le nom d'hôte du nœud pour sélectionner un nœud.

     2

     Le nom d'hôte du nœud.

2. Ajouter une étiquette unique au PV :

   oc label pv <destination-pv> node=node01

3. Créez un manifeste de volume de données qui fait référence aux éléments suivants :

   • Le nom PVC et l'espace de noms de la machine virtuelle.
   • L'étiquette que vous avez appliquée au PV à l'étape précédente.

   • Taille du PV de destination.

     apiVersion: cdi.kubevirt.io/v1beta1
     kind: DataVolume
     metadata:
       name: <clone-datavolume> 1
     spec:
       source:
         pvc:
           name: "<source-vm-disk>" 2
           namespace: "<source-namespace>" 3
       pvc:
         accessModes:
           - ReadWriteOnce
         selector:
           matchLabels:
             node: node01 4
         resources:
           requests:
             storage: <10Gi> 5

     1

     Le nom du nouveau volume de données.

     2

     Le nom du PVC source. Si vous ne connaissez pas le nom du PVC, vous pouvez le trouver dans la configuration de la machine virtuelle : spec.volumes.persistentVolumeClaim.claimName.

     3

     L'espace de noms dans lequel le PVC source existe.

     4

     L'étiquette que vous avez appliquée au PV à l'étape précédente.

     5

     Taille du PV de destination.

4. Commencez l'opération de clonage en appliquant le manifeste du volume de données à votre cluster :

   oc apply -f <clone-datavolume.yaml>

Procédure

1. Modifiez le manifeste DataVolume:

   apiVersion: cdi.kubevirt.io/v1beta1
   kind: DataVolume
   metadata:
     name: blank-image-datavolume
   spec:
     source:
         blank: {}
     pvc:
       # Optional: Set the storage class or omit to accept the default
       # storageClassName: "hostpath"
       accessModes:
         - ReadWriteOnce
       resources:
         requests:
           storage: 500Mi

2. Créez l'image de disque vierge en exécutant la commande suivante :

   oc create -f <blank-image-datavolume>.yaml

1. Un instantané de la revendication de volume persistant (PVC) source est créé.
2. Un PVC est créé à partir de l'instantané.
3. L'instantané est supprimé.

1. Créez un fichier YAML pour un objet DataVolume qui spécifie le nom du nouveau volume de données ainsi que le nom et l'espace de noms du PVC source. Dans cet exemple, comme vous spécifiez l'API storage, il n'est pas nécessaire de spécifier accessModes ou volumeMode. Les valeurs optimales seront calculées automatiquement pour vous.

   apiVersion: cdi.kubevirt.io/v1beta1
   kind: DataVolume
   metadata:
     name: <cloner-datavolume> 1
   spec:
     source:
       pvc:
         namespace: "<source-namespace>" 2
         name: "<my-favorite-vm-disk>" 3
     storage: 4
       resources:
         requests:
           storage: <2Gi> 5

   1

   Le nom du nouveau volume de données.

   2

   L'espace de noms dans lequel le PVC source existe.

   3

   Le nom du PVC source.

   4

   Spécifie l'allocation avec l'API storage

   5

   Taille du nouveau volume de données.

2. Commencez à cloner le PVC en créant le volume de données :

   oc create -f <cloner-datavolume>.yaml

   Note

   Les volumes de données empêchent le démarrage d'une machine virtuelle avant que le PVC ne soit préparé. Vous pouvez donc créer une machine virtuelle qui fait référence au nouveau volume de données pendant que le PVC se clone.

Procédure

1. Dans la console OpenShift Container Platform, cliquez sur Virtualization Templates dans le menu latéral.
2. Identifiez le modèle RHEL pour lequel vous souhaitez configurer une source de démarrage et cliquez sur Add source.
3. Dans la fenêtre Add boot source to template, sélectionnez URL (creates PVC) dans la liste Boot source type.
4. Cliquez sur RHEL download page pour accéder au portail client de Red Hat. Une liste des installateurs et des images disponibles est affichée sur la page Télécharger Red Hat Enterprise Linux.
5. Identifiez l'image de l'invité Red Hat Enterprise Linux KVM que vous souhaitez télécharger. Cliquez avec le bouton droit de la souris sur Download Now et copiez l'URL de l'image.
6. Dans la fenêtre Add boot source to template, collez l'URL dans le champ Import URL et cliquez sur Save and import.

Vérification

1. Vérifiez que le modèle affiche une coche verte dans la colonne Boot source de la page Templates.

Procédure

1. Dans la console OpenShift Container Platform, cliquez sur Virtualization Templates dans le menu latéral.
2. Cliquez sur le menu d'options à côté d'un modèle et sélectionnez Edit boot source.
3. Cliquez sur Add disk.
4. Dans la fenêtre Add disk, sélectionnez Use this disk as a boot source.
5. Saisissez le nom du disque et sélectionnez une adresse Source, par exemple, Blank (creates PVC) ou Use an existing PVC.
6. Entrez une valeur pour Persistent Volume Claim size afin de spécifier la taille du PVC adéquate pour l'image non compressée et tout espace supplémentaire requis.
7. Sélectionnez une adresse Type, par exemple Disk ou CD-ROM.

8. Facultatif : Cliquez sur Storage class et sélectionnez la classe de stockage utilisée pour créer le disque. En général, cette classe de stockage est la classe de stockage par défaut qui est créée pour être utilisée par tous les PVC.

   Note

   Les sources d'amorçage fournies sont automatiquement mises à jour avec la dernière version du système d'exploitation. Pour les sources d'amorçage mises à jour automatiquement, les réclamations de volumes persistants (PVC) sont créées avec la classe de stockage par défaut de la grappe. Si vous sélectionnez une autre classe de stockage par défaut après la configuration, vous devez supprimer les volumes de données existants dans l'espace de noms du cluster qui sont configurés avec la classe de stockage par défaut précédente.

9. Facultatif : Clear Apply optimized StorageProfile settings pour modifier le mode d'accès ou le mode de volume.

10. Sélectionnez la méthode appropriée pour enregistrer votre source de démarrage :

    1. Cliquez sur Save and upload si vous avez téléchargé un fichier local.
    2. Cliquez sur Save and import si vous avez importé du contenu à partir d'une URL ou du registre.
    3. Cliquez sur Save and clone si vous avez cloné un PVC existant.

Procédure

1. Dans la console web d'OpenShift Container Platform, cliquez sur Virtualization Catalog dans le menu latéral.
2. Sélectionnez le modèle mis à jour et cliquez sur Quick create VirtualMachine.

Procédure

1. Cliquez sur Virtualization VirtualMachines dans le menu latéral.
2. Sélectionnez la machine virtuelle en cours d'exécution sur laquelle vous souhaitez connecter à chaud un disque virtuel.
3. Sur la page VirtualMachine details, cliquez sur l'onglet Disks.
4. Cliquez sur Add disk.
5. Dans la fenêtre Add disk (hot plugged), remplissez les informations relatives au disque virtuel que vous souhaitez connecter à chaud.
6. Cliquez sur Save.

Procédure

1. Cliquez sur Virtualization VirtualMachines dans le menu latéral.
2. Sélectionnez la machine virtuelle en cours d'exécution avec le disque que vous voulez débrancher à chaud pour ouvrir la page VirtualMachine details.
3. Dans l'onglet Disks, cliquez sur le menu Options du disque virtuel que vous souhaitez débrancher à chaud.
4. Cliquez sur Detach.

Procédure

1. Créer un fichier Docker pour construire l'image de la machine virtuelle dans une image de conteneur. L'image de la machine virtuelle doit appartenir à QEMU, qui a un UID de 107, et être placée dans le répertoire /disk/ à l'intérieur du conteneur. Les autorisations pour le répertoire /disk/ doivent ensuite être définies sur 0440.

   L'exemple suivant utilise l'image de base universelle (UBI) de Red Hat pour gérer ces changements de configuration dans la première étape, et utilise l'image minimale scratch dans la deuxième étape pour stocker le résultat :

   $ cat > Dockerfile << EOF
   FROM registry.access.redhat.com/ubi8/ubi:latest AS builder
   ADD --chown=107:107 <vm_image>.qcow2 /disk/ 1
   RUN chmod 0440 /disk/*
   
   FROM scratch
   COPY --from=builder /disk/* /disk/
   EOF

   1

   Où <vm_image> est l'image de la machine virtuelle au format QCOW2 ou RAW.
   Pour utiliser une image de machine virtuelle distante, remplacez <vm_image>.qcow2 par l'url complète de l'image distante.

2. Construire et étiqueter le conteneur :

   $ podman build -t <registry>/<container_disk_name>:latest .

3. Insérer l'image du conteneur dans le registre :

   $ podman push <registry>/<container_disk_name>:latest

Procédure

1. Modifiez le CR HyperConverged en exécutant la commande suivante :

   $ oc edit hco -n openshift-cnv kubevirt-hyperconverged

2. Ajoutez le champ spec.scratchSpaceStorageClass à la CR, en définissant la valeur sur le nom d'une classe de stockage qui existe dans le cluster :

   apiVersion: hco.kubevirt.io/v1beta1
   kind: HyperConverged
   metadata:
     name: kubevirt-hyperconverged
   spec:
     scratchSpaceStorageClass: "<storage_class>" 1

   1

   Si vous ne spécifiez pas de classe de stockage, CDI utilise la classe de stockage de la revendication de volume persistant qui est en train d'être remplie.

3. Sauvegardez et quittez votre éditeur par défaut pour mettre à jour le CR HyperConverged.

Procédure

1. Assurez-vous que la politique de récupération du PV est réglée sur Retain:

   1. Vérifier la politique de récupération du PV :

      oc get pv <pv_name> -o yaml | grep 'persistentVolumeReclaimPolicy' $ oc get pv <pv_name> -o yaml

   2. Si persistentVolumeReclaimPolicy n'est pas défini sur Retain, modifiez la politique de récupération à l'aide de la commande suivante :

      $ oc patch pv <pv_name> -p '{"spec":{"persistentVolumeReclaimPolicy":"Retain"}''

2. S'assurer qu'aucune ressource n'utilise le PV :

   oc describe pvc <pvc_name> | grep 'Mounted By:' (Monté par :)

   Supprimez toutes les ressources qui utilisent le PVC avant de continuer.

3. Supprimer le PVC pour libérer le PV :

   oc delete pvc <pvc_name> $ oc delete pvc <pvc_name>

4. Facultatif : Exporter la configuration PV dans un fichier YAML. Si vous supprimez manuellement le stockage partagé plus tard dans cette procédure, vous pourrez vous référer à cette configuration. Vous pouvez également utiliser les paramètres spec de ce fichier comme base pour créer un nouveau PV avec la même configuration de stockage après avoir récupéré le PV :

   $ oc get pv <nom_du_v> -o yaml > <nom_du_fichier>.yaml

5. Supprimer le PV :

   oc delete pv <pv_name> $ oc delete pv <pv_name>

6. Facultatif : Selon le type de stockage, il peut être nécessaire de supprimer le contenu du dossier de stockage partagé :

   $ rm -rf <path_to_share_storage>

7. Facultatif : Créez un PV qui utilise la même configuration de stockage que le PV supprimé. Si vous avez exporté la configuration du PV récupéré précédemment, vous pouvez utiliser les paramètres spec de ce fichier comme base d'un nouveau manifeste PV :

   Note

   Pour éviter tout conflit, il est conseillé de donner au nouvel objet PV un nom différent de celui que vous avez supprimé.

   oc create -f <nouveau_nom_pv>.yaml

Procédure

1. Modifiez le manifeste PersistentVolumeClaim du disque VM que vous souhaitez développer :

   $ oc edit pvc <nom_du_pvc>

2. Modifier la valeur de l'attribut spec.resource.requests.storage pour obtenir une taille plus grande.

   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
      name: vm-disk-expand
   spec:
     accessModes:
        - ReadWriteMany
     resources:
       requests:
          storage: 3Gi 1
   ...

   1

   Taille du disque de la VM pouvant être augmentée