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 :
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.
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.
Remplissez en mettant le type à KVM, le Networking à default et le hostname à localhost puis cliquez sur create :
Après quelques instants, rafraîchissez la page. Le statuts doit passer à On :
L’installation de base est a présent terminée. Nous irons plus loin dans la configuration d’OpenNebula dans un prochain article.