Utiliser Vagrant avec un MacBook Mx (ARM64)

Emulation x86_64 sur arm64

Lorsque j’ai migré vers un Mac M1, j’ai rapidement réalisé que l’utilisation de Vagrant n’était plus aussi simple. J’ai donc dû mettre cet outil de côté, que j’adore pendant un certain temps. Cependant, récemment, sur LinkedIn, j’ai reçu sur un message vers un lien qui décrivait une solution utilisant QEMU comme provider pour Vagrant. Bien que la performance ne soit pas aussi fluide que sur x86, cette approche fonctionne et m’a permis de reprendre certaines de mes vieilles habitudes.

Les défis de l’architecture Apple Silicon

L’arrivée des processeurs Apple Silicon (M1/M2/M3) a marqué une révolution en offrant une efficacité énergétique exceptionnelle. Cependant, cette transition a aussi apporté son lot de défis, notamment pour les développeurs habitués aux environnements de virtualisation classiques.

Les processeurs M1/M2/M3 sont basés sur l’architecture ARM64, qui diffère fondamentalement de l’architecture x86 utilisée par la majorité des systèmes d’exploitation pour les serveurs et les environnements de développement. Par conséquent, de nombreux outils de virtualisation, comme VirtualBox, qui fonctionnent parfaitement sur les Mac Intel, ne sont pas compatibles avec les Mac ARM64. Cette incompatibilité a forcé de nombreux développeurs à chercher des solutions alternatives pour continuer à utiliser leurs workflows habituels.

L’un des principaux défis est l’émulation de l’architecture x86 sur les Mac Mx. QEMU est une solution potentielle, car il peut émuler différentes architectures, y compris x86 sur ARM. Cependant, cette solution n’est pas sans compromis. L’émulation complète d’une architecture x86 sur un processeur ARM64 est complexe et peut entraîner des ralentissements.

Installation de Vagrant sur Mac ARM64

L’installation de Vagrant sur un Mac ARM64 nécessite quelques étapes spécifiques. Voici comment procéder pour mettre en place un environnement fonctionnel.

Installer Homebrew

Avant de commencer, il est recommandé d’installer Homebrew, le gestionnaire de paquets pour macOS, si ce n’est pas déjà fait. Cela facilitera l’installation de Vagrant et de ses dépendances. Vous pouvez l’installer en exécutant la commande suivante dans le terminal :

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Installer Vagrant

Avec Homebrew installé, vous pouvez installer Vagrant en exécutant la commande suivante :

brew install vagrant

Cette commande téléchargera et installera la version la plus récente de Vagrant compatible avec votre système.

Installer QEMU comme fournisseur

Étant donné que VirtualBox n’est pas compatible avec les Mac M1/M2, il faut utiliser QEMU comme fournisseur pour Vagrant. QEMU est un émulateur capable de gérer des environnements virtualisés sur différentes architectures.

Installez QEMU en utilisant Homebrew :

brew tap hashicorp/tap
brew install hashicorp/tap/hashicorp-vagrant

Une fois QEMU installé, il faut ajouter le plugin QEMU pour Vagrant.

vagrant plugin install vagrant-qemu

Une première VM ARM64

Voici un exemple de configuration de base pour un Vagrantfile utilisant QEMU pour une machine tournant sur l’architecture ARM64 :

Vagrantfile
Vagrant.configure("2") do |config|
  config.vm.box = "perk/ubuntu-2204-arm64"
  config.vm.provider "qemu" do |qe|
    qe.ssh_port = "50022"
  end
end
EOF

Ce fichier spécifie que la machine virtuelle utilisera Ubuntu 22.04 comme système d’exploitation et QEMU comme fournisseur.

Après avoir écrit votre Vagrantfile dans un dossier, vous pouvez lancer votre machine virtuelle avec la commande suivante :

vagrant up

Cette commande démarrera la machine virtuelle en utilisant la configuration que vous avez spécifiée. Pour arrêter ou détruire la machine virtuelle, vous pouvez utiliser respectivement les commandes vagrant halt et vagrant destroy.

Une seconde VM X86_64

Dans de nombreux cas, il est indispensable de reproduire l’environnement de production le plus fidèlement possible pour s’assurer que les applications se comportent de manière identique en développement et en production. Cela est particulièrement vrai lorsqu’on travaille avec des architectures x86_64, qui sont encore largement utilisées sur les serveurs en production, alors que les Mac M1/M2 utilisent l’architecture ARM64.

Le Vagrantfile

Pour créer une VM x86_64 sur un Mac Mx, il faut configurer QEMU pour émuler l’architecture x86_64. Voici comment vous pouvez configurer votre Vagrantfile pour que cela fonctionne :

Vagrant.configure("2") do |config|
  config.vm.box = "generic/ubuntu2204"
  config.vm.synced_folder ".", "/vagrant", disabled: true
  config.vm.provider "qemu" do |qe|
    qe.qemu_dir = "/usr/bin/"
    qe.arch="x86_64"
    qe.memory = "2048"
    qe.smp = "4"
    qe.machine = "q35"
    qe.cpu = "max"
    qe.net_device = "virtio-net-pci"
  end
end

Ce Vagrantfile est conçu pour créer et configurer une machine virtuelle Ubuntu 22.04 en utilisant QEMU comme fournisseur. Voici un décryptage des principales lignes :

qe.qemu_dir = “/usr/bin/” : Indique le chemin où QEMU est installé.
qe.arch=“x86_64” : Définit l’architecture émulée comme étant x86_64.
qe.memory = “2048” : Alloue 2 Go de RAM à la VM.
qe.smp = “4” : Alloue 4 cœurs CPU à la VM.
qe.machine = “q35” : Spécifie le type de machine émulée (q35 est un modèle de machine moderne avec des fonctionnalités comme PCIe).
qe.cpu = “max” : Configure la CPU émulée pour utiliser toutes les fonctionnalités disponibles.
qe.net_device = “virtio-net-pci” : Utilise l’adaptateur réseau virtio-net-pci pour des performances réseau optimales dans la VM.

Lancement de la VM

Une fois votre Vagrantfile déposé, vous pouvez lancer votre machine virtuelle avec la commande suivante :

vagrant up

Comme cette configuration utilise QEMU pour émuler une architecture x86_64, il faut s’attendre à ce que le processus soit plus lent qu’une virtualisation native. Pendant le démarrage de la machine virtuelle, vous verrez souvent le message Warning: Connection reset. Retrying.... Cela signifie que la machine met du temps à répondre, ce qui est normal dans ce contexte. Il faudra être patient et attendre jusqu’à ce que vous voyiez finalement le message ==> default: Machine booted and ready!, indiquant que la VM est prête à être utilisée.

Une fois que votre machine virtuelle est démarrée, il est important de vérifier que l’architecture émulée est bien celle que vous avez configurée, à savoir x86_64. Pour cela, vous pouvez utiliser la commande suivante dans le terminal de la VM :

uname -m
x86_64

Cette commande affichera les informations relatives au processeur utilisé par la VM. Si tout est correctement configuré, vous devriez voir une mention de l’architecture x86_64 comme résultat. Cela confirme que notre VM émule bien l’architecture x86_64, vous permettant de travailler dans un environnement similaire à celui des systèmes de production basés sur cette architecture.

J’ai ensuite pu exécuter quelques commandes pour m’assurer que tout fonctionnait correctement. Par exemple, j’ai fait une mise à jour des packages pour confirmer que le réseau fonctionnait correctement.

Conclusion

Utiliser Vagrant sur un Mac M1/M2/M3 pour émuler une architecture x86_64 permet de reproduire des environnements de production, mais il est important de garder à l’esprit que les temps de réponse seront inévitablement plus lents. Cette solution reste néanmoins viable pour tester et développer dans des conditions proches de la réalité. Pour ceux qui souhaitent approfondir leurs connaissances sur Vagrant et découvrir d’autres configurations possibles, je vous invite à consulter ma section dédiée à Vagrant.

Source ↗