Est-il possible d'installer un logiciel de machine virtuelle en tant qu'utilisateur non root et de l'exécuter?

Quelles machines virtuelles peuvent être installées sans avoir besoin d'un accès root?

Si ce n'est pas possible, quelle serait la machine virtuelle la plus légère à utiliser pour quelques machines virtuelles Windows XP SP3?

Toute virtualisation réelle nécessite un accès de bas niveau au CPU, et donc root doit l'installer. Une fois installé, vous n'avez pas besoin d'être root pour l'exécuter. Vous pouvez probablement installer et exécuter un émulateur non root, tel que bochs, ou un adaptateur tel que wine. Si vous avez une application Windows spécifique à l'esprit, vous pouvez simplement l'exécuter sous wine (peut-être).

Pour KVM , vous devez avoir accès au périphérique /dev/kvm. Si votre utilisateur peut lire / écrire sur ce périphérique, vous pouvez exécuter des machines virtuelles basées sur KVM en tant qu'utilisateur.

Dans la plupart des distributions, les membres du kvmgroupe ont accès à cet appareil, donc tout ce que vous avez à faire est d'ajouter votre utilisateur au kvmgroupe.

Pour la plupart des autres technologies accélérées, vous aurez besoin de modules de noyau chargés (cela inclut virtualbox et VMWare). Cela nécessite presque certainement un accès au niveau racine.

Vous pouvez exécuter des technologies de virtualisation non accélérée comme n'importe quel utilisateur. Par exemple, qemu en mode non accéléré. Sachez que ce sera très lent par rapport à la virtualisation accélérée.

Mode utilisateur Linux est une solution de virtualisation Linux qui s'exécute entièrement dans l'espace utilisateur - aucun privilège root requis.

Cependant, il ne peut exécuter qu'un invité Linux au sein d'un hôte Linux, il n'est donc pas adapté si vous souhaitez exécuter autre chose.

Une machine virtuelle a besoin d'un accès de bas niveau au processeur (et à tout autre matériel) pour être efficace. Par conséquent, vous ne verrez aucun logiciel de VM performant pouvant être installé non root.

Quant aux machines virtuelles légères, la légèreté est obtenue en n'incluant que les fonctionnalités nécessaires. Cela nécessite une certaine connaissance du système d'exploitation qui sera exécuté, et les machines virtuelles légères open source ( Plex86 , LilyVM ) ne prennent en charge que les systèmes d'exploitation open source. Selon cette logique, il se peut que Microsoft Virtual PC soit plus léger que VirtualBox / VMWare / etc. mais je ne sais vraiment pas. VirtualBox est disponible en open-source, est tout à fait utilisable et a toujours été suffisant pour mes besoins (mais j'en ai essayé d'autres).

Virtualbox 4.0.8 doit être installé en tant que root root, mais vous pouvez ensuite laisser les utilisateurs créer leurs propres machines virtuelles. Vous devez juste être membre du groupevboxusers

usermod -G vboxusers USERNAME

Jetez un oeil à ce lien , bel article comment l'exécuter sans tête, directement à partir du shell. Je creuse aussi vraiment qu'il prend en charge le protocole RDP, ce qui signifie que vous pouvez simplement l'utiliser rdesktoppour vous connecter.

QEmu est capable de le faire. Je l'ai fait plusieurs fois. Pas très performant cependant

1) Réponse en trois lignes

Pour utiliser mes images prédéfinies / version compilée de qemu, téléchargez-la à partir d' ici , puis décompressez-la:

tar -xvzf qemu_packed.tar.gz

vous pouvez également télécharger mon image debian 8 (1.6G) ici :

tar -xvzf test01.qcow2.tar.gz

et enfin courir

./command.sh

Vous devriez avoir une Debian 8 fonctionnelle, en mode texte, avec le port ssh ouvert dans l'invité hôte au port 22222. Vous pouvez vous connecter en utilisant l'utilisateur "root" et le mot de passe "root".

2) Réponse plus longue, faites vous-même ces images

QEMU est en effet une solution qui m'a permis d'installer ma propre image linux sur un serveur sur lequel je n'avais pas d'accès root. C'est très utile, je l'utilise par exemple pour faire du reverse ssh sans révéler mon mot de passe utilisateur principal, ou à des fins pédagogiques. Mais en effet, comme vous ne pouvez pas utiliser KVM pour une véritable virtualisation sans compte root, vous ne pourrez faire que l'émulation, ce qui peut être assez inefficace (mais pour les opérations en ligne de commande, je n'ai jamais vraiment vu le surcoût).

2.1) Pack qemu

Voici la description de la façon dont je procède. La première étape consiste à rendre qemu "portable", c'est-à-dire utilisable sur le serveur sans accès root. Pour ce faire vous disposez de plusieurs méthodes, je vais essayer de les présenter afin que vous puissiez choisir celle que vous préférez.

2.1.a) Méthode 1: téléchargez le .deb disponible

Cette solution peut être très rapide à appliquer (essentiellement si cela fonctionne, dans 1 commande vous l'obtenez), mais parce que mon script peut être bogué / peut oublier une bibliothèque, il peut être assez long de télécharger manuellement tous les binaires ... un autre avantage de cette méthode est que vous pouvez l'exécuter en mode non root, directement sur le serveur. L'idée d'obtenir des binaires qemu ici est d'obtenir le fichier .deb / .rpm (à partir d'apt ou des sites Web en ligne qui hébergent .deb), de l'extraire, de vérifier les dépendances des bibliothèques à l'aide lddet de télécharger toutes .debles dépendances qui sont pas déjà présents sur l'ordinateur pour les extraire (les .sofichiers). Parce qu'il peut être assez long et répétitif, j'ai créé un petit script, mais si vous êtes courageux, vous pouvez faire tout cela manuellement ... Cela prend juste du temps. Pour l'utiliser, enregistrez ce script dans un fichiercreate_qemu_binaries.sh:

#!/usr/bin/env bash
mkdir qemu_extract
cd qemu_extract
echo "########## Downloading qemu... ##########"
apt-get download qemu-system-x86
echo "########## Extracting qemu... ##########"
dpkg -x qemu-system-*.deb .
mkdir -p qemu_packed/lib
cp usr/bin/qemu-system-x86_64 qemu_packed
echo "########## Copy libs... ##########"
ldd usr/bin/qemu-system-x86_64 | grep "=>" | grep -v "not found" | awk '{print "cp "$3" qemu_packed/lib/"}' | bash
mkdir not_found
cd not_found
echo "########## Get not found libs... ##########"
ldd ../usr/bin/qemu-system-x86_64 | grep "not found" | awk '{print $1}' > not_found.txt
echo "########## Download not found libs... ##########"
for lib in $(cat not_found.txt); do echo "=== Dealing with $lib ==="; apt-file search --regexp "/${lib}\$" | sed 's/:.*//' | xargs apt-get download; done
echo "########## Extracting not found libs... ##########"
ls *.deb | xargs -I{} dpkg -x "{}" .
echo "########## Copying not found libs... ##########"
find . | grep ".so" | xargs -I{} cp "{}" ../qemu_packed/lib
cd ..
echo "########## Getting pc-bios... ##########"
git clone https://github.com/qemu/qemu.git
cp -r qemu/pc-bios qemu_packed
echo "########## Finished !!! ##########"
echo "The output file should be in the folder qemu_extract/qemu_packed."
echo "Once you have a filesystem image, you can run it using:"
echo "$ LD_LIBRARY_PATH=$(pwd)/lib ./qemu-system-x86_64 -L pc-bios -no-kvm -m 256 -drive if=virtio,file=<your image>.qcow2,cache=none -display curses -k fr -redir tcp:22222::22"
echo "Don't forget to replace <your image>"

et l'exécuter en utilisant:

chmod +x create_qemu_binaries.sh 
./create_qemu_binaries.sh 

tout fonctionne bien, à la fin, vous devriez avoir dans le dossier ./qemu_extract/qemu_packed/un fichier qemu-system-x86_64(le binaire principal), un dossier lib(les bibliothèques qui doivent être prises avec qemu) et un dossier pc-bios, un ensemble de fichiers qemuà exécuter. Vous pouvez ensuite exécuter qemuen utilisant (n'oubliez pas de remplacer par votre image de système de fichiers):

$ LD_LIBRARY_PATH=$(pwd)/lib ./qemu-system-x86_64 -L pc-bios -no-kvm -m 256 -drive if=virtio,file=<your image>.qcow2,cache=none -redir tcp:22222::22

Prendre plaisir ! (si le script ne fonctionne pas pour vous, n'hésitez pas à me le demander, je l'ai testé uniquement sur deux ordinateurs, et remplissez-le gratuitement pour le supprimer redirsi vous n'avez pas besoin de transfert ssh entre l'hôte et la conjecture)

2.1.b) Méthode 2: si vous accédez à un ordinateur avec un accès root

La première méthode nécessite un ordinateur avec un accès root (ou qemuinstallé). Installez d'abord en qemuutilisant quelque chose comme

sudo apt install qemu-system-x86

puis localisez le chemin absolu de qemu:

$ which qemu-system-x86_64 
/usr/bin/qemu-system-x86_64

Ensuite, créez un dossier pour le mettre:

mkdir -p qemu_packed/lib
cd qemu_packed
cp /usr/bin/qemu-system-x86_64 qemu_packed

et obtenez la liste des bibliothèques liées à qemu:

ldd qemu_packed/qemu-system-x86_64 | awk '{print "cp "$3" qemu_packed/lib"}' | bash

maintenant, nous devons obtenir l'utilisation du BIOS par qemu. Les fichiers sont disponibles sur votre système, mais je ne sais pas pourquoi ils se trouvent dans différents dossiers, donc je pense qu'il est plus facile de les obtenir à partir des sources:

git clone https://github.com/qemu/qemu.git
cp -r qemu/pc-bios qemu_packed
cd qemu_packed

Maintenant, cela devrait fonctionner, vous pouvez copier ces fichiers sur la machine non root et exécuter simplement en qemuutilisant la ligne suivante (n'oubliez pas de remplacer l'image):

$ LD_LIBRARY_PATH=$(pwd)/lib ./qemu-system-x86_64 -L pc-bios -no-kvm -m 256 -drive if=virtio,file=<your image>.qcow2,cache=none

2.1.c) Méthode 3: à partir des sources

Vous pouvez également compiler les sources, mais si vous n'avez pas toutes les bibliothèques installées, il peut être difficile d'éviter d'utiliser un ordinateur rooté pour compiler qemu. Mais je suppose que c'est un peu plus fiable si les deux méthodes ci-dessus ne fonctionnent pas. Ensuite, une fois qu'il est compilé, récupérez le fichier exécutable et faites la même astuce que ci-dessus pour obtenir les bibliothèques (en utilisant ldd, toutes les bibliothèques devraient déjà être sur l'ordinateur) et le fichier pc-bios. Et encore une fois, exécutez-le avec la même commande.

2.3) Créez votre propre image

Si vous ne voulez pas utiliser une image de système de fichiers prédéfinie, suivez simplement les nombreux tutoriels en utilisant les commandes ci-dessus à la place de qemu/qemu-system-x86_64! NB: si vous souhaitez également utiliser qemu-imgpour créer des images en tant que non root, alors suivez le même processus que ci-dessus!

Prendre plaisir !

NB: si vous souhaitez utiliser l'affichage curses pour l'exécuter sur un serveur sans interface graphique, vous devez ajouter dans votre image une ligne dans l'option de démarrage afin qu'elle n'active pas le buffer de trame dans /etc/default/grub:

GRUB_CMDLINE_LINUX_DEFAULT="vga=normal nofb nomodeset bochs_drm.fbdev=off"

(le plus important est le dernier, je ne sais pas si c'est nécessaire). Aussi bien que

GRUB_TERMINAL=console
GRUB_GFXPAYLOAD_LINUX=text

afin que grub reste en mode texte. Vous pouvez également vouloir activer le mode texte dans systemd si cela ne suffit pas.