Articles avec les mots clés ’qemu



1
Fév

Installation d’OpenNebula sous Archlinux (partie 1)

Présentation

Dans cette série d’articles, nous allons voir l’installation d’un mini cloud privé sous OpenNebula qui nous permettra de déployer et tester rapidement des machines virtuelles.

L’idée est la suivante :

opennebula

Notre serveur Opennebula sera relié au LAN par sa carte réseau physique eno1 qui posséde l’adresse IP 192.168.0.136
Le serveur Opennebula gérera un réseau virtuel 192.168.0.1/24 sur lequel les machines virtuelles seront déployées. Ce réseau virtuel n’est relié
à aucun réseau physique et n’a d’existence que pour le serveur OpenNebula. Une interface réseau virtuelle sera donc crée pour l’occasion (dummy0).
Ainsi, pour accéder aux VMs, nous passerons par un serveur VPN installé sur le serveur OpenNebula.

Le serveur OpenNebula utilisera l’hyperviseur kvm. Une virtualisation de ce serveur sous Virtualbox par exemple est donc impossible.

Installation du système

Traditionnellement, Opennebula s’installe via des paquets rpm ou deb en fonction de l’installation. Au jour d’aujourd’hui, le paquet aur sous archlinux n’est plus maintenu et ne propose pas l’installation de l’interface web sunstone.
Nous allons donc installer Opennebula depuis les sources sur une distribution Archlinux.

Je ne détallerai pas l’installation du système a proprement parler, des guides d’installations très bien faits existent déjà.

Les paquets à installer sont ceux « de base » .La commande a utiliser est : pacstrap /mnt base base-devel

Si vous utilisez grub, je vous conseille néanmoins d’exécuter la commande grub-mkconfig -o /boot/grub/grub.cfg après grub-install –no-floppy –recheck /dev/sda.

Configuration du réseau

Par défaut, l’interface réseau est configurée pour obtenir son adresse IP via un dhcp. Nous allons donc désactiver cette fonctionnalité et gérer les adresses de manière statique via netctl.

systemctl disable dhcpcd.service

Configurons l’interface reliée au lan en créant le fichier /etc/netctl/ethernet-static :

Description='Interface lan'
Interface=eno1
Connection=ethernet
IP=static
Address=('192.168.0.136/24')
Gateway='192.168.0.1'
DNS=('192.168.0.1')

Dans mon cas, cette interface se nomme eno1, vous pouvez connaitre le nom de la votre à l’aide de la commande ip address show.

Nous allons créer l’interface virtuelle qui nous permettra d’accéder au lan des vm. Ils nous faut créer le fichier /etc/netctl/dummy-interface .

Description='Interface virtuelle'
Interface=dummy0
Connection=dummy

Cette interface virtuelle sera reliée à un pont virtuel. Il nous faut donc créer le fichier /etc/netctl/bridge :

Description="Bridge"
Interface=br0
Connection=bridge
BindsToInterfaces=(dummy0)
IP=static
Address=('192.168.1.1/24')
SkipForwardingDelay=yes

Une fois ces trois fichiers crées, ils nous faut les activer pour les modifications soient prises en compte au prochain reboot :

netctl enable ethernet-static
netctl enable bridge
netctl enable dummy-interface

Préparation du système

Nous allons installer qemu :

pacman -S qemu

et créer l’utilisateur oneadmin qui sera utilisé pour l’instance d’OpenNebula :

groupadd oneadmin
useradd -s /bin/bash -g oneadmin -d /var/lib/one oneadmin
gpasswd -a oneadmin kvm
passwd -l oneadmin

A l’aide de la commande visudo, nous allons ajouter ces deux lignes :

oneadmin ALL = NOPASSWD: /sbin/iptables
oneadmin ALL = NOPASSWD: /bin/vgdisplay

Nous allons installer openssh :

pacman -S openssh
systemctl enable sshd
systemctl start sshd

Nous allons maintenant positionner le mot de passe pour l’administrateur opennebula (login : oneadmin, mot de passe : mypassword). Personnalisez le mot de passe, bien entendu :

su - oneadmin
cd /var/lib/one/
mkdir .one
cd .one
echo "oneadmin:mypassword" > one_auth
exit

Ils nous faut configurer openssh pour que l’utilisateur oneadmin puisse faire un ssh en local sans mot de passe :

su - oneadmin
cd /var/lib/one/
mkdir .ssh
ssh-keygen -t rsa 
cp .ssh/id_rsa.pub .ssh/authorized_keys
cat << EOT > .ssh/config
Host *
    StrictHostKeyChecking no
    UserKnownHostsFile /dev/null
EOT
chmod 600 .ssh/config
exit

Puis nous testons que la connexion sans mot de passe fonctionne :

su - oneadmin
ssh localhost

Nous fermons la connexion ssh et repassons alors en root pour poursuivre.

Nous allons installer toutes les dépendances et pré-requis :

pacman -S wget gcc make ruby xmlrpc-c openssl sqlite3 libxml2 curl libxslt expat cdrkit log4cpp scons nfs-utils flex bison npm nodejs git libldap libvirt memcached python linux-headers python-numpy python2-numpy

Installation d’Opennebula

Nous allons installer la dernière version disponible à ce jour, c’est à dire la 4.14.2
Pour ceci, nous allons créer un répertoire /usr/local/sources et effectuer la compilation dedans :

mkdir -p /usr/local/sources
cd  /usr/local/sources
wget http://downloads.opennebula.org/packages/opennebula-4.14.2/opennebula-4.14.2.tar.gz
tar zxf opennebula-4.14.2.tar.gz
cd opennebula-4.14.2
npm install -g bower
npm install -g grunt
npm install -g grunt-cli
cd /usr/local/sources/opennebula-4.14.2/src/sunstone/public
npm install
bower  --allow-root install
cd /usr/local/sources/opennebula-4.14.2/
scons new_xmlrpc=yes sqlite=yes sunstone=yes syslog=yes

Puis nous procédons à l’installation :

cd /usr/local/sources/opennebula-4.14.2/
./install.sh -u oneadmin -g oneadmin 
mkdir -p /var/lock/one
mkdir -p /var/log/one
chown oneadmin:oneadmin /var/lock/one
chown oneadmin:oneadmin  /var/log/one

Sunstone, l’interface web d’OpenNebula, s’appuie sur quelques gems. Pour les installer nous éditions d’abord le fichier /etc/gemrc pour modifier la ligne

gem: --user-install 

et y mettre à la place :

gem: --no-user-install

Nous installons ensuite les gems :

gem install amazon-ec2 aws-sdk aws-sdk-core aws-sdk-resources azure builder configparser curb daemons eventmachine faraday faraday_middleware jmespath macaddr mime-types  mini_portile  multipart-post net-ldap nokogiri parse-cron polyglot rack rack-protection rake sequel sinatra  sqlite3  systemu  thor tilt treetop trollop  uuid xml-simple memcache-client

Post-installation

Nous allons créer le fichier /etc/tmpfiles.d/opennebula.conf et y mettre :

d /run/lock/one 0755 oneadmin oneadmin

afin de créer le répertoire /run/lock/one à chaque démarrage du système. Rebootez pour vérifier le répertoire /run/lock/one est bien présent.

Nous allons maintenant créer les scripts de démarrage. Tout d’abord /usr/lib/systemd/system/opennebula.service

[Unit]
Description=OpenNebula Daemon
Requires=systemd-tmpfiles-setup.service
Before=opennebula-scheduler.service
BindTo=opennebula-scheduler.service
After=systemd-tmpfiles-setup.service

[Service]
Type=simple
Group=oneadmin
User=oneadmin
ExecStart=/usr/bin/oned -f
ExecStartPre=/bin/mkdir -p /var/log/one
ExecStartPre=/bin/chown oneadmin:oneadmin /var/log/one
ExecStop=/bin/kill -TERM $MAINPID
PIDFile=/var/run/one/oned.pid

[Install]
WantedBy=multi-user.target

puis /usr/lib/systemd/system/opennebula-sunstone.service :

[Unit]
Description=OpenNebula Sunstone
Requires=opennebula.service
Requires=opennebula-novnc.service
After=opennebula.service
After=opennebula-novnc.service

[Service]
Type=simple
Group=oneadmin
User=oneadmin
ExecStart=/usr/bin/ruby /usr/lib/one/sunstone/sunstone-server.rb
PIDFile=/var/run/one/sunstone.pid

[Install]
WantedBy=multi-user.target

Ensuite /usr/lib/systemd/system/opennebula-novnc.service :

[Unit]
Description=OpenNebula noVNC Server
Before=opennebula-sunstone.service

[Service]
Type=forking
Group=oneadmin
User=oneadmin
ExecStart=/usr/bin/novnc-server start
PIDFile=/var/lock/one/.novnc.lock

[Install]
WantedBy=multi-user.target

et enfin /usr/lib/systemd/system/opennebula-scheduler.service :

[Unit]
Description=OpenNebula Cloud Scheduler Daemon
Requires=opennebula.service
After=opennebula.service
BindTo=opennebula.service

[Service]
Type=simple
Group=oneadmin
User=oneadmin

ExecStart=/usr/bin/mm_sched
ExecStop=/bin/kill -TERM $MAINPID
PIDFile=/var/run/one/sched.pid

Configuration

Pour le moment, nous allons configurer le strict minimum. Par défaut sunstone n’autorise la connexion que depuis le localhost.

Il nous faut donc editer le fichier /etc/one/sunstone-server.conf et remplacer :

:host: 127.0.0.1 
:sessions: memory

par

:host:  0.0.0.0
:sessions: memcache

Nous allons ensuite configurer qemu. Nous allons d’abord éditer le fichier /etc/libvirt/qemu.conf et y ajouter :

user="oneadmin"
group="oneadmin"
dynamic_ownership = 0

Editons ensuite le fichier /etc/libvirt/libvirtd.conf :

unix_sock_group = "oneadmin"
auth_unix_ro = "none"
auth_unix_rw = "none"

Enfin, modifions le fichier /etc/one/vmm_exec/vmm_exec_kvm.conf pour y mettre la ligne :

EMULATOR = /usr/bin/qemu-system-x86_64

Démarrage des services

Avant de lancer les services, il faut effectuer une modification dans le fichier /usr/lib/one/ruby/OpenNebulaVNC.rb et remplacer la ligne :

  cmd ="python #{@proxy_path} #{proxy_options} #{@proxy_port}"

par

 cmd ="python2 #{@proxy_path} #{proxy_options} #{@proxy_port}"

Nous pouvons ensuite lancer les scripts de démarrage :

systemctl enable libvirtd.service
systemctl enable virtlogd.service
systemctl enable memcached
systemctl enable opennebula.service
systemctl enable opennebula-novnc.service
systemctl enable opennebula-sunstone.service
systemctl start libvirtd.service
systemctl start virtlogd.service
systemctl start memcached
systemctl start opennebula.service
systemctl start opennebula-novnc.service
systemctl start opennebula-sunstone.service

Si tout se passe bien, vous pouvez vous logguer via à navigateur web à l’adresse http://192.168.1.136:9869 à l’aide de l’utilisateur oneadmin et le mot de passe que vous avez spécifié lors de la création du fichier one_auth.
sunstone

Allez ensuite dans le menu Infrastructure -> host et cliquez sur le ‘+’ vert pour ajouter un hyperviseur. Opennebula peut gérer plusieurs hyperviseur et y accède en ssh. Dans notre cas, tout a été installé sur la même machine.
addhost1

Remplissez en mettant le type à KVM, le Networking à default et le hostname à localhost puis cliquez sur create :
addhost2

Après quelques instants, rafraîchissez la page. Le statuts doit passer à On :
addhost3
L’installation de base est a présent terminée. Nous irons plus loin dans la configuration d’OpenNebula dans un prochain article.

Le thème Celadon pour WordPress a été créé par Themes Boutique