pacman -S nginx

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;
          }
    }
 
	…
}

systemctl enable nginx
systemctl start nginx

:host: 0.0.0.0

:host: 127.0.0.1

systemctl stop opennebula-sunstone.service
systemctl start opennebula-sunstone.service

groupadd vpn

useradd -s /usr/bin/nologin -M -g vpn beroot
passwd beroot

pacman -S openvpn iptables easy-rsa

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"

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

vpn

mkdir -p /etc/openvpn/keys
cp -r /usr/share/easy-rsa /etc/openvpn/

cd /etc/openvpn/easy-rsa
vim vars

 . ./vars
 ./clean-all
 ./build-ca
 ./build-key-server server
 ./build-dh

 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/

systemctl enable openvpn@server.service
systemctl start openvpn@server.service

*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

net.ipv4.ip_forward = 1

systemctl enable iptables.service
systemctl start iptables.service
sysctl -p

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.