Version actuelle datée du 23 février 2016 à 10:19

Cette page est un guide pas à pas pour reconstruire l'architecture de notre projet sur une machine Debian (Jessie 8) avec un noyau Linux 3.16.0-4-amd64.

Sur la machine hôte

Mise à jour et outils pratiques

Sur une machine Debian Jessie, il est nécessaire d'installer les outils suivants :

apt-get update -y; apt-get upgrade -y; \
apt-get install -y xen-hypervisor-4.4-amd64 xen-tools sqlite3 nginx ssh xen-utils-common bridge-utils

Les outils suivants sont également conseillés :

apt-get install -y vim python curl lynx nmap

Création du bridge général

Nous créons une interface tap dédiée à la connexion des interfaces du bridge. L'interface eth0 est dédiée au support. Pour que la configuration soit identique si la machine redémarre, nous éditons le fichier /etc/network/interfaces comme suit :

# The loopback network interface
auto lo
iface lo inet loopback

# The primary network interface
auto eth0
iface eth0 inet static
 address 172.26.64.13
 netmask 255.255.240.0
 gateway 172.26.79.254

auto tap0
iface tap0 inet manual
#MASQUERADE
 pre-up iptables -t nat -A POSTROUTING -s 10.0.0.0/8 -j MASQUERADE
 pre-up ip tuntap add mode tap dev $IFACE
 pre-up ip addr add 172.26.79.230/20 dev $IFACE
 up ip link set dev $IFACE up
#post-up ip route add 172.26.79.230/32 dev $IFACE
 down ip link set $IFACE down
 post-down ip link del dev $IFACE

#Bridge réunissant les conteneurs 
auto Summoners
iface Summoners inet static
 bridge-ports tap0
 address 10.0.0.1
 netmask 255.0.0.0

La mascarade doit s'effectuer manuellement plutôt que l'option iptables-restore. En effet nous risquons d'écraser les nouvelles règles de routages de machines virtuelles Xen. La commande qui gère le routage est commentée, elle n'est à utiliser que si le routage ne se fait pas automatiquement.

Création des machines virtuelles Xen

Une fois les outils Xen installé, on créée autant de vm que nécessaire

xen-create-image --hostname=teemo --ip=10.2.0.1 --netmask=255.0.0.0 --gateway=10.0.0.1 \
--dir=/usr/local/xen --mirror=http://debian.polytech-lille.fr/debian/ --dist=jessie --passwd

Puis on lance la VM ainsi créée:

xl create /etc/xen/teemo.cfg

Sur la machine Xen

On se connecte à la machine Xen via la commande xl console teemo

Mise a jour et outils pratiques

Une fois reconnecté, nous devrions avoir une connexion internet valide.

apt-get update -y; apt-get upgrade -y; \
apt-get install -y vim curl nmap ssh bridge-utils

Pour activer le ssh :

sed -i 's/PermitRootLogin without-password/PermitRootLogin yes/' /etc/ssh/sshd_config; \
service ssh restart

Architecture réseau

Dans une premier temps il est nécessaire d'établir les bons paramètres réseaux. La création d'un bridge personnalisé nous servira par la suite pour y mettre tous les conteneurs. Il faut éditer le fichier /etc/network/interfaces comme suit :

# The loopback network interface
auto lo
iface lo inet loopback

auto eth0
iface eth0 inet static
 pre-up ip link set $IFACE up
 post-down ip link set $IFACE down

# The primary network interface
auto br0
iface br0 inet static
 bridge_ports eth0
 address 10.2.0.1
 netmask 255.0.0.0
 gateway 10.0.0.1

reboot

Installation de Docker

Ajout des dépôts docker de jessie où se trouve le paquet nécessaire.

apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys 58118E89F3A912897C070ADBF76221572C52609D; \
echo -e "deb http://apt.dockerproject.org/repo debian-jessie main" > /etc/apt/sources.list.d/docker.list; \
apt-get update -y

Installation proprement dite de Docker.

apt-get install -y docker-engine

Ajout du proxy dans l’environnement Docker.

mkdir /etc/systemd/system/docker.service.d; \
echo -e "[Service]\nEnvironment=HTTP_PROXY=http://proxy.polytech-lille.fr:3128/" > /etc/systemd/system/docker.service.d/http-proxy.conf; \
systemctl daemon-reload ;\
systemctl restart docker

Création d'un bridge personnalisé pour Docker

Pour changer le réseau par défaut de Docker, on doit dans un premier temps détruire toute la configuration existante.

service docker stop; \
ip link set docker0 down; \
brctl delbr docker0; \
iptables -t nat -F POSTROUTING

On doit ensuite indiquer au démon de Docker d'utiliser notre bridge br0 précédemment créée. On édite pour cela /lib/systemd/system/docker.service. On y indique aussi que l'on souhaite que les conteneurs prennent leurs adresses dans la plage donnée par l'option fixed-cidr. Par défaut, la passerelle par défaut est construite en fonction de l'adresse de l'hôte du conteneur (ici 10.2.0.1 au lieu de 10.0.0.1). Nous devons également la préciser ici. Voici la à exécuter pour modifier le fichier :

sed -i 's/ExecStart=\/usr\/bin\/docker daemon -H fd:\/\//ExecStart=\/usr\/bin\/docker daemon -H fd:\/\/ --fixed-cidr=10.2.0.1\/16 -b=br0 --default-gateway=10.0.0.1/' /lib/systemd/system/docker.service;

On recharge le démon pour prendre en compte la configuration.

systemctl daemon-reload; \
service docker restart

On peut alors vérifier que notre configuration a bien été prise en compte avec les commandes suivantes.

ifconfig; \
iptables -t nat -L -n

Mise en place des scripts

SSH

Sur la VM

On doit dans un premier temps établir une connexion sécurisée en ssh entre l'hyperviseur et la vm Xen. Sur la VM xen, il faut créer :

mkdir /root/.ssh/; \
touch /root/.ssh/authorized_keys

Sur l'hyperviseur

ssh-keygen -t rsa -b 4096; \
cat /root/.ssh/id_rsa.pub | ssh root@10.2.0.1 "cat - >> /root/.ssh/authorized_keys"; \
exec ssh-agent bash; \
ssh-add;

Si la clé est déja crée (si ce n'est pas la première VM), seulement la commande :

cat /root/.ssh/id_rsa.pub | ssh root@10.2.0.1 "cat - >> /root/.ssh/authorized_keys"

Base de données

Une base de données est nécessaire pour stocker les associations entre conteneur, adresse ip, nom de domaine et login.
On crée cette base sur l'hyperviseur :

sqlite3 /root/projet.db "PRAGMA foreign_keys=OFF;BEGIN TRANSACTION \
CREATE TABLE users(login varchar(10), vlan int, docker_ip varchar(15),domain varchar(50) primary key);COMMIT;"

Scripts

Nous avons ensuite besoin transférer sur l'hyperviseur nos trois scripts principaux disponibles aux URL suivants :

• Script de création (Usage: create.sh USER VLAN DOMAIN_NAME)
• Script de suppression (Usage: delete.sh NOM_DE_DOMAINE)
• Script de vérification de cohérence IP-Nom de Domaine (Usage: checkIP.sh)
• Script de construction des règles de proxy (Usage: proxyBuild.sh)

Pour récupérer les fichiers, nous conseillons un copier-coller, le wget insert un caractère non reconnu qui empêche le bon fonctionnement. Les variables de chaque scripts sont à adapter au contexte d’exécution. (e.g. HOST=jinx à remplacer par le nom de la vm). Il faut également penser à donner les droits d'exécution aux scripts:

chmod u+x *.sh

De plus, le script suivant est également nécessaire sur la machine xen :

• Script de récupération de l'IP (Usage: fetchinfo.sh DOMAIN_NAME)

Ce script permet de récupérer l'adresse IP d'un domaine donné grâce aux commandes natives de docker.

Tests

Voici une archive qui réunit le nécessaire pour construire des conteneurs avec un site web nginx autonome, accessible en ssh.

• docker_web.tar.gz

Après extraction dans la machine virtuelle, on construit l'image personnalisée en indiquant le dossier décompressé:

docker build -t IMAGE_NAME /path/to/webserv

Le nom de l'image est à indiquer dans le script de création create.sh. Voici ensuite quelques commandes qui permettent de tester nos outils depuis l'hyperviseur.

./create.sh rex 2 domain.name.tld
./checkIP.sh

On peut alors vérifier que la ligne a correctement été insérée dans la base de données.

squilte3 /root/projet.db "SELECT * FROM users;"

On peut ensuite construire le proxy inverse et tester l'accessibilité de notre conteneur.

./proxyBuild.sh
 wget --header "Host: domain.name.tld" http://hypervisor-address/