Articles avec les mots clés ’virtualisation’
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.
VMware WSX : Accéder à une machine virtuelle depuis un navigateur Web
VMware WSX est une fonctionnalité apparue avec VMware Workstation 9. Elle permet aux utilisateurs d’accéder à distance à des machines virtuelles directement depuis un simple navigateur Web et sans aucun plug-in. La technologie HTML 5 est utilisée pour le déport d’affichage.
Depuis le site de VMware, téléchargez la version pour Windows de VMware WSX dans la rubrique consacrée à VMware Workstation.
Lancez l’exécutable Vmware-WSX-Server-1.0.0-842025.msi. L’assistant d’installation de VMware WSX s’ouvre. Cliquez sur le bouton Next.
Acceptez la licence d’utilisation. Vous devez choisir le port d’écoute pour le protocole HTTP (par défaut, 8888). Cliquez sur le bouton Next.
Cliquez sur le bouton Install pour procéder à l’installation de VMware WSX, puis Finish pour quitter l’assistant d’installation. Dans les services Windows, on peut vérifier que le service VMware WSX Service est en fonctionnement.
A l’aide de votre navigateur Web, allez à l’adresse suivante http://localhost:8888/. Un compte local membre du groupe Administrateurs est nécessaire pour s’authentifier. A noté que les utilisateurs de domaine ne sont pas supportés.
VMware WSX fonctionne avec les dernières version de Chrome, Firefox, Safari.
La page d’accueil est le point d’entrée pour accéder à vos serveurs. Si vous avez installé VMware WSX sur la même machine que VMware Workstation 9, ce qui est notre cas, les machines virtuelles que vous avez partagé seront répertoriées dans la partie Share VMs (localhost).
Vous pouvez aussi vous connecter à des serveurs VMware ESXi distant en cliquant sur le bouton Add a server.
Une machine virtuelle partagée est une machine virtuelle exécutée sur un système hôte où les utilisateurs peuvent y accéder à distance, en fonction de leurs permissions.
Depuis VMware Workstation 9, nous allons partager une machine virtuelle. Pour commencer, il est nécessaire de vérifier que le service VMware Workstation Server est activé dans les préférences. Ce qui est le cas, par défaut.
Ensuite, sélectionnez la machine virtuelle et allez dans le menu VM, Manage et cliquez sur Share.
L’assistant d’installation de Share Virtual Machine Wizard s’ouvre. Cliquez sur le bouton Next.
Entrez le nom de la machine virtuelle à partagée et sélectionnez l’option Move the virtual machine pour la déplacer dans l’emplacement correspondant aux machines virtuelles partagées. Cliquez sur le bouton Finish.
Une fois l’opération de déplacement est terminée, vous pouvez cliquer sur le bouton Close.
La machine virtuelle partagée se trouve à présent sous le nœud Shared VMs.
Nous allons vérifier les permissions pour les machines virtuelles partagées. Dans le menu surgissant de Shared VMs, cliquez sur Permissions.
Par défaut, le groupe local Administrateurs possède le rôle Administrator. Cliquez sur le bouton OK.
Depuis l’interface Web de VMware WSX, cliquez sur Shared VMs (localhost).
Entrez les identifiants de connexion pour accéder aux machines virtuelles partagées.
La liste des des machines virtuelles sont listées. Cliquez sur une machine virtuelle pour y accéder.
Vous pouvez démarrer, arrêter ou suspendre la machine virtuelle. A noté que le clavier est en QWERTY.
Vous pouvez lancer plusieurs applications Windows pour tester le fonctionnement.
Plusieurs actions peuvent être effectué à travers les icônes situés en bas à droite de la console :
– Rechargement de la page
– Affiche le clavier pour les tablettes
– Envoie la combinaison de touches Ctrl+Alt+Delete
– Cacher le panel de gauche
– Mettre en plein écran
Le fonctionnement en local validé, nous allons ajouter une nouvelle règle dans le pare-feu pour pouvoir se connecter à VMware WSX à distance.
Depuis la console Pare-feu Windows avec fonctions avancées de sécurité, créez une nouvelle règle entrante.
Sélectionnez l’option TCP et l’option Ports locaux spécifiques. Entrez 8888 comme port local (port de VMware WSX, par défaut). Cliquez sur le bouton Suivant.
Sélectionnez l’option Autoriser la connexion et cliquez sur le bouton Next.
Cochez les profils qui s’applique à cette règle. Cliquez sur le bouton Suivant.
Entrez le nom pour cette nouvelle règle et cliquez sur le bouton Terminer.
La règle est créé dans le pare-feu.
Vous pouvez maintenant vous connecter à distance à VMware WSX.