Installation d’OpenNebula sous Archlinux (partie 2)
Dans cet article nous allons poursuivre l’installation de notre plateforme cloud utilisant OpenNebula sur une distribution Archlinux.
Nous avons vu que, par défaut, sunstone écoute sur le port 9869/tcp. Pour faciliter l’utilisation, nous allons mettre un reverse-proxy nginx en place. Ce dernier écoutera sur le port 80/tcp et enverra les requêtes à sunstone.
Mise en place de Nginx
L’installation se fait de manière classique sous Archlinux :
pacman -S nginx
La configuration se fait en éditant le fichier /etc/nginx/nginx.conf et en inserant un bloc server dans la section http :
http {
…
server {
listen 80 default_server;
server_name _;
# A regler en fonction des images qcow2 que l'on souhaite uploader dans sunstone
client_max_body_size 29G;
location / {
proxy_pass http://127.0.0.1:9869;
}
}
…
}
Le démarrage de nginx se fait à l’aide des commandes :
systemctl enable nginx systemctl start nginx
Nous pouvons maintenant dire à sunstone de n’autoriser des requêtes que depuis le localhost.
Il nous faut éditer le fichier /etc/one/sunstone-server.conf et modifier la ligne :
:host: 0.0.0.0
en
:host: 127.0.0.1
et relancer le service :
systemctl stop opennebula-sunstone.service systemctl start opennebula-sunstone.service
A présent si nous effectuons une requête depuis un navigateur web sur http://192.168.0.136 sans spécifier de port (a modifier bien sur en fonction de l’adresse de votre serveur opennebula),
nous obtenons la page d’accueil de sunstone :
Installation d’OpenVPN
Vu que les VMs deployées par OpenNebula seront reliées à un switch virtuel n’ayant aucune connexion avec un quelconque réseau physique, nous devons installer un service VPN sur notre serveur OpenNebula qui nous permettra accéder aux machines.
Pour simplifier les choses, openvpn sera configuré pour authentifier les utilisateurs via leur compte système via les PAM. Nous allons d’abord créer un groupe « vpn » :
groupadd vpn
Nous allons donc créer le compte d’un utilisateur (ici beroot qui pourra se connecter au vpn :
useradd -s /usr/bin/nologin -M -g vpn beroot passwd beroot
Installons OpenVPN :
pacman -S openvpn iptables easy-rsa
Créons le fichier de configuration d’OpenVPN /etc/openvpn/server.conf :
port 1194 proto udp dev tun0 ca /etc/openvpn/keys/ca.crt cert /etc/openvpn/keys/server.crt key /etc/openvpn/keys/server.key dh /etc/openvpn/keys/dh2048.pem server 10.8.0.0 255.255.255.0 ifconfig-pool-persist ipp.txt client-to-client keepalive 10 120 comp-lzo max-clients 100 user nobody group nobody persist-key persist-tun status /var/log/openvpn-status.log log-append /var/log/openvpn.log verb 4 client-cert-not-required plugin /usr/lib/openvpn/plugins/openvpn-plugin-auth-pam.so openvpn push "route 192.168.1.0 255.255.255.0"
Créons le fichier /etc/pam.d/openvpn :
auth required pam_listfile.so onerr=fail item=group sense=allow file=/etc/pam.d/openvpn.allowed auth sufficient pam_unix.so try_first_pass likeauth nullok auth required pam_deny.so account required pam_unix.so session required pam_unix.so
et le fichier /etc/pam.d/openvpn.allowed qui contient juste le nom du groupe unix autorisé à se connecter au vpn :
vpn
Il nous faut maintenant préparer l’environnement qui va nous permettre de créer les clés de cryptage :
mkdir -p /etc/openvpn/keys cp -r /usr/share/easy-rsa /etc/openvpn/
Nous éditons ensuite le fichier vars et le modifions en fonction de notre localisation.
cd /etc/openvpn/easy-rsa vim vars
Nous générons ensuite les clés :
. ./vars ./clean-all ./build-ca ./build-key-server server ./build-dh
Puis nous les copions à l’endroit approprié :
cp keys/ca.crt /etc/openvpn/keys/ cp keys/ca.key /etc/openvpn/keys/ cp keys/server.crt /etc/openvpn/keys/ cp keys/server.key /etc/openvpn/keys/ cp keys/dh2048.pem /etc/openvpn/keys/
Vous pouvez déjà exporter le fichier /etc/openvpn/keys/ca.crt car il sera à installer sur les clients vpn par la suite.
Nous pouvons alors démarrer le service openvpn :
systemctl enable openvpn@server.service systemctl start openvpn@server.service
Le serveur vpn est en service mais il faut que nous paramétrions quelques règles iptables pour rendre le système utilisable.
Mise en place de règles iptables
Créons le fichier /etc/iptables/iptables.rules (remplacez eno1 par le nom de votre interface réseau) :
*nat :PREROUTING ACCEPT [0:0] :OUTPUT ACCEPT [0:0] :POSTROUTING ACCEPT [0:0] -A POSTROUTING -s 192.168.1.0/24 -j MASQUERADE COMMIT *filter :INPUT DROP [0:0] :FORWARD ACCEPT [0:0] :OUTPUT ACCEPT [0:0] -A INPUT -i lo -j ACCEPT -A OUTPUT -o lo -j ACCEPT -A INPUT -i br0 -j ACCEPT -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT -A OUTPUT -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT -A INPUT -m state --state NEW -m tcp -p tcp --dport 22 -j ACCEPT -A INPUT -m state --state NEW -m tcp -p tcp --dport 80 -j ACCEPT -A INPUT -m state --state NEW -m tcp -p tcp --match multiport --dports 5900:6000 -j ACCEPT -A INPUT -m state --state NEW -m tcp -p tcp --dport 29876 -j ACCEPT -A INPUT -i eno1 -p udp --dport 1194 -j ACCEPT COMMIT
Créons un fichier /etc/sysctl.d/iptables.conf :
net.ipv4.ip_forward = 1
Démarrons l’ensemble :
systemctl enable iptables.service systemctl start iptables.service sysctl -p
Ce deuxième article sur la configuration de notre plateforme OpenNebula s’achève ici. Le système est utilisable dans l’état mais nous irons encore plus loin dans un prochain article …
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 :
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.
Installation de GLPI sous CentOS 7
GLPI (Gestionnaire Libre de Parc Informatique) est une solution libre de gestion de parc informatique. Il s’agit d’une application Web écrite en PHP où les différents éléments (matériel, logiciels, licences, contrats, interventions, …) constituant votre parc peuvent être organisés et gérés.
Dans cette documentation, nous allons installer la dernière version stable de GLPI (0.90.1) sur une distribution CentOS 7 de manière fonctionnelle. Cette procédure d’installation ne sera donc ni optimisée, ni sécurisée. Nous aurons besoin d’un serveur Web (Apache/HTTPD), d’une base de données de type MySQL (MariaDB remplace MySQL sous CentOS 7) et de PHP.
A noter qu’un paquet glpi est également disponible dans le dépôt EPEL (Extra Packages for Enterprise Linux). Nous n’utiliserons pas ce dépôt.
Ces opérations sont à réaliser en tant qu’utilisateur root.
– Désactivez SELinux de façon permanente à travers son fichier de configuration : vi /etc/selinux/config
SELINUX=disabled
– La prise en compte de ce changement nécessite un redémarrage de la machine : reboot
GLPI requiert l’installation d’extensions PHP (CType, FileInfo, GD, JSON, Mbstring, MySQLi, Session, Zlib). Certaines extensions sont incluses directement dans le paquet php et d’autres doivent être installées explicitement. Dans le cas où vous souhaiteriez mettre en place une méthode d’authentification externe, d’autres extensions PHP seront à prévoir. Dans notre exemple, nous utiliserons une base locale de comptes pour l’authentification.
– Installez les paquets suivants (serveur Apache/HTTPD, PHP, extensions PHP, serveur MariaDB et l’utilitaire wget) : yum install httpd php php-mysql php-gd php-mbstring mariadb-server wget
– Lancez le serveur MariaDB au démarrage de la machine : systemctl enable mariadb
– Lancez le serveur MariaDB : systemctl start mariadb
– Exécutez l’utilitaire mysql_secure_installation pour sécuriser l’installation de MariaDB : mysql_secure_installation
> Enter current password for root (enter for none): > OK, successfully used password, moving on... > Set root password? [Y/n] Y > New password: > Re-enter new password: > Remove anonymous users? [Y/n] Y > Disallow root login remotely? [Y/n] Y > Remove test database and access to it? [Y/n] Y > Reload privilege tables now? [Y/n] Y
Pour commencer, l’utilitaire mysql_secure_installation nous demande le mot de passe actuel de l’utilisateur root (celui de MariaDB). Ce mot de passe est vide par défaut. Ensuite, plusieurs questions vous sont posées pour sécuriser l’installation de MariaDB : affecter un mot de passe à l’utilisateur root, supprimer les connexions anonymes, désactiver la possibilité à l’utilisateur root de se connecter à distance, supprimer la base de données prédéfinie test et recharger les privilèges des tables.
GLPI nécessite la création d’une base de données spécifique à son utilisation.
– Lancez l’invite de commandes de MariaDB/MySQL : mysql -u root -p
> Enter password: > MariaDB [(none)]> CREATE DATABASE glpidb; > MariaDB [(none)]> GRANT ALL PRIVILEGES ON `glpidb` .* TO 'glpiuser'@'localhost' IDENTIFIED BY 'MotDePasse'; > MariaDB [(none)]> quit
Le mot de passe de l’utilisateur root est demandé. Il s’agit d’entrer le mot de passe que vous avez choisi précédemment. La première commande SQL créé la base de données glpidb. La deuxième commande créé et associe l’utilisateur glpiuser avec cette base de données en lui octroyant les autorisations adéquates. Vous êtes bien entendu encouragé à modifier le mot de passe de l’utilisateur glpiuser.
Nous allons maintenant configurer le serveur Web pour les besoins de GLPI.
– Éditez le fichier de configuration de PHP afin de préciser le fuseau horaire : vi /etc/php.ini
[Date] date.timezone = "Europe/Paris"
Lors de l’installation de GLPI, le script d’installation vérifie que les répertoires config et files ne soient pas accessibles.
– Créez le fichier de configuration pour interdire l’accès aux répertoires config et files : vi /etc/httpd/conf.d/glpi.conf
<Directory "/var/www/html/glpi/config">
AllowOverride None
Require all denied
</Directory>
<Directory "/var/www/html/glpi/files">
AllowOverride None
Require all denied
</Directory>
– Lancez le serveur Apache/HTTPD au démarrage de la machine : systemctl enable httpd
– Lancez immédiatement le serveur Apache/HTTPD : systemctl start httpd
CentOS 7 introduit le concept de zone réseau avec le pare-feu firewalld. Ce qui permet d’appliquer des règles en fonction de la zone réseau sur lequel on se trouve. Par défaut, la zone réseau est nommée public. Nous allons autoriser le service http pour la zone public de manière permanente et recharger les règles.
– firewall-cmd –permanent –zone=public –add-service=http
– firewall-cmd –reload
Nous allons passer à l’installation de GLPI.
– Placez-vous dans le répertoire suivant : cd /usr/local/src/
– Téléchargez la dernière version stable de GLPI (0.90.1 lors de l’écriture cette documentation) à l’aide de l’utilitaire wget : wget https://github.com/glpi-project/glpi/releases/download/0.90.1/glpi-0.90.1.tar.gz
– Décompressez l’archive de GLPI à la racine des documents du serveur Web : tar -xzvf glpi-0.90.1.tar.gz -C /var/www/html/
– Modifiez le propriétaire de manière récursive sur le répertoire de GLPI : chown -R apache:apache /var/www/html/glpi/
A l’aide de votre navigateur Web, vous devez entrer l’adresse du serveur Web suivi de glpi (http://xxx.xxx.xxx.xxx/glpi/). Un assistant vous guide dans l’installation de GLPI.
Sélectionnez la langue française dans la liste déroulante.
Acceptez la licence d’utilisation.
Une nouvelle installation complète doit être choisie.
Plusieurs tests sont effectués pour vérifier si les extensions PHP et la configuration sont conformes aux besoins de GLPI.
Indiquez les paramètres de connexion à la base de données.
Sélectionner la base de données existante glpidb.
Les différentes tables sont alors créées dans cette base de données.
L’assistant vous indique les comptes utilisateurs prédéfinis.
– Supprimez le script d’installation de GLPI : rm -f /var/www/html/glpi/install/install.php
Vous pouvez maintenant vous authentifier à l’interface Web de GLPI avec l’utilisateur glpi dont le mot de passe par défaut est aussi glpi.
Depuis le menu Administration, et le sous-menu Utilisateurs, vous pouvez modifier les mots de passe attribués aux utilisateurs prédéfinis (glpi, post-only, tech et normal).