Comment exporter et importer des machines virtuelles KVM sous Linux

Posté 14/04/2026

Par Yann

8 min lire

Traduction article original How To Export And Import KVM Virtual Machines In Linux

Guide complet sur la gestion des KVM (machines virtuelles basées sur le noyau) qui se concentre sur les processus critiques d’exportation et importation de vos machines virtuelles dans un environnement Linux. Ces étapes sont essentielles pour la migration, la sauvegarde, la reprise après sinistre, les environnements de clonage et le déplacement des charges de travail entre les hôtes.

Cet article couvre à la fois :

Une méthode manuelle (pour que vous compreniez ce qui se passe)
Une méthode automatisée utilisant un script de bash (pour que vous puissiez le répéter rapidement)

Comprendre KVM et l’importance de l’exportation/importation
Exportation et importation manuelles de machines virtuelles KVM
- Exporter une machine virtuelle KVM manuellement
- Importer une machine virtuelle KVM manuellement
Automatisation de l’exportation et de l’importation KVM avec un script Bash
- Code du script
- Utilisation du script
Personnalisation et meilleures pratiques
Résolution des problèmes courants
Conclusion

Comprendre KVM et l’importance de l’exportation/importation

KVM est une fonctionnalité de virtualisation open-source intégrée au noyau Linux. Il transforme une machine Linux en hyperviseur afin que vous puissiez exécuter plusieurs machines virtuelles (VM) avec des systèmes d’exploitation distincts.

Avantages clés :

Optimisation des ressources : consolider les charges de travail sur un hôte
Isolation et sécurité : les VM sont isolées les unes des autres
**Flexibilité : ** déploiement, test et mise à l’échelle faciles

Pourquoi l’exportation/l’importation importe-t-elle :

Sauvegardes et reprise après sinistre : restaurer les VM après la perte de données/pannes matérielles
Migration & portabilité : déplacer une VM vers un autre hôte Linux
Test & développement : clone une VM sans toucher à la production
Environnements de partage : distribuer des builds VM cohérents aux équipes

Exportation et importation manuelles de machines virtuelles KVM

L’exportation/importation manuelle est la base que vous devriez comprendre avant d’automatiser.

Exporter une machine virtuelle KVM manuellement

L’exportation signifie faire un backup:

De la configuration VM (XML)
De l’image disque VM (*qcow2/raw)

1) Identifier la VM

Listez toutes les VM (en cours d’exécution + arrêté) :

virsh list --all

Notez le nom de la VM <vm_name> que vous souhaitez exporter.

2) Éteindre la VM (recommandé)

Cela aide à éviter l’incohérence du disque :

virsh shutdown <vm_name>

Remplacez <vm_name> par votre VM réelle.

3) Localiser l’image disque

Les images VM sont souvent stockées dans :

/var/lib/libvirt/images

Vous pouvez vérifier les informations et confirmer le type/taille du fichier :

virsh dominfo <vm_name> | grep 'Disk'

Ou inspecter une image spécifique :

qemu-img info /path/to/your/disk.qcow2

4) Exporter la configuration XML

Dump la définition de la VM dans XML :

virsh dumpxml <vm_name> > <vm_name>.xml

Exemple:

virsh dumpxml myvm > myvm.xml

5) Copiez l’image disque + XML pour sauvegarder l’emplacement

Copie locale :

cp /path/to/your/disk.qcow2 /path/to/destination/
cp <vm_name>.xml /path/to/destination/

Copie à distance (SCP) :

scp /path/to/your/disk.qcow2 user@remote_host:/path/to/destination
scp <vm_name>.xml user@remote_host:/path/to/destination

À ce stade, votre machine virtuelle est exportée.

Importer une machine virtuelle KVM manuellement

L’importation signifie :

Copier le disque VM + XML vers l’hôte cible
Corriger les chemins si nécessaire
Définir VM avec virsh define
Démarrer VM

1) Transférer les fichiers vers le nouvel hôte

Exemple de transfert vers des emplacements standard :

scp user@remote_host:/path/to/destination/disk.qcow2 /var/lib/libvirt/images/
scp user@remote_host:/path/to/destination/<vm_name>.xml /tmp/

2) Ajustez le chemin de l’image disque dans XML (si nécessaire)

Ouvrez le XML et corrigez le chemin du fichier `<source=’…’>

        
      
<disk type='file' device='disk'>
  <driver name='qemu' type='qcow2'/>
  <source file='/var/lib/libvirt/images/disk.qcow2'/>  <!-- update this path -->
  <target dev='vda' bus='virtio'/>
</disk>

3) Définir la VM à partir de XML

virsh define /tmp/<vm_name>.xml

4) Démarrer la VM

virsh start <vm_name>

Vérifier:

virsh list

5) Vérifier le réseau

Après le démarrage :

confirmer que VM obtient une adresse IP
confirmer que l’invité peut atteindre LAN/Internet
confirmer que les ponts hôtes/NAT sont corrects
Automatisation de l’exportation et de l’importation KVM avec un script Bash

L’automatisation est utile pour les sauvegardes fréquentes et les migrations répétées. Le script ci-dessous :

(optionnellement) éteint la VM
exporte le XML de la VM
copie l’image disque dans un dossier d’exportation
importe en définissant XML et en démarrant VM

Code du script

Enregistrer sous : kvm_export_import.sh

        
      
#!/bin/bash

# Configuration (Customize these variables)
VM_NAME="$1"                      # Virtual Machine Name (passed as argument)
EXPORT_DIR="/mnt/backup/kvm_exports"  # Destination directory for exports
IMPORT_DIR="/var/lib/libvirt/images/" # Destination directory for imports (disk images)
LOG_FILE="/var/log/kvm_export_import.log"
DEBUG=false                       # Set to true for verbose output

#  Logging Function 
log() {
  local timestamp
  timestamp=$(date "+%Y-%m-%d %H:%M:%S")
  local message="$1"
  echo "$timestamp: $message" >> "$LOG_FILE"
  if $DEBUG; then
    echo "$timestamp: $message"
  fi
}

#  Error Handling Function 
error() {
  log "ERROR: $1"
  exit 1
}

#  Function to Shut Down VM (optional) 
shutdown_vm() {
  log "Shutting down VM: $VM_NAME"
  virsh shutdown "$VM_NAME" || error "Failed to shut down VM: $VM_NAME"
  log "VM $VM_NAME shut down successfully."
}

#  Function to Export VM 
export_vm() {
  log "Starting export of VM: $VM_NAME"

  mkdir -p "$EXPORT_DIR" || error "Failed to create export directory: $EXPORT_DIR"

  # Find disk image path
  DISK_IMAGE_PATH=$(virsh dominfo "$VM_NAME" | grep 'Disk' | awk '{print $4}')
  if [ -z "$DISK_IMAGE_PATH" ]; then
    error "Could not determine disk image path for VM: $VM_NAME"
  fi

  DISK_IMAGE_FILENAME=$(basename "$DISK_IMAGE_PATH")

  # Export XML configuration
  virsh dumpxml "$VM_NAME" > "$EXPORT_DIR/$VM_NAME.xml" || error "Failed to export XML configuration for VM: $VM_NAME"

  # Copy disk image
  cp "$DISK_IMAGE_PATH" "$EXPORT_DIR/$DISK_IMAGE_FILENAME" || error "Failed to copy disk image for VM: $VM_NAME"

  log "Successfully exported VM: $VM_NAME to $EXPORT_DIR"
}

#  Function to Import VM 
import_vm() {
  log "Starting import of VM: $VM_NAME"

  mkdir -p "$IMPORT_DIR" || error "Failed to create import directory: $IMPORT_DIR"

  if [ ! -f "$EXPORT_DIR/$VM_NAME.xml" ]; then
    error "Configuration file not found for VM: $VM_NAME in $EXPORT_DIR"
  fi

  # Define the VM
  virsh define "$EXPORT_DIR/$VM_NAME.xml" || error "Failed to define VM from XML configuration for VM: $VM_NAME"

  # Start the VM
  virsh start "$VM_NAME" || error "Failed to start the imported VM: $VM_NAME"

  log "Successfully imported and started VM: $VM_NAME"
}

#  Main Execution Block 
if [ -z "$VM_NAME" ]; then
  echo "Usage: $0 <VM_NAME> [export|import]"
  exit 1
fi

if [ "$2" == "export" ]; then
  shutdown_vm  # Optional - comment out if not needed
  export_vm
elif [ "$2" == "import" ]; then
  import_vm
else
  echo "Usage: $0 <VM_NAME> [export|import]"
  exit 1
fi

exit 0

Utilisation du script

Rendre exécutable :

chmod +x kvm_export_import.sh

Exporter une VM :

./kvm_export_import.sh <vm_name> export

Importer une VM:

./kvm_export_import.sh <vm_name> import

Personnalisation et meilleures pratiques

Changez EXPORT_DIR, IMPORT_DIR, LOG_FILE en fonction de la disposition de votre serveur
Exécuter avec les autorisations appropriées (souvent sudo) et/ou ajouter un utilisateur au groupe `libvirt
Test dans une VM non en production d’abord
Pensez à ajouter la compression pour les grandes images (gzip, xz)
Pour les flux de travail à distance, étendez le script jusqu’à rsync/scp sur un serveur de sauvegarde
Après l’importation, confirmez le réseau VM, les chemins de stockage et les autorisations

Résolution des problèmes courants

Permission refusée

courir avec sudo
vérifier les permissions des fichiers sur les images
ajouter un utilisateur au groupe libvirt si nécessaire

Image disque introuvable

le chemin dans XML ne correspond pas à l’emplacement du disque sur le nouvel hôte
edit <source file='...'> en XML

*Problèmes de réseau**

vérifier les paramètres du pont hôte/NAT
vérifier la configuration de la NIC invitée après l’importation

Espace disque insuffisant

confirmer que la destination a suffisamment d’espace pour le disque VM complet

XML parse errors

XML corrompu ou modifié incorrectement
régénérer via virsh dumpxml sur l’hôte original si possible

Restrictions SELinux/AppArmor

vérifier les journaux, ajuster les politiques, définir les étiquettes/contextes corrects

Problèmes de compatibilité

confirmer que les deux hôtes ont des versions compatibles de libvirt/qemu/kvm

Conclusion

Vous avez maintenant un processus complet pour exporter et importer les machines virtuelles KVM dans Linux :

Méthode manuelle pour un contrôle et une compréhension complets
Script automatisé pour les flux de travail d’exportation/importation répétables

Utilisez les étapes manuelles lors du débogage ou de la migration entre différents environnements, et utilisez le script lorsque vous souhaitez des exportations et des restaurations rapides et cohérentes.

Blog, QEMU-KVM

kvm virtuel

Cet article est sous licence CC BY 4.0 par l'auteur.