Utiliser Gentoo et Calculate Linux

Installer et utiliser LXC sur Gentoo / Calculate Linux

Cet article a été mis à jour, vous consultez ici une archive de cet article!
Table des matières
  1. Présentation de LXC
  2. Prérequis pour l'installation
    1. Partie kernel
    2. Partie réseau
  3. Installation de LXC
    1. Installation commune
    2. Installations optionnelles
      1. Cas Debian
      2. Cas Fedora/CentOS
  4. Utiliser LXC
    1. Où sont les fichiers
    2. Créer un conteneur

conteneurs







Présentation de LXC





LXC, contraction de l’anglais LinuX Containers est un système de virtualisation, utilisant l'isolation comme méthode de cloisonnement au niveau du système d'exploitation. Il est utilisé pour faire fonctionner des environnements Linux isolés les uns des autres dans des conteneurs partageant le même noyau et une plus ou moins grande partie du système hôte. Le conteneur apporte une virtualisation de l'environnement d'exécution (Processeur, Mémoire vive, réseau, système de fichier… ) et non pas de la machine. Pour cette raison, on parle de « conteneur » et non de machine virtuelle.



Ce système est similaire aux autres systèmes de virtualisations au niveau du système d'exploitation comme openVZ.





Prérequis pour l'installation





Tout le long de l'article, j'ai utilisé une CSS (CalculateLinux Server Scratch), avec le noyau 3.14.22.





Partie kernel





LXC a besoin des fonctionnalités CGROUP du noyau linux.



Ces valeurs de configuration doivent être positionnées à y :



Code BASH :
CONFIG_NAMESPACES=y
CONFIG_UTS_NS=y
CONFIG_IPC_NS=y
CONFIG_USER_NS=y
CONFIG_PID_NS=y
CONFIG_NET_NS=y
CONFIG_CGROUPS=y
CONFIG_CGROUP_DEVICE=y
CONFIG_CPUSETS=y
CONFIG_DEVPTS_MULTIPLE_INSTANCES=y
CONFIG_CGROUP_FREEZER=y
CONFIG_VETH=y
CONFIG_MACVLAN=y
CONFIG_MACVTAP=y
CONFIG_BRIDGE=y




On peut trouver ces valeurs via la commande suivante :



Code BASH :
zcat /proc/config.gz




Si tout n'est pas sur "y" :



Désactiver le FLAG minimal :

Code BASH :
echo "sys-kernel/calculate-sources -minimal" >> /etc/portage/package.use/custom




Puis réémerger le noyau :

Code BASH :
emerge -q sys-kernel/calculate-sources




Se rendre dans les sources :

Code BASH :
cd /usr/src/linux




Nettoyer les compilations précédentes :

Code BASH :
make distclean




Copier la configuration actuelle dans .config :

Code BASH :
zcat /proc/config.gz > .config




Passer à y les valeurs non définies :



Voici une commande sympathique pour vérifier tout d'un coup :

Code BASH :
grep CONFIG_NAMESPACES .config ; \
grep CONFIG_UTS .config ; \
grep CONFIG_IPC .config ; \
grep CONFIG_USER_NS .config ; \
grep CONFIG_PID_NS .config ; \
grep CONFIG_NET_NS .config ; \
grep CONFIG_CGROUPS .config ; \
grep CONFIG_CGROUP_DEVICE .config ; \
grep CONFIG_CPUSETS .config ; \
grep CONFIG_DEVPTS_MULTIPLE_INSTANCES .config ; \
grep CONFIG_CGROUP_FREEZER .config ; \
grep CONFIG_VETH .config ; \
grep CONFIG_MACVLAN .config ; \
grep CONFIG_MACVTAP .config ; \
grep CONFIG_BRIDGE .config
 




Puis éditer avec l'éditeur de son choix le fichier .config pour placer chaque valeur à y.

J'ai opté personnellement pour sed :

Code BASH :
sed -e 's/# CONFIG_CGROUP_DEVICE is not set/CONFIG_CGROUP_DEVICE=y/g' -i .config
sed -e 's/# CONFIG_CPUSETS is not set/CONFIG_CPUSETS=y/g' -i .config
sed -e 's/# CONFIG_DEVPTS_MULTIPLE_INSTANCES is not set/CONFIG_DEVPTS_MULTIPLE_INSTANCES=y/g' -i .config
sed -e 's/# CONFIG_CGROUP_FREEZER is not set/CONFIG_CGROUP_FREEZER=y/g' -i .config
sed -e 's/# CONFIG_VETH is not set/CONFIG_VETH=y/g' -i .config
sed -e 's/# CONFIG_MACVLAN is not set/CONFIG_MACVLAN=y/g' -i .config
sed -e 's/# CONFIG_MACVTAP is not set/CONFIG_MACVTAP=y/g' -i .config
sed -e 's/CONFIG_BRIDGE=m/CONFIG_BRIDGE=y/g' -i .config




Puis on recompile le noyau :

Code BASH :
make oldconfig
make
make modules_install
make install
dracut --force
#emerge @module-rebuild
#cl-setup-boot




Pour compiler plus vite, on peut passer à make l'argument -jX où X est le nombre de processeurs + 1

Pour un intel i7 avec 8 coeurs :

Code BASH :
make -j9




On redémarre ensuite pour démarrer sur le nouveau noyau :

Code BASH :
reboot




Une fois redémarré, on vérifie que les CGROUPS sont bien actifs :

Code BASH :
 mount | grep cgroup




Qui doit renvoyer ces lignes :

Citation :
cgroup_root on /sys/fs/cgroup type tmpfs (rw,nosuid,nodev,noexec,relatime,size=10240k,mode=755)

openrc on /sys/fs/cgroup/openrc type cgroup (rw,nosuid,nodev,noexec,relatime,release_agent=/lib64/rc/sh/cgroup-release-agent.sh,name=openrc)

cpuset on /sys/fs/cgroup/cpuset type cgroup (rw,nosuid,nodev,noexec,relatime,cpuset)

cpu on /sys/fs/cgroup/cpu type cgroup (rw,nosuid,nodev,noexec,relatime,cpu)

cpuacct on /sys/fs/cgroup/cpuacct type cgroup (rw,nosuid,nodev,noexec,relatime,cpuacct)

memory on /sys/fs/cgroup/memory type cgroup (rw,nosuid,nodev,noexec,relatime,memory)

devices on /sys/fs/cgroup/devices type cgroup (rw,nosuid,nodev,noexec,relatime,devices)

freezer on /sys/fs/cgroup/freezer type cgroup (rw,nosuid,nodev,noexec,relatime,freezer)

net_cls on /sys/fs/cgroup/net_cls type cgroup (rw,nosuid,nodev,noexec,relatime,net_cls)

blkio on /sys/fs/cgroup/blkio type cgroup (rw,nosuid,nodev,noexec,relatime,blkio)






Partie réseau





Pour utiliser nos conteneurs, on a besoin d'une interface réseau en mode pont (bridge).



On installe les modules réseau nécessaires :



Code BASH :
emerge -q net-misc/bridge-utils




On édite ensuite le fichier de configuration des interfaces réseaux :



Code BASH :
nano /etc/conf.d/net




On commente la configuration de l'interface en cours (chez moi enp0s3), on indique à null sa configuration et on créée le pont nommé br0 :



Code BASH :
#config_enp0s3="dhcp"
 
config_enp0s3="null"
 
# Pont réseau
config_br0="10.21.27.253/24"
routes_br0="default via 10.21.27.254"
dns_servers="10.21.27.250"
 
brctl_br0="setfd 0
sethello 10
stp off"
bridge_br0="enp0s3"




On n'oublie pas de créer le lien symbolique qui va bien et de lancer cette connexion au démarrage :



Code BASH :
ln -s /etc/init.d/net.lo /etc/init.d/net.br0
rc-update add net.br0 default




On redémarre pour vérifier le bon fonctionnement du pont réseau :

Code BASH :
reboot




On vérifie avec ifconfig que l'interface br0 ait bien son adresse IP et que les communications réseaux fonctionnent correctement.







Installation de LXC







Installation commune





Aucun FLAG par défaut n'est activé.

On va activer deux FLAG : examples et doc vont nous fournir des modèles de base tout prêt pour déployer rapidement nos conteneurs.



Code BASH :
echo "app-emulation/lxc examples doc #LXC" >> /etc/portage/package.use/custom




lxc est archtildé sur Calculate Linux, donc on l'ajoute au fichier packages.keywords :



Code BASH :
echo "app-emulation/lxc #LXC" >> /etc/portage/package.keywords/custom




Puis on lance l'installation :



Code BASH :
emerge -avq app-emulation/lxc




Voilà, c'est installé.





Installations optionnelles







Cas Debian





Si on souhaite par la suite installer un conteneur fonctionnant sous Debian, il est nécessaire d'installer dev-util/debootstrap :



Code BASH :
emerge -aqv dev-util/debootstrap






Cas Fedora/CentOS





Si on souhaite par la suite installer un conteneur fonctionnant sous Fedora ou CentOS, il est nécessaire d'installer sys-apps/yum qui installera aussi en dépendance app-arch/rpm .

On ajoute quelques paquets au fichier package.keywords et ajoutons les USE lua et python à RPM :



Code BASH :
echo "sys-apps/yum #LXC" >> /etc/portage/package.keywords/custom 
echo "dev-python/sqlitecachec #LXC" >> /etc/portage/package.keywords/custom 
echo "dev-lang/python sqlite #LXC" >> /etc/portage/package.use/custom 
echo "dev-libs/libxml2 python #LXC" >> /etc/portage/package.use/custom
echo "app-arch/rpm lua python #LXC" >> /etc/portage/package.use/custom




On installe ensuite yum :



Code BASH :
emerge -aqv sys-apps/yum






Utiliser LXC







Où sont les fichiers





Tous les fichiers sont stockés dans /etc/lxc.

Un dossier sera créé par conteneur, et contient :

  • Un dossier rootfs (le / du conteneur)
  • Un fichier config (la configuration du conteneur).







Créer un conteneur





La commande pour créer un conteneur est lxc-create et s'utilise de cette manière :



Code BASH :
lxc-create -n $NomDuConteneur -t $TypeDuConteneur




Voici quelques syntaxes :



Pour un conteneur nommé alpha de type Gentoo :

Code BASH :
lxc-create -n alpha-t gentoo




Pour un conteneur nommé beta de type Debian :

Code BASH :
lxc-create -n beta -t debian




Pour un conteneur nommé gamma de type Fedora :

Code BASH :
lxc-create -n gamma -t fedora




Pour un conteneur nommé delta de type CentOS :

Code BASH :
lxc-create -n delta -t centos